Типы и методы пакета net языка Go

type Addr

type Addr интерфейс {
	Network() string // имя сети (например, "tcp", "udp")
	String() string // строковая форма адреса (например, "192.0.2.1:25", "[2001:db8::1]:80")
}

Addr представляет адрес конечной точки сети.

Два метода [Addr.Network] и [Addr.String] условно возвращают строки, которые могут быть переданы в качестве аргументов в Dial, но точная форма и значение строк зависят от реализации.

func InterfaceAddrs

func InterfaceAddrs() ([]Addr, error)

InterfaceAddrs возвращает список адресов одноадресных интерфейсов системы.

Возвращаемый список не идентифицирует связанный с ним интерфейс; для получения более подробной информации используйте Interfaces и Interface.Addrs.

type AddrError

type AddrError struct {
	строка Err
	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

type Buffers [][]byte

Buffers содержит ноль или более байтов для записи.

На некоторых машинах для определенных типов соединений это оптимизируется в специфическую для ОС операцию пакетной записи (например, “writev”).

func (*Buffers) Read

func (v *Буферы) Read(p []byte) (n int, err error)

Чтение из буферов.

Read реализует io.Reader для буферов.

Read изменяет фрагмент v, а также v[i] для 0 <= i < len(v), но не изменяет v[i][j] для любых i, j.

func (*Buffers) WriteTo

func (v *Буферы) WriteTo(w io.Writer) (n int64, err error)

WriteTo записывает содержимое буферов в w.

WriteTo реализует io.WriterTo для буферов.

WriteTo изменяет фрагмент v, а также v[i] для 0 <= i < len(v), но не изменяет v[i][j] для любых i, j.

type Conn ¶

type Conn interface {
	// Read считывает данные из соединения.
	// Чтение можно сделать тайм-аутом и вернуть ошибку по истечении фиксированного
	// времени; см. SetDeadline и SetReadDeadline.
	Read(b []byte) (n int, err error)

	// Write записывает данные в соединение.
	// Запись может быть сделана так, чтобы тайм-аут и возврат ошибки происходили через фиксированное
	// времени; см. SetDeadline и SetWriteDeadline.
	Write(b []byte) (n int, err error)

	// Close закрывает соединение.
	// Любые заблокированные операции чтения или записи будут разблокированы и вернут ошибку.
	Close() error

	// LocalAddr возвращает адрес локальной сети, если он известен.
	LocalAddr() Addr

	// RemoteAddr возвращает адрес удаленной сети, если он известен.
	RemoteAddr() Addr

	// SetDeadline устанавливает крайние сроки чтения и записи, связанные
	// с данным соединением. Это эквивалентно вызову обеих функций.
	// SetReadDeadline и SetWriteDeadline.
	//
	// Крайний срок - это абсолютное время, по истечении которого операции ввода-вывода
	// прекращаются, а не блокируются. Крайний срок применяется ко всем будущим
	// и ожидающим операциям ввода-вывода, а не только к непосредственно следующему вызову
	// чтения или записи. После превышения крайнего срока
	// соединение можно обновить, установив крайний срок в будущем.
	//
	// Если крайний срок превышен, вызов Read или Write или других
	// методы ввода/вывода вернут ошибку, обернутую в os.ErrDeadlineExceeded.
	// Это можно проверить с помощью errors.Is(err, os.ErrDeadlineExceeded).
	// Метод Timeout ошибки вернет true, но обратите внимание, что существуют
	// есть и другие возможные ошибки, для которых метод Timeout
	// вернет true, даже если срок не был превышен.
	//
	// Таймаут простоя может быть реализован путем многократного продления
	// крайнего срока после успешных вызовов чтения или записи.
	//
	// Нулевое значение t означает, что операции ввода-вывода не будут выполняться по тайм-ауту.
	SetDeadline(t time.Time) error

	// SetReadDeadline устанавливает крайний срок для будущих вызовов Read
	// и любого заблокированного в данный момент вызова Read.
	// Нулевое значение t означает, что операции Read не будут завершаться.
	SetReadDeadline(t time.Time) error

	// SetWriteDeadline устанавливает крайний срок для будущих вызовов записи
	// и любого заблокированного в данный момент вызова Write.
	// Даже если запись завершится, она может вернуть n > 0, указывая на то, что
	// часть данных была успешно записана.
	// Нулевое значение t означает, что Write не будет завершаться.
	SetWriteDeadline(t time.Time) error
}

Conn - это общее потоково-ориентированное сетевое соединение.

Несколько горутинов могут вызывать методы на 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”. Зона определяет область действия буквального IPv6-адреса, как определено в RFC 4007. Функции 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”, за которой следует двоеточие и литеральный номер протокола или имя протокола, а адрес имеет вид “host”. Хост должен быть буквальным 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

func (e *DNSConfigError) Unwrap() error

type DNSError

type DNSError struct {
	UnwrapErr error // ошибка, возвращаемая методом [DNSError.Unwrap], может быть nil
	Err string // описание ошибки
	Name string // искомое имя
	Server string // используемый сервер
	IsTimeout bool // если true, то таймаут истек; не все таймауты устанавливают это значение
	IsTemporary bool // если true, то ошибка временная; не все ошибки устанавливают это

	// IsNotFound устанавливается в true, если запрашиваемое имя не
	// не содержит записей запрашиваемого типа (данные не найдены),
	// или само имя не найдено (NXDOMAIN).
	IsNotFound bool
}

DNSError представляет ошибку поиска DNS.

func (*DNSError) Error

func (e *DNSError) Error() string

func (*DNSError) Temporary

func (e *DNSError) Temporary() bool

Temporary сообщает, является ли ошибка DNS временной. Это не всегда известно; поиск DNS может завершиться неудачей из-за временной ошибки и вернуть DNSError, для которого Temporary возвращает false.

func (*DNSError) Timeout

func (e *DNSError) Timeout() bool

Таймаут сообщает о том, что поиск DNS завершился по таймеру. Это не всегда известно; поиск DNS может завершиться неудачей из-за таймаута и вернуть DNSError, для которого Timeout возвращает false.

func (*DNSError) Unwrap

func (e *DNSError) Unwrap() error

Unwrap возвращает e.UnwrapErr.

type Dialer

type Dialer struct {
	// Timeout - это максимальное количество времени, в течение которого набор будет ждать
	// завершения соединения. Если также задано значение Deadline, то соединение может завершиться
	// раньше.
	//
	// По умолчанию таймаут отсутствует.
	//
	// При использовании TCP и наборе имени хоста с несколькими IP
	// адресов, тайм-аут может быть разделен между ними.
	//
	// С таймаутом или без него операционная система может установить
	// свой собственный более ранний тайм-аут. Например, тайм-ауты TCP
	// часто составляет около 3 минут.
	Timeout time.Duration

	// Крайний срок - это абсолютный момент времени, после которого набор номера
	// завершится неудачей. Если установлен таймаут, то отказ может произойти раньше.
	// Ноль означает отсутствие крайнего срока, или зависит от операционной системы.
	// как в случае с параметром Timeout.
	Deadline time.Time

	// LocalAddr - локальный адрес, который следует использовать при наборе
	// адреса. Адрес должен быть совместимого типа для
	// набираемой сети.
	// Если nil, локальный адрес выбирается автоматически.
	LocalAddr Addr

	// В DualStack ранее была включена поддержка RFC 6555 Fast Fallback
	// поддержка, также известная как "Happy Eyeballs", при которой IPv4
	// пробует вскоре, если IPv6 оказывается неправильно сконфигурированным и
	// зависает.
	//
	// Утративший силу: Fast Fallback включен по умолчанию. Чтобы
	// отключить, установите FallbackDelay в отрицательное значение.
	DualStack bool

	// FallbackDelay задает время ожидания перед тем, как
	// порождения соединения RFC 6555 Fast Fallback. То есть это
	// это время ожидания успеха IPv6, прежде чем
	// предположить, что IPv6 неправильно сконфигурирован, и вернуться к
	// IPv4.
	//
	// Если значение равно нулю, то по умолчанию используется задержка 300 мс.
	// Отрицательное значение отключает поддержку быстрого отката.
	FallbackDelay time.Duration

	// KeepAlive задает интервал между попытками сохранить активное сетевое соединение.
	// зондами активного сетевого соединения.
	//
	// KeepAlive игнорируется, если KeepAliveConfig.Enable равен true.
	//
	// Если значение равно нулю, то зонды keep-alive отправляются со значением по умолчанию.
	// (в настоящее время 15 секунд), если это поддерживается протоколом и операционной // системой.
	// системой. Сетевые протоколы или операционные системы, которые.
	// не поддерживают keep-alive, игнорируют это поле.
	// Если значение отрицательное, то запросы keep-alive отключаются.
	KeepAlive time.Duration

	// KeepAliveConfig определяет конфигурацию зонда keep-alive
	// для активного сетевого соединения, если оно поддерживается
	// протоколом и операционной системой.
	//
	// Если KeepAliveConfig.Enable равен true, то зонды keep-alive включены.
	// Если KeepAliveConfig.Enable ложно и KeepAlive отрицательно,
	// зонды keep-alive отключены.
	KeepAliveConfig KeepAliveConfig

	// Resolver опционально указывает альтернативный резолвер для использования.
	Resolver *Resolver

	// Cancel - необязательный канал, закрытие которого указывает, что
	// набор должен быть отменен. Не все типы циферблатов поддерживают
	// отмену.
	//
	// Утратил актуальность: Вместо этого используйте DialContext.
	Cancel <-chan struct{}

	// Если Control не nil, то вызывается после создания сетевого
	// соединения, но до фактического набора номера.
	//
	// Параметры сети и адреса, передаваемые в функцию Control, не являются
	// обязательно те, которые передаются в Dial. Вызов Dial с сетями TCP
	// приведет к вызову функции Control с параметрами "tcp4" или "tcp6",
	// UDP-сети станут "udp4" или "udp6", IP-сети - "ip4" или "ip6",
	// а другие известные сети передаются как есть.
	//
	// Контроль игнорируется, если ControlContext не равен nil.
	Control func(network, address string, c syscall.RawConn) error

	// Если ControlContext не равен nil, то эта функция вызывается после создания сетевого
	// соединения, но до фактического набора номера.
	//
	// Параметры сети и адреса, передаваемые в функцию ControlContext, не являются
	// обязательно те, что переданы в Dial. Вызов Dial с сетями TCP
	// приведет к вызову функции ControlContext с параметрами "tcp4" или "tcp6",
	// UDP-сети станут "udp4" или "udp6", IP-сети - "ip4" или "ip6",
	// а другие известные сети передаются как есть.
	//
	// Если ControlContext не равен nil, Control игнорируется.
	ControlContext func(ctx context.Context, network, address string, c syscall.RawConn) error
	// содержит отфильтрованные или неэкспонированные поля
}

Dialer содержит опции для соединения с адресом.

Нулевое значение для каждого поля эквивалентно дозвону без этой опции. Поэтому набор номера с нулевым значением Dialer эквивалентен простому вызову функции Dial.

Безопасно вызывать методы Dialer одновременно.

package main

import (
	"context"
	"log"
	"net"
	"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)
	}
}

package main

import (
	"context"
	"log"
	"net"
	"time"
)

func main() {
	// DialUnix does not take a context.Context parameter. This example shows
	// how to dial a Unix socket with a Context. Note that the Context only
	// applies to the dial operation; it does not apply to the connection once
	// it has been established.
	var d net.Dialer
	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
	defer cancel()

	d.LocalAddr = nil // if you have a local addr, add it here
	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)
	}
}

func (*Dialer) Dial

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

Dial соединяется с адресом в указанной сети.

Описание параметров сети и адреса см. в func Dial.

Dial внутренне использует context.Background; чтобы указать контекст, используйте Dialer.DialContext.

func (*Dialer) DialContext

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

DialContext соединяется с адресом в названной сети, используя предоставленный контекст.

Предоставленный контекст должен быть ненулевым. Если срок действия контекста истекает до завершения соединения, возвращается ошибка. После успешного соединения любое истечение срока действия контекста не повлияет на соединение.

При использовании TCP, когда хост в параметре адреса разрешается в несколько сетевых адресов, таймаут набора номера (из d.Timeout или ctx) распределяется на каждый последовательный набор, так что каждому дается соответствующая доля времени для соединения. Например, если у хоста есть 4 IP-адреса и таймаут составляет 1 минуту, то на соединение с каждым отдельным адресом будет дано 15 секунд, прежде чем будет выполнена попытка соединения со следующим адресом.

Описание параметров сети и адреса см. в func Dial.

func (*Dialer) MultipathTCP

func (d *Dialer) MultipathTCP() bool

MultipathTCP сообщает, будет ли использоваться MPTCP.

Этот метод не проверяет, поддерживается ли MPTCP операционной системой или нет.

func (*Dialer) SetMultipathTCP

func (d *Dialer) SetMultipathTCP(use bool)

SetMultipathTCP направляет методы Dial на использование или неиспользование MPTCP, если это поддерживается операционной системой. Этот метод отменяет системное значение по умолчанию и настройку GODEBUG=multipathtcp=…, если таковая имеется.

Если MPTCP недоступен на хосте или не поддерживается сервером, методы набора будут возвращаться к 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 анализирует s как IEEE 802 MAC-48, EUI-48, EUI-64 или 20-октетный адрес канального уровня IP поверх InfiniBand, используя один из следующих форматов:

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-адресом.

func IPv4

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

IPv4 возвращает IP-адрес (в 16-байтовой форме) IPv4-адреса a.b.c.d.

package main

import (
	"fmt"
	"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 (“192.0.2.1”), IPv6 (“2001:db8::68”) или IPv4-mapped IPv6 ("::ffff:192.0.2.1"). Если s не является корректным текстовым представлением IP-адреса, ParseIP возвращает nil. Возвращаемый адрес всегда имеет размер 16 байт, IPv4-адреса возвращаются в IPv4-сопоставленной IPv6-форме.

package main

import (
	"fmt"
	"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) AppendText

func (ip IP) AppendText(b []byte) ([]byte, error)

AppendText реализует интерфейс encoding.TextAppender. Кодировка такая же, как и у IP.String, за одним исключением: Если len(ip) равно нулю, то ничего не добавляется.

func (IP) DefaultMask

func (ip IP) DefaultMask() IPMask

DefaultMask возвращает IP-маску по умолчанию для IP-адреса ip. Маски по умолчанию есть только у IPv4-адресов; DefaultMask возвращает nil, если ip не является действительным IPv4-адресом.

package main

import (
	"fmt"
	"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 считаются равными.

package main

import (
	"fmt"
	"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. Возвращает true, даже если ip находится в частном адресном пространстве IPv4 или локальном адресном пространстве IPv6 одноадресной рассылки.

package main

import (
	"fmt"
	"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 интерфейсно-локальным многоадресным адресом.

package main

import (
	"fmt"
	"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 адресом link-local multicast.

package main

import (
	"fmt"
	"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 адресом link-local unicast.

package main

import (
	"fmt"
	"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 адресом loopback.

package main

import (
	"fmt"
	"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 адресом многоадресной рассылки.

package main

import (
	"fmt"
	"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

func (ip IP) IsPrivate() bool

IsPrivate сообщает, является ли ip частным адресом, в соответствии с RFC 1918 (IPv4-адреса) и RFC 4193 (IPv6-адреса).

package main

import (
	"fmt"
	"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-адресом “::”.

package main

import (
	"fmt"
	"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

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

MarshalText реализует интерфейс encoding.TextMarshaler. Кодировка та же, что возвращается IP.String, за одним исключением: Если len(ip) равен нулю, возвращается пустой фрагмент.

func (IP) Mask

func (ip IP) Mask(mask IPMask) IP

Mask возвращает результат маскирования IP-адреса ip с помощью маски.

func (IP) String

func (ip IP) String() string

String возвращает строковую форму IP-адреса ip. Возвращается одна из 4 форм:

• “”, если ip имеет длину 0
• десятичная точка (“192.0.2.1”), если ip - это IPv4 или IP4-сопоставленный IPv6-адрес.
• IPv6 в соответствии с RFC 5952 (“2001:db8::1”), если ip - действительный IPv6-адрес
• шестнадцатеричная форма ip без знаков препинания, если другие случаи не применимы.

package main

import (
	"fmt"
	"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.

package main

import (
	"fmt"
	"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-адрес ip в 4-байтовое представление. Если ip не является IPv4-адресом, To4 возвращает nil.

package main

import (
	"fmt"
	"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 (*IP) UnmarshalText

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

UnmarshalText реализует интерфейс encoding.TextUnmarshaler. IP-адрес ожидается в форме, принимаемой ParseIP.

type IPAddr

type IPAddr struct {
	IP-АДРЕС
	Zone string // Зона масштабируемой адресации IPv6
}

IPAddr представляет адрес конечной точки IP.

func ResolveIPAddr

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

ResolveIPAddr возвращает адрес конечной IP-точки.

Сеть должна быть именем IP-сети.

Если хост в параметре address не является литеральным IP-адресом, ResolveIPAddr преобразует адрес в адрес конечной точки IP. В противном случае он анализирует адрес как литеральный IP-адрес. В качестве параметра адреса может использоваться имя хоста, но это не рекомендуется, так как будет возвращен не более одного из IP-адресов имени хоста.

Описание параметров сети и адреса см. в разделе func Dial.

func (*IPAddr) Сеть

func (a *IPAddr) Network() string

Network возвращает сетевое имя адреса, “ip”.

func (*IPAddr) String

func (a *IPAddr) String() string

type IPConn

type IPConn struct {
	// содержит отфильтрованные или неотправленные поля
}

IPConn - это реализация интерфейсов Conn и PacketConn для сетевых IP-соединений.

func DialIP

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

DialIP действует как Dial для IP-сетей.

Сеть должна быть именем IP-сети; подробности см. в func Dial.

Если laddr равен nil, автоматически выбирается локальный адрес. Если поле IP в raddr равно nil или является неопределенным IP-адресом, предполагается локальная система.

func ListenIP

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

ListenIP действует как ListenPacket для IP-сетей.

Сеть должна быть именем IP-сети; подробности см. в func Dial.

Если поле IP в laddr равно nil или неопределенному IP-адресу, ListenIP прослушивает все доступные IP-адреса локальной системы, кроме IP-адресов многоадресной рассылки.

func (*IPConn) Закрыть

func (c *IPConn) Close() error

Close закрывает соединение.

func (*IPConn) File

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

File возвращает копию базового файла os.File. Ответственность за закрытие f по завершении работы лежит на вызывающей стороне. Закрытие c не влияет на f, а закрытие f не влияет на c.

Дескриптор файла возвращаемого os.File отличается от дескриптора соединения. Попытка изменить свойства оригинала с помощью этого дубликата может привести к желаемому результату, а может и не привести.

func (*IPConn) LocalAddr

func (c *IPConn) LocalAddr() Addr

LocalAddr возвращает адрес локальной сети. Возвращаемый Addr является общим для всех вызовов LocalAddr, поэтому не следует его изменять.

func (*IPConn) Read

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

Read реализует метод Conn Read.

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

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 могут быть использованы для манипулирования опциями сокетов IP-уровня в oob.

func (*IPConn) RemoteAddr

func (c *IPConn) RemoteAddr() Addr

RemoteAddr возвращает удаленный сетевой адрес. Возвращаемый Addr является общим для всех вызовов RemoteAddr, поэтому не изменяйте его.

func (*IPConn) SetDeadline

func (c *IPConn) SetDeadline(t time.Time) error

SetDeadline реализует метод Conn SetDeadline.

func (*IPConn) SetReadBuffer

func (c *IPConn) SetReadBuffer(bytes int) error

SetReadBuffer устанавливает размер буфера приема операционной системы, связанного с соединением.

func (*IPConn) SetReadDeadline

func (c *IPConn) SetReadDeadline(t time.Time) error

SetReadDeadline реализует метод Conn SetReadDeadline.

func (*IPConn) SetWriteBuffer

func (c *IPConn) SetWriteBuffer(bytes int) error

SetWriteBuffer устанавливает размер буфера передачи операционной системы, связанного с соединением.

func (*IPConn) SetWriteDeadline

func (c *IPConn) SetWriteDeadline(t time.Time) error

SetWriteDeadline реализует метод Conn SetWriteDeadline.

func (*IPConn) SyscallConn

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

SyscallConn возвращает необработанное сетевое соединение. Оно реализует интерфейс syscall.Conn.

func (*IPConn) Write

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

Write реализует метод Conn Write.

func (*IPConn) WriteMsgIP

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

WriteMsgIP записывает сообщение на addr через c, копируя полезную нагрузку из b и связанные с ней внеполосные данные из oob. Возвращается количество записанных байт полезной нагрузки и внеполосных данных.

Пакеты golang.org/x/net/ipv4 и golang.org/x/net/ipv6 могут быть использованы для манипулирования опциями сокетов IP-уровня в oob.

func (*IPConn) WriteTo

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

WriteTo реализует метод PacketConn WriteTo.

func (*IPConn) WriteToIP

func (c *IPConn) WriteToIP(b []байт, addr *IPAddr) (int, error)

WriteToIP действует подобно IPConn.WriteTo, но принимает IPAddr.

type IPMask

type IPMask []байт

IPMask - это битовая маска, которая может быть использована для манипулирования IP-адресами для IP-адресации и маршрутизации.

Подробнее см. в разделе type IPNet и func ParseCIDR.

func CIDRMask

func CIDRMask(ones, bits int) IPMask

CIDRMask возвращает IPMask, состоящую из битов ‘ones’ 1, за которыми следуют 0 до общей длины ‘bits’ бит. Для маски такой формы CIDRMask является обратной величиной к IPMask.Size.

package main

import (
	"fmt"
	"net"
)

func main() {
	// This mask corresponds to a /31 subnet for IPv4.
	fmt.Println(net.CIDRMask(31, 32))

	// This mask corresponds to a /64 subnet for IPv6.
	fmt.Println(net.CIDRMask(64, 128))

}

Output:

fffffffe
ffffffffffffffff0000000000000000

func IPv4Mask

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

IPv4Mask возвращает IP-маску (в 4-байтовой форме) IPv4-маски a.b.c.d.

package main

import (
	"fmt"
	"net"
)

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

}

Output:

ffffff00

func (IPMask) Size

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

Size возвращает количество ведущих единиц и общее количество битов в маске. Если маска не имеет канонической формы - за единицами следуют нули - то Size возвращает 0, 0.

func (IPMask) String

func (m IPMask) String() string

String возвращает шестнадцатеричную форму m, без знаков препинания.

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” или “2001:db8::/48”, как определено в RFC 4632 и RFC 4291. Если маска не имеет канонической формы, возвращается строка, состоящая из IP-адреса, за которым следует символ косой черты и маска, выраженная в шестнадцатеричной форме без знаков препинания, например “198.51.100.0/c000ff00”.

type Interface

type Interface struct {
	Index int // положительное целое число, начинающееся с единицы, ноль никогда не используется
	MTU int // максимальная единица передачи
	Name string // например, "en0", "lo0", "eth0.100".
	HardwareAddr HardwareAddr // форма IEEE MAC-48, EUI-48 и EUI-64
	Flags Флаги // например, FlagUp, FlagLoopback, FlagMulticast
}

Интерфейс представляет собой сопоставление между именем и индексом сетевого интерфейса. Он также представляет информацию об объекте сетевого интерфейса.

func InterfaceByIndex

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

InterfaceByIndex возвращает интерфейс, указанный индексом.

В Solaris возвращается один из логических сетевых интерфейсов, разделяющих логический канал данных; для большей точности используйте InterfaceByName.

func InterfaceByName

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

InterfaceByName возвращает интерфейс, указанный именем.

func Интерфейсы

func Interfaces() ([]Interface, error)

Interfaces возвращает список сетевых интерфейсов системы.

func (*Interface) Addrs

func (ifi *Интерфейс) Addrs() ([]Addr, error)

Addrs возвращает список адресов одноадресных интерфейсов для конкретного интерфейса.

func (*Interface) MulticastAddrs

func (ifi *Интерфейс) 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

type KeepAliveConfig struct {
	// Если Enable равно true, то зонды keep-alive включены.
	Enable bool

	// Idle - время, в течение которого соединение должно простаивать, прежде чем
	// отправки первого зонда keep-alive.
	// Если значение равно нулю, то по умолчанию используется значение 15 секунд.
	Idle time.Duration

	// Интервал - время между зондами keep-alive.
	// Если ноль, по умолчанию используется значение 15 секунд.
	Interval time.Duration

	// Count - максимальное количество зондов keep-alive, которые
	// может остаться без ответа до разрыва соединения.
	// Если значение равно нулю, то по умолчанию используется значение 9.
	Count int
}

KeepAliveConfig содержит параметры TCP keep-alive.

Если поля Idle, Interval или Count равны нулю, выбирается значение по умолчанию. Если поле отрицательно, соответствующая опция уровня сокета будет оставлена без изменений.

Обратите внимание, что до версии Windows 10 1709 ни установка Idle и Interval по отдельности, ни изменение Count (которое обычно равно 10) не поддерживаются. Поэтому, если вы хотите настроить параметры TCP keep-alive, рекомендуется установить неотрицательные значения Idle и Interval в сочетании с -1 для Count в старых версиях Windows. Напротив, если только один из Idle и Interval установлен в неотрицательное значение, другой будет установлен в значение по умолчанию, и в конечном итоге установите оба Idle и Interval в отрицательные значения, если вы хотите оставить их без изменений.

Обратите внимание, что Solaris и ее производные не поддерживают установку Interval в неотрицательное значение и Count в отрицательное значение, или наоборот.

type ListenConfig

type ListenConfig struct {
	// Если Control не nil, то вызывается после создания сетевого
	// соединения, но до его привязки к операционной системе.
	//
	// Параметры сети и адреса, передаваемые в функцию Control, не являются
	// обязательно те, которые передаются в функцию Listen. Вызов Listen с сетями TCP
	// приведет к вызову функции Control с параметрами "tcp4" или "tcp6",
	// UDP-сети станут "udp4" или "udp6", IP-сети - "ip4" или "ip6",
	// и другие известные сети передаются как есть.
	Control func(network, address string, c syscall.RawConn) error

	// KeepAlive задает период ожидания для сетевых
	// соединений, принимаемых этим слушателем.
	//
	// KeepAlive игнорируется, если KeepAliveConfig.Enable равен true.
	//
	// Если ноль, то keep-alive включается, если поддерживается протоколом
	// и операционной системой. Сетевые протоколы или операционные системы.
	// которые не поддерживают keep-alive, игнорируют это поле.
	// Если значение отрицательно, keep-alive отключены.
	KeepAlive time.Duration

	// KeepAliveConfig определяет конфигурацию зонда keep-alive
	// для активного сетевого соединения, если оно поддерживается
	// протоколом и операционной системой.
	//
	// Если KeepAliveConfig.Enable равен true, то зонды keep-alive включены.
	// Если KeepAliveConfig.Enable ложно и KeepAlive отрицательно,
	// зонды keep-alive отключены.
	KeepAliveConfig KeepAliveConfig
	// содержит отфильтрованные или неэкспонированные поля
}

ListenConfig содержит опции для прослушивания адреса.

func (*ListenConfig) Listen

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

Listener сообщает об адресе локальной сети.

Описание параметров сети и адреса см. в разделе func Listen.

Аргумент ctx используется при разрешении адреса для прослушивания; он не влияет на возвращаемый error.

func (*ListenConfig) ListenPacket

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

ListenPacket сообщает об адресе локальной сети.

Описание параметров сети и адреса см. в func ListenPacket.

Аргумент ctx используется при разрешении адреса для прослушивания; он не влияет на возвращаемый слушатель.

func (*ListenConfig) MultipathTCP

func (lc *ListenConfig) MultipathTCP() bool

MultipathTCP сообщает, будет ли использоваться MPTCP.

Этот метод не проверяет, поддерживается ли MPTCP операционной системой или нет.

func (*ListenConfig) SetMultipathTCP

func (lc *ListenConfig) SetMultipathTCP(use bool)

SetMultipathTCP направляет метод Listen на использование или неиспользование MPTCP, если это поддерживается операционной системой. Этот метод отменяет системное значение по умолчанию и настройку GODEBUG=multipathtcp=…, если таковая имеется.

Если MPTCP недоступен на хосте или не поддерживается клиентом, метод Listen вернется к TCP.

type Listener ¶

type Listener interface {
	// Accept ожидает и возвращает следующее соединение со слушателем.
	Accept() (Conn, error)

	// Close закрывает слушателя.
	// Любые заблокированные операции Accept будут разблокированы и вернут ошибки.
	Close() error

	// Addr возвращает сетевой адрес слушателя.
	Addr() Addr
}

Listener - это общий сетевой слушатель для потоково-ориентированных протоколов.

Несколько горутинов могут одновременно вызывать методы одного Listener.

package main

import (
	"io"
	"log"
	"net"
)

func main() {
	// Listen on TCP port 2000 on all available unicast and
	// anycast IP addresses of the local system.
	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)
		}
		// Handle the connection in a new goroutine.
		// The loop then returns to accepting, so that
		// multiple connections may be served concurrently.
		go func(c net.Conn) {
			// Echo all incoming data.
			io.Copy(c, c)
			// Shut down the connection.
			c.Close()
		}(conn)
	}
}

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)

Listener сообщает об адресе локальной сети.

Сеть должна быть “tcp”, “tcp4”, “tcp6”, “unix” или “unixpacket”.

Для TCP-сетей, если параметр host в параметре address пуст или является буквальным неуказанным IP-адресом, Listen прослушивает все доступные одноадресные и одноадресные IP-адреса локальной системы. Чтобы использовать только IPv4, используйте сеть “tcp4”. В качестве адреса может использоваться имя хоста, но это не рекомендуется, поскольку в этом случае будет создан слушатель только для одного из IP-адресов хоста. Если порт в параметре адреса пустой или “0”, как в “127.0.0.1:” или “[::1]:0”, номер порта выбирается автоматически. Для определения выбранного порта можно использовать метод Addr Слушателя.

Описание параметров сети и адреса см. в func 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

type NS struct {
	Host string
}

NS представляет собой одну запись DNS NS.

func LookupNS

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

LookupNS возвращает записи DNS NS для заданного доменного имени.

Возвращаемые имена серверов имен проверяются на правильность форматирования доменных имен в формате представления. Если в ответе содержатся недопустимые имена, эти записи отфильтровываются, и вместе с оставшимися результатами возвращается ошибка, если таковая имеется.

Внутри LookupNS используется context.Background; чтобы указать контекст, используйте Resolver.LookupNS.

type OpError

type OpError struct {
	// Op - это операция, вызвавшая ошибку, например.
	// "чтение" или "запись".
	Op string

	// Net - тип сети, в которой произошла ошибка,
	// например, "tcp" или "udp6".
	Net string

	// Для операций, связанных с удаленным сетевым соединением, например.
	// набор, чтение или запись, Source - это соответствующий локальный
	// сетевой адрес.
	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

func (e *OpError) Unwrap() error

type PacketConn

type PacketConn interface {
	// ReadFrom читает пакет из соединения,
	// копируя полезную нагрузку в p. Возвращается количество
	// байт, скопированных в p, и адрес возврата, который
	// был в пакете.
	// Возвращается количество прочитанных байт (0 <= n <= len(p))
	// и любую возникшую ошибку. Вызывающая сторона всегда должна обрабатывать
	// возвращенные n > 0 байт, прежде чем рассматривать ошибку err.
	// ReadFrom можно сделать так, чтобы тайм-аут и возврат ошибки происходили через
	// фиксированного лимита времени; см. SetDeadline и SetReadDeadline.
	ReadFrom(p []byte) (n int, addr Addr, err error)

	// WriteTo записывает пакет с полезной нагрузкой p в addr.
	// WriteTo можно сделать так, чтобы по истечении фиксированного времени она завершилась и вернула ошибку.
	// фиксированного лимита времени; см. SetDeadline и SetWriteDeadline.
	// На пакетно-ориентированных соединениях таймаут записи случается редко.
	WriteTo(p []byte, addr Addr) (n int, err error)

	// Close закрывает соединение.
	// Любые заблокированные операции ReadFrom или WriteTo будут разблокированы и вернут ошибки.
	Close() error

	// LocalAddr возвращает адрес локальной сети, если он известен.
	LocalAddr() Addr

	// SetDeadline устанавливает крайние сроки чтения и записи, связанные
	// с данным соединением. Это эквивалентно вызову обеих функций.
	// SetReadDeadline и SetWriteDeadline.
	//
	// Крайний срок - это абсолютное время, по истечении которого операции ввода-вывода
	// прекращаются, а не блокируются. Крайний срок применяется ко всем будущим
	// и ожидающим операциям ввода-вывода, а не только к непосредственно следующему вызову
	// чтения или записи. После превышения крайнего срока
	// соединение можно обновить, установив крайний срок в будущем.
	//
	// Если крайний срок превышен, вызов Read или Write или других
	// методы ввода/вывода вернут ошибку, обернутую в os.ErrDeadlineExceeded.
	// Это можно проверить с помощью errors.Is(err, os.ErrDeadlineExceeded).
	// Метод Timeout ошибки вернет true, но обратите внимание, что существуют
	// есть и другие возможные ошибки, для которых метод Timeout
	// вернет true, даже если срок не был превышен.
	//
	// Таймаут ожидания может быть реализован путем многократного продления
	// крайнего срока после успешных вызовов ReadFrom или WriteTo.
	//
	// Нулевое значение t означает, что операции ввода-вывода не будут выполняться по тайм-ауту.
	SetDeadline(t time.Time) error

	// SetReadDeadline устанавливает крайний срок для будущих вызовов ReadFrom
	// и любого заблокированного в данный момент вызова ReadFrom.
	// Нулевое значение t означает, что ReadFrom не будет завершаться по времени.
	SetReadDeadline(t time.Time) error

	// SetWriteDeadline устанавливает крайний срок для будущих вызовов WriteTo
	// и любого текущего заблокированного вызова WriteTo.
	// Даже если запись завершилась, она может вернуть n > 0, указывая на то, что
	// часть данных была успешно записана.
	// Нулевое значение t означает, что WriteTo не прервется.
	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-сетей, если в параметре address значение host пустое или это буквальный неопределенный IP-адрес, ListenPacket прослушивает все доступные IP-адреса локальной системы, кроме IP-адресов многоадресной рассылки. Чтобы использовать только IPv4, используйте сеть “udp4” или “ip4:proto”. В качестве адреса можно использовать имя хоста, но это не рекомендуется, поскольку в этом случае будет создан слушатель только для одного из IP-адресов хоста. Если порт в параметре адреса пустой или “0”, как в “127.0.0.1:” или “[::1]:0”, номер порта выбирается автоматически. Для обнаружения выбранного порта можно использовать метод LocalAddr программы PacketConn.

Описание параметров сети и адреса см. в func Dial.

ListenPacket внутренне использует context.Background; чтобы указать контекст, используйте ListenConfig.ListenPacket.

type ParseError

type ParseError struct {
	// Тип - это тип ожидаемой строки, например.
	// "IP-адрес", "CIDR-адрес".
	Type string

	// Text - неправильно сформированная текстовая строка.
	Text string
}

ParseError - это тип ошибки синтаксического анализатора сетевых адресов.

func (*ParseError) Error

func (e *ParseError) Error() string

func (*ParseError) Temporary

func (e *ParseError) Temporary() bool

func (*ParseError) Timeout

func (e *ParseError) Timeout() bool

type Resolver

type Resolver struct {
	// PreferGo управляет тем, предпочтителен ли встроенный DNS-резольвер Go.
	// на платформах, где он доступен. Это эквивалентно настройке
	// GODEBUG=netdns=go, но относится только к этому резольверу.
	PreferGo bool

	// StrictErrors управляет поведением временных ошибок
	// (включая таймаут, ошибки сокетов и SERVFAIL) при использовании
	// встроенного в Go резолвера. Для запроса, состоящего из нескольких
	// подзапросов (например, поиск адреса A+AAA или переход по
	// список поиска DNS), эта опция заставляет такие ошибки прерывать
	// весь запрос, а не возвращать частичный результат. Эта опция
	// не включена по умолчанию, поскольку это может повлиять на совместимость
	// с резолверами, которые некорректно обрабатывают запросы AAAA.
	StrictErrors bool

	// Dial опционально задает альтернативный дозвон для использования
	// встроенным DNS-резольвером Go для создания TCP- и UDP-соединений
	// к службам DNS. Хост в параметре address будет
	// всегда будет буквальным IP-адресом, а не именем хоста, а
	// порт в параметре адреса будет буквальным номером порта
	// а не имя службы.
	// Если возвращаемый Conn также является PacketConn, отправленные и полученные DNS
	// сообщения должны соответствовать разделу 4.2.1 RFC 1035, "Использование UDP".
	// В противном случае DNS-сообщения, передаваемые через Conn, должны соответствовать
	// разделу 5 RFC 7766, "Выбор транспортного протокола".
	// Если nil, используется дозвонщик по умолчанию.
	Dial func(ctx context.Context, network, address string) (Conn, error)
	// содержит отфильтрованные или неэкспонированные поля
}

Резольвер ищет имена и номера.

Нулевой *Resolver эквивалентен нулевому Resolver.

func (*Resolver) LookupAddr

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

LookupAddr выполняет обратный поиск для заданного адреса, возвращая список имен, сопоставленных с этим адресом.

Возвращаемые имена проверяются на правильность форматирования доменных имен в формате представления. Если ответ содержит недопустимые имена, эти записи отфильтровываются, и вместе с оставшимися результатами, если таковые имеются, возвращается ошибка.

func (*Resolver) LookupCNAME

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

LookupCNAME возвращает каноническое имя для данного хоста. Пользователи, которым не важно каноническое имя, могут вызвать LookupHost или LookupIP напрямую; оба они позаботятся о разрешении канонического имени как части поиска.

Каноническое имя - это окончательное имя после следования нуля или более записей CNAME. LookupCNAME не возвращает ошибку, если хост не содержит записей DNS “CNAME”, при условии, что хост разрешается в адресные записи.

Возвращаемое каноническое имя проверяется на то, что оно является правильно отформатированным доменным именем формата представления.

func (*Resolver) LookupHost

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

LookupHost ищет заданный хост с помощью локального резольвера. Возвращается фрагмент адресов этого хоста.

func (*Resolver) LookupIP

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

LookupIP ищет хост для заданной сети с помощью локального резольвера. Возвращается фрагмент IP-адресов этого хоста типа, указанного network. network должен быть одним из “ip”, “ip4” или “ip6”.

func (*Resolver) LookupIPAddr

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

LookupIPAddr ищет хост с помощью локального резольвера. Возвращается фрагмент IPv4- и IPv6-адресов этого хоста.

func (*Resolver) LookupMX

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

LookupMX возвращает DNS MX-записи для заданного доменного имени, отсортированные по предпочтению.

Возвращаемые имена почтовых серверов проверяются на правильность форматирования доменных имен в формате представления. Если в ответе содержатся недопустимые имена, эти записи отфильтровываются, и вместе с оставшимися результатами, если таковые имеются, возвращается ошибка.

func (*Resolver) LookupNS

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

LookupNS возвращает NS-записи DNS для заданного доменного имени.

Возвращаемые имена серверов имен проверяются на правильность форматирования доменных имен в формате представления. Если ответ содержит недопустимые имена, эти записи отфильтровываются, и вместе с оставшимися результатами, если таковые имеются, возвращается ошибка.

func (*Resolver) LookupNetIP

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

LookupNetIP ищет хост с помощью локального резольвера. Возвращается фрагмент IP-адресов этого хоста типа, указанного в network. Сеть должна быть одной из “ip”, “ip4” или “ip6”.

func (*Resolver) LookupPort

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

LookupPort ищет порт для заданной сети и сервиса.

Сеть должна быть одной из “tcp”, “tcp4”, “tcp6”, “udp”, “udp4”, “udp6” или “ip”.

func (*Resolver) LookupSRV

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

LookupSRV пытается разрешить SRV-запрос данного сервиса, протокола и доменного имени. Протоколом является “tcp” или “udp”. Возвращаемые записи сортируются по приоритету и рандомизируются по весу в пределах приоритета.

LookupSRV строит DNS-имя для поиска в соответствии с RFC 2782. То есть, он ищет _service._proto.name. Для удобства сервисов, публикующих SRV-записи под нестандартными именами, если service и proto являются пустыми строками, LookupSRV ищет имя напрямую.

Возвращаемые имена сервисов проверяются на правильность форматирования доменных имен в формате представления. Если ответ содержит недопустимые имена, эти записи отфильтровываются и возвращается ошибка вместе с оставшимися результатами, если таковые имеются.

func (*Resolver) LookupTXT

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

LookupTXT возвращает записи DNS TXT для заданного доменного имени.

Если 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-запрос для данного сервиса, протокола и доменного имени. Протоколом является “tcp” или “udp”. Возвращаемые записи сортируются по приоритету и рандомизируются по весу в пределах приоритета.

LookupSRV строит DNS-имя для поиска в соответствии с RFC 2782. То есть, он ищет _service._proto.name. Для удобства сервисов, публикующих SRV-записи под нестандартными именами, если service и proto являются пустыми строками, LookupSRV ищет имя напрямую.

Возвращаемые имена сервисов проверяются на правильность форматирования доменных имен в формате представления. Если ответ содержит недопустимые имена, эти записи отфильтровываются, и вместе с оставшимися результатами, если таковые имеются, возвращается ошибка.

type TCPAddr

type TCPAddr struct {
	IP IP
	Port int
	Zone string // Зона масштабируемой адресации IPv6
}

TCPAddr представляет адрес конечной точки TCP.

func ResolveTCPAddr

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

ResolveTCPAddr возвращает адрес конечной точки TCP.

Сеть должна быть именем TCP-сети.

Если хост в параметре address не является литеральным IP-адресом или порт не является литеральным номером порта, ResolveTCPAddr преобразует адрес в адрес конечной точки TCP. В противном случае он разбирает адрес как пару из буквального IP-адреса и номера порта. В качестве параметра address может использоваться имя хоста, но это не рекомендуется, так как вернется не более одного из IP-адресов имени хоста.

Описание параметров сети и адреса см. в разделе func Dial.

func TCPAddrFromAddrPort

func TCPAddrFromAddrPort(addr netip.AddrPort) *TCPAddr

TCPAddrFromAddrPort возвращает addr как TCPAddr. Если addr.IsValid() равен false, то возвращаемый TCPAddr будет содержать нулевое поле IP, указывающее на неопределенный адрес, не зависящий от семейства адресов.

func (*TCPAddr) AddrPort

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 {
	// содержит отфильтрованные или неэкспонированные поля
}

TCPConn - это реализация интерфейса Conn для сетевых соединений TCP.

func DialTCP

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

DialTCP действует как Dial для сетей TCP.

Сеть должна быть именем TCP-сети; подробности см. в func Dial.

Если laddr равен nil, автоматически выбирается локальный адрес. Если поле IP в raddr равно nil или является неопределенным IP-адресом, предполагается локальная система.

func (*TCPConn) Закрыть

func (c *TCPConn) Close() error

Close закрывает соединение.

func (*TCPConn) CloseRead

func (c *TCPConn) CloseRead() error

CloseRead закрывает TCP-соединение со стороны чтения. Большинство вызывающих должны просто использовать Close.

func (*TCPConn) CloseWrite

func (c *TCPConn) CloseWrite() error

CloseWrite закрывает пишущую сторону TCP-соединения. Большинству вызывающих следует просто использовать Close.

func (*TCPConn) File

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

File возвращает копию базового файла os.File. Ответственность за закрытие f по завершении работы лежит на вызывающей стороне. Закрытие c не влияет на f, а закрытие f не влияет на c.

Дескриптор файла возвращаемого os.File отличается от дескриптора соединения. Попытка изменить свойства оригинала с помощью этого дубликата может привести к желаемому результату, а может и не привести.

func (*TCPConn) LocalAddr

func (c *TCPConn) LocalAddr() Addr

LocalAddr возвращает адрес локальной сети. Возвращаемый Addr является общим для всех вызовов LocalAddr, поэтому не изменяйте его.

func (*TCPConn) MultipathTCP

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

MultipathTCP сообщает, использует ли текущее соединение MPTCP.

Если Multipath TCP не поддерживается хостом, другим пиром или намеренно/случайно отфильтровывается каким-либо устройством между ними, будет выполнен откат к TCP. Этот метод делает все возможное, чтобы проверить, используется ли MPTCP или нет.

В Linux больше условий проверяется на ядрах >= v5.16, что улучшает результаты.

func (*TCPConn) Read

func (c *TCPConn) Read(b []byte) (int, error)

Read реализует метод Conn Read.

func (*TCPConn) ReadFrom

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

ReadFrom реализует метод io.ReaderFrom ReadFrom.

func (*TCPConn) RemoteAddr

func (c *TCPConn) RemoteAddr() Addr

RemoteAddr возвращает адрес удаленной сети. Возвращаемый Addr является общим для всех вызовов RemoteAddr, поэтому не изменяйте его.

func (*TCPConn) SetDeadline

func (c *TCPConn) SetDeadline(t time.Time) error

SetDeadline реализует метод Conn SetDeadline.

func (*TCPConn) SetKeepAlive

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

SetKeepAlive устанавливает, должна ли операционная система отправлять сообщения keep-alive на соединение.

func (*TCPConn) SetKeepAliveConfig

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

SetKeepAliveConfig настраивает сообщения keep-alive, отправляемые операционной системой.

func (*TCPConn) SetKeepAlivePeriod

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

SetKeepAlivePeriod устанавливает время, в течение которого соединение должно простаивать, прежде чем TCP начнет посылать keepalive зонды.

Обратите внимание, что вызов этого метода на Windows до Windows 10 версии 1709 сбросит KeepAliveInterval на системное значение по умолчанию, которое обычно составляет 1 секунду.

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 управляет тем, должна ли операционная система задерживать передачу пакетов в надежде отправить меньше пакетов (алгоритм Нагла). По умолчанию установлено значение true (без задержки), что означает, что данные отправляются как можно быстрее после записи.

func (*TCPConn) SetReadBuffer

func (c *TCPConn) SetReadBuffer(bytes int) error

SetReadBuffer устанавливает размер буфера приема операционной системы, связанного с соединением.

func (*TCPConn) SetReadDeadline

func (c *TCPConn) SetReadDeadline(t time.Time) error

SetReadDeadline реализует метод Conn SetReadDeadline.

func (*TCPConn) SetWriteBuffer

func (c *TCPConn) SetWriteBuffer(bytes int) error

SetWriteBuffer устанавливает размер буфера передачи операционной системы, связанного с соединением.

func (*TCPConn) SetWriteDeadline

func (c *TCPConn) SetWriteDeadline(t time.Time) error

SetWriteDeadline реализует метод Conn SetWriteDeadline.

func (*TCPConn) SyscallConn

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

SyscallConn возвращает необработанное сетевое соединение. Оно реализует интерфейс syscall.Conn.

func (*TCPConn) Write

func (c *TCPConn) Write(b []byte) (int, error)

Write реализует метод записи Conn.

func (*TCPConn) WriteTo

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

WriteTo реализует метод io.WriterTo WriteTo.

type TCPListener

type TCPListener struct {
	// содержит отфильтрованные или неэкспонированные поля
}

TCPListener - это сетевой слушатель TCP. Клиенты обычно должны использовать переменные типа Listener, а не предполагать, что это TCP.

func ListenTCP

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

ListenTCP действует как Listen для сетей TCP.

Сеть должна быть именем TCP-сети; подробности см. в func Dial.

Если поле IP в laddr равно nil или неопределенному IP-адресу, ListenTCP прослушивает все доступные одноадресные и одноадресные IP-адреса локальной системы. Если поле Port в laddr равно 0, номер порта выбирается автоматически.

func (*TCPListener) Accept

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

Accept реализует метод Accept в интерфейсе Listener; он ожидает следующего вызова и возвращает общий 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

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

SyscallConn возвращает необработанное сетевое соединение. Оно реализует интерфейс syscall.Conn.

Возвращаемое RawConn поддерживает только вызов Control. Чтение и запись возвращают ошибку.

type UDPAddr

type UDPAddr struct {
	IP IP
	Порт int
	Zone string // Зона масштабируемой адресации IPv6
}

UDPAddr представляет адрес конечной точки UDP.

func ResolveUDPAddr

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

ResolveUDPAddr возвращает адрес конечной точки UDP.

Сеть должна быть именем UDP-сети.

Если хост в параметре address не является литеральным IP-адресом или порт не является литеральным номером порта, ResolveUDPAddr преобразует адрес в адрес конечной точки UDP. В противном случае он разбирает адрес как пару из буквального IP-адреса и номера порта. В качестве параметра address может использоваться имя хоста, но это не рекомендуется, так как вернется не более одного из IP-адресов имени хоста.

Описание параметров сети и адреса см. в разделе func Dial.

func UDPAddrFromAddrPort

func UDPAddrFromAddrPort(addr netip.AddrPort) *UDPAddr

UDPAddrFromAddrPort возвращает addr как UDPAddr. Если addr.IsValid() равен false, то возвращаемый UDPAddr будет содержать нулевое поле IP, указывающее на неопределенный адрес, не зависящий от семейства адресов.

func (*UDPAddr) AddrPort

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 {
	// содержит отфильтрованные или неэкспонированные поля
}

UDPConn - это реализация интерфейсов Conn и PacketConn для сетевых соединений UDP.

func DialUDP

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

DialUDP действует как Dial для сетей UDP.

Сеть должна быть именем UDP-сети; подробности см. в func Dial.

Если laddr равно nil, автоматически выбирается локальный адрес. Если поле IP в raddr равно nil или является неопределенным IP-адресом, предполагается локальная система.

func ListenMulticastUDP

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

ListenMulticastUDP действует подобно ListenPacket для UDP сетей, но принимает групповой адрес на определенном сетевом интерфейсе.

Сеть должна быть именем UDP-сети; подробности см. в func Dial.

ListenMulticastUDP прослушивает все доступные IP-адреса локальной системы, включая групповой, многоадресный IP-адрес. Если ifi равно nil, ListenMulticastUDP использует назначенный системой многоадресный интерфейс, хотя это не рекомендуется, поскольку назначение зависит от платформ и иногда может потребовать настройки маршрутизации. Если поле Port в gaddr равно 0, номер порта выбирается автоматически.

ListenMulticastUDP предназначен только для удобства простых, небольших приложений. Для общего назначения существуют пакеты golang.org/x/net/ipv4 и golang.org/x/net/ipv6.

Обратите внимание, что ListenMulticastUDP установит опцию сокета IP_MULTICAST_LOOP в 0 в IPPROTO_IP, чтобы отключить обратную петлю для многоадресных пакетов.

func ListenUDP

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