.examples
.github
alerting
client
config
controller
core
docs
jsonpath
metrics
pattern
security
storage
test
util
vendor
github.com
golang.org
x
crypto
image
mod
net
bpf
context
icmp
internal
ipv4
ipv6
batch.go
control.go
control_rfc2292_unix.go
control_rfc3542_unix.go
control_stub.go
control_unix.go
control_windows.go
dgramopt.go
doc.go
endpoint.go
genericopt.go
header.go
helper.go
iana.go
icmp.go
icmp_bsd.go
icmp_linux.go
icmp_solaris.go
icmp_stub.go
icmp_windows.go
icmp_zos.go
payload.go
payload_cmsg.go
payload_nocmsg.go
sockopt.go
sockopt_posix.go
sockopt_stub.go
sys_aix.go
sys_asmreq.go
sys_asmreq_stub.go
sys_bpf.go
sys_bpf_stub.go
sys_bsd.go
sys_darwin.go
sys_freebsd.go
sys_linux.go
sys_solaris.go
sys_ssmreq.go
sys_ssmreq_stub.go
sys_stub.go
sys_windows.go
sys_zos.go
zsys_aix_ppc64.go
zsys_darwin.go
zsys_dragonfly.go
zsys_freebsd_386.go
zsys_freebsd_amd64.go
zsys_freebsd_arm.go
zsys_freebsd_arm64.go
zsys_freebsd_riscv64.go
zsys_linux_386.go
zsys_linux_amd64.go
zsys_linux_arm.go
zsys_linux_arm64.go
zsys_linux_loong64.go
zsys_linux_mips.go
zsys_linux_mips64.go
zsys_linux_mips64le.go
zsys_linux_mipsle.go
zsys_linux_ppc.go
zsys_linux_ppc64.go
zsys_linux_ppc64le.go
zsys_linux_riscv64.go
zsys_linux_s390x.go
zsys_netbsd.go
zsys_openbsd.go
zsys_solaris.go
zsys_zos_s390x.go
LICENSE
PATENTS
oauth2
sync
sys
tools
xerrors
google.golang.org
gopkg.in
lukechampine.com
modernc.org
modules.txt
watchdog
web
.dockerignore
.gitattributes
.gitignore
Dockerfile
LICENSE
Makefile
README.md
config.yaml
go.mod
go.sum
main.go
302 lines
7.5 KiB
Go
302 lines
7.5 KiB
Go
// Copyright 2013 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package ipv6
|
|
|
|
import (
|
|
"net"
|
|
|
|
"golang.org/x/net/bpf"
|
|
)
|
|
|
|
// MulticastHopLimit returns the hop limit field value for outgoing
|
|
// multicast packets.
|
|
func (c *dgramOpt) MulticastHopLimit() (int, error) {
|
|
if !c.ok() {
|
|
return 0, errInvalidConn
|
|
}
|
|
so, ok := sockOpts[ssoMulticastHopLimit]
|
|
if !ok {
|
|
return 0, errNotImplemented
|
|
}
|
|
return so.GetInt(c.Conn)
|
|
}
|
|
|
|
// SetMulticastHopLimit sets the hop limit field value for future
|
|
// outgoing multicast packets.
|
|
func (c *dgramOpt) SetMulticastHopLimit(hoplim int) error {
|
|
if !c.ok() {
|
|
return errInvalidConn
|
|
}
|
|
so, ok := sockOpts[ssoMulticastHopLimit]
|
|
if !ok {
|
|
return errNotImplemented
|
|
}
|
|
return so.SetInt(c.Conn, hoplim)
|
|
}
|
|
|
|
// MulticastInterface returns the default interface for multicast
|
|
// packet transmissions.
|
|
func (c *dgramOpt) MulticastInterface() (*net.Interface, error) {
|
|
if !c.ok() {
|
|
return nil, errInvalidConn
|
|
}
|
|
so, ok := sockOpts[ssoMulticastInterface]
|
|
if !ok {
|
|
return nil, errNotImplemented
|
|
}
|
|
return so.getMulticastInterface(c.Conn)
|
|
}
|
|
|
|
// SetMulticastInterface sets the default interface for future
|
|
// multicast packet transmissions.
|
|
func (c *dgramOpt) SetMulticastInterface(ifi *net.Interface) error {
|
|
if !c.ok() {
|
|
return errInvalidConn
|
|
}
|
|
so, ok := sockOpts[ssoMulticastInterface]
|
|
if !ok {
|
|
return errNotImplemented
|
|
}
|
|
return so.setMulticastInterface(c.Conn, ifi)
|
|
}
|
|
|
|
// MulticastLoopback reports whether transmitted multicast packets
|
|
// should be copied and send back to the originator.
|
|
func (c *dgramOpt) MulticastLoopback() (bool, error) {
|
|
if !c.ok() {
|
|
return false, errInvalidConn
|
|
}
|
|
so, ok := sockOpts[ssoMulticastLoopback]
|
|
if !ok {
|
|
return false, errNotImplemented
|
|
}
|
|
on, err := so.GetInt(c.Conn)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
return on == 1, nil
|
|
}
|
|
|
|
// SetMulticastLoopback sets whether transmitted multicast packets
|
|
// should be copied and send back to the originator.
|
|
func (c *dgramOpt) SetMulticastLoopback(on bool) error {
|
|
if !c.ok() {
|
|
return errInvalidConn
|
|
}
|
|
so, ok := sockOpts[ssoMulticastLoopback]
|
|
if !ok {
|
|
return errNotImplemented
|
|
}
|
|
return so.SetInt(c.Conn, boolint(on))
|
|
}
|
|
|
|
// JoinGroup joins the group address group on the interface ifi.
|
|
// By default all sources that can cast data to group are accepted.
|
|
// It's possible to mute and unmute data transmission from a specific
|
|
// source by using ExcludeSourceSpecificGroup and
|
|
// IncludeSourceSpecificGroup.
|
|
// JoinGroup uses the system assigned multicast interface when ifi is
|
|
// nil, although this is not recommended because the assignment
|
|
// depends on platforms and sometimes it might require routing
|
|
// configuration.
|
|
func (c *dgramOpt) JoinGroup(ifi *net.Interface, group net.Addr) error {
|
|
if !c.ok() {
|
|
return errInvalidConn
|
|
}
|
|
so, ok := sockOpts[ssoJoinGroup]
|
|
if !ok {
|
|
return errNotImplemented
|
|
}
|
|
grp := netAddrToIP16(group)
|
|
if grp == nil {
|
|
return errMissingAddress
|
|
}
|
|
return so.setGroup(c.Conn, ifi, grp)
|
|
}
|
|
|
|
// LeaveGroup leaves the group address group on the interface ifi
|
|
// regardless of whether the group is any-source group or
|
|
// source-specific group.
|
|
func (c *dgramOpt) LeaveGroup(ifi *net.Interface, group net.Addr) error {
|
|
if !c.ok() {
|
|
return errInvalidConn
|
|
}
|
|
so, ok := sockOpts[ssoLeaveGroup]
|
|
if !ok {
|
|
return errNotImplemented
|
|
}
|
|
grp := netAddrToIP16(group)
|
|
if grp == nil {
|
|
return errMissingAddress
|
|
}
|
|
return so.setGroup(c.Conn, ifi, grp)
|
|
}
|
|
|
|
// JoinSourceSpecificGroup joins the source-specific group comprising
|
|
// group and source on the interface ifi.
|
|
// JoinSourceSpecificGroup uses the system assigned multicast
|
|
// interface when ifi is nil, although this is not recommended because
|
|
// the assignment depends on platforms and sometimes it might require
|
|
// routing configuration.
|
|
func (c *dgramOpt) JoinSourceSpecificGroup(ifi *net.Interface, group, source net.Addr) error {
|
|
if !c.ok() {
|
|
return errInvalidConn
|
|
}
|
|
so, ok := sockOpts[ssoJoinSourceGroup]
|
|
if !ok {
|
|
return errNotImplemented
|
|
}
|
|
grp := netAddrToIP16(group)
|
|
if grp == nil {
|
|
return errMissingAddress
|
|
}
|
|
src := netAddrToIP16(source)
|
|
if src == nil {
|
|
return errMissingAddress
|
|
}
|
|
return so.setSourceGroup(c.Conn, ifi, grp, src)
|
|
}
|
|
|
|
// LeaveSourceSpecificGroup leaves the source-specific group on the
|
|
// interface ifi.
|
|
func (c *dgramOpt) LeaveSourceSpecificGroup(ifi *net.Interface, group, source net.Addr) error {
|
|
if !c.ok() {
|
|
return errInvalidConn
|
|
}
|
|
so, ok := sockOpts[ssoLeaveSourceGroup]
|
|
if !ok {
|
|
return errNotImplemented
|
|
}
|
|
grp := netAddrToIP16(group)
|
|
if grp == nil {
|
|
return errMissingAddress
|
|
}
|
|
src := netAddrToIP16(source)
|
|
if src == nil {
|
|
return errMissingAddress
|
|
}
|
|
return so.setSourceGroup(c.Conn, ifi, grp, src)
|
|
}
|
|
|
|
// ExcludeSourceSpecificGroup excludes the source-specific group from
|
|
// the already joined any-source groups by JoinGroup on the interface
|
|
// ifi.
|
|
func (c *dgramOpt) ExcludeSourceSpecificGroup(ifi *net.Interface, group, source net.Addr) error {
|
|
if !c.ok() {
|
|
return errInvalidConn
|
|
}
|
|
so, ok := sockOpts[ssoBlockSourceGroup]
|
|
if !ok {
|
|
return errNotImplemented
|
|
}
|
|
grp := netAddrToIP16(group)
|
|
if grp == nil {
|
|
return errMissingAddress
|
|
}
|
|
src := netAddrToIP16(source)
|
|
if src == nil {
|
|
return errMissingAddress
|
|
}
|
|
return so.setSourceGroup(c.Conn, ifi, grp, src)
|
|
}
|
|
|
|
// IncludeSourceSpecificGroup includes the excluded source-specific
|
|
// group by ExcludeSourceSpecificGroup again on the interface ifi.
|
|
func (c *dgramOpt) IncludeSourceSpecificGroup(ifi *net.Interface, group, source net.Addr) error {
|
|
if !c.ok() {
|
|
return errInvalidConn
|
|
}
|
|
so, ok := sockOpts[ssoUnblockSourceGroup]
|
|
if !ok {
|
|
return errNotImplemented
|
|
}
|
|
grp := netAddrToIP16(group)
|
|
if grp == nil {
|
|
return errMissingAddress
|
|
}
|
|
src := netAddrToIP16(source)
|
|
if src == nil {
|
|
return errMissingAddress
|
|
}
|
|
return so.setSourceGroup(c.Conn, ifi, grp, src)
|
|
}
|
|
|
|
// Checksum reports whether the kernel will compute, store or verify a
|
|
// checksum for both incoming and outgoing packets. If on is true, it
|
|
// returns an offset in bytes into the data of where the checksum
|
|
// field is located.
|
|
func (c *dgramOpt) Checksum() (on bool, offset int, err error) {
|
|
if !c.ok() {
|
|
return false, 0, errInvalidConn
|
|
}
|
|
so, ok := sockOpts[ssoChecksum]
|
|
if !ok {
|
|
return false, 0, errNotImplemented
|
|
}
|
|
offset, err = so.GetInt(c.Conn)
|
|
if err != nil {
|
|
return false, 0, err
|
|
}
|
|
if offset < 0 {
|
|
return false, 0, nil
|
|
}
|
|
return true, offset, nil
|
|
}
|
|
|
|
// SetChecksum enables the kernel checksum processing. If on is ture,
|
|
// the offset should be an offset in bytes into the data of where the
|
|
// checksum field is located.
|
|
func (c *dgramOpt) SetChecksum(on bool, offset int) error {
|
|
if !c.ok() {
|
|
return errInvalidConn
|
|
}
|
|
so, ok := sockOpts[ssoChecksum]
|
|
if !ok {
|
|
return errNotImplemented
|
|
}
|
|
if !on {
|
|
offset = -1
|
|
}
|
|
return so.SetInt(c.Conn, offset)
|
|
}
|
|
|
|
// ICMPFilter returns an ICMP filter.
|
|
func (c *dgramOpt) ICMPFilter() (*ICMPFilter, error) {
|
|
if !c.ok() {
|
|
return nil, errInvalidConn
|
|
}
|
|
so, ok := sockOpts[ssoICMPFilter]
|
|
if !ok {
|
|
return nil, errNotImplemented
|
|
}
|
|
return so.getICMPFilter(c.Conn)
|
|
}
|
|
|
|
// SetICMPFilter deploys the ICMP filter.
|
|
func (c *dgramOpt) SetICMPFilter(f *ICMPFilter) error {
|
|
if !c.ok() {
|
|
return errInvalidConn
|
|
}
|
|
so, ok := sockOpts[ssoICMPFilter]
|
|
if !ok {
|
|
return errNotImplemented
|
|
}
|
|
return so.setICMPFilter(c.Conn, f)
|
|
}
|
|
|
|
// SetBPF attaches a BPF program to the connection.
|
|
//
|
|
// Only supported on Linux.
|
|
func (c *dgramOpt) SetBPF(filter []bpf.RawInstruction) error {
|
|
if !c.ok() {
|
|
return errInvalidConn
|
|
}
|
|
so, ok := sockOpts[ssoAttachFilter]
|
|
if !ok {
|
|
return errNotImplemented
|
|
}
|
|
return so.setBPF(c.Conn, filter)
|
|
}
|