Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified
📁 ..	-	2025-05-25 12:27
📄 batch.go // Copyright 2017 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" "runtime" "golang.org/x/net/internal/socket" ) // BUG(mikio): On Windows, the ReadBatch and WriteBatch methods of // PacketConn are not implemented. // A Message represents an IO message. // // type Message struct { // Buffers [][]byte // OOB []byte // Addr net.Addr // N int // NN int // Flags int // } // // The Buffers fields represents a list of contiguous buffers, which // can be used for vectored IO, for example, putting a header and a // payload in each slice. // When writing, the Buffers field must contain at least one byte to // write. // When reading, the Buffers field will always contain a byte to read. // // The OOB field contains protocol-specific control or miscellaneous // ancillary data known as out-of-band data. // It can be nil when not required. // // The Addr field specifies a destination address when writing. // It can be nil when the underlying protocol of the endpoint uses // connection-oriented communication. // After a successful read, it may contain the source address on the // received packet. // // The N field indicates the number of bytes read or written from/to // Buffers. // // The NN field indicates the number of bytes read or written from/to // OOB. // // The Flags field contains protocol-specific information on the // received message. type Message = socket.Message // ReadBatch reads a batch of messages. // // The provided flags is a set of platform-dependent flags, such as // syscall.MSG_PEEK. // // On a successful read it returns the number of messages received, up // to len(ms). // // On Linux, a batch read will be optimized. // On other platforms, this method will read only a single message. func (c payloadHandler) ReadBatch(ms []Message, flags int) (int, error) { if !c.ok() { return 0, errInvalidConn } switch runtime.GOOS { case "linux": n, err := c.RecvMsgs([]socket.Message(ms), flags) if err != nil { err = &net.OpError{Op: "read", Net: c.PacketConn.LocalAddr().Network(), Source: c.PacketConn.LocalAddr(), Err: err} } return n, err default: n := 1 err := c.RecvMsg(&ms[0], flags) if err != nil { n = 0 err = &net.OpError{Op: "read", Net: c.PacketConn.LocalAddr().Network(), Source: c.PacketConn.LocalAddr(), Err: err} } return n, err } } // WriteBatch writes a batch of messages. // // The provided flags is a set of platform-dependent flags, such as // syscall.MSG_DONTROUTE. // // It returns the number of messages written on a successful write. // // On Linux, a batch write will be optimized. // On other platforms, this method will write only a single message. func (c payloadHandler) WriteBatch(ms []Message, flags int) (int, error) { if !c.ok() { return 0, errInvalidConn } switch runtime.GOOS { case "linux": n, err := c.SendMsgs([]socket.Message(ms), flags) if err != nil { err = &net.OpError{Op: "write", Net: c.PacketConn.LocalAddr().Network(), Source: c.PacketConn.LocalAddr(), Err: err} } return n, err default: n := 1 err := c.SendMsg(&ms[0], flags) if err != nil { n = 0 err = &net.OpError{Op: "write", Net: c.PacketConn.LocalAddr().Network(), Source: c.PacketConn.LocalAddr(), Err: err} } return n, err } }	3.31 KB	2025-05-25 12:27
📄 bpf_test.go // Copyright 2016 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_test import ( "net" "runtime" "testing" "time" "golang.org/x/net/bpf" "golang.org/x/net/ipv6" "golang.org/x/net/nettest" ) func TestBPF(t testing.T) { if runtime.GOOS != "linux" { t.Skipf("not supported on %s", runtime.GOOS) } if _, err := nettest.RoutedInterface("ip6", net.FlagUp\|net.FlagLoopback); err != nil { t.Skip("ipv6 is not enabled for loopback interface") } l, err := net.ListenPacket("udp6", "[::1]:0") if err != nil { t.Fatal(err) } defer l.Close() p := ipv6.NewPacketConn(l) // This filter accepts UDP packets whose first payload byte is // even. prog, err := bpf.Assemble([]bpf.Instruction{ // Load the first byte of the payload (skipping UDP header). bpf.LoadAbsolute{Off: 8, Size: 1}, // Select LSB of the byte. bpf.ALUOpConstant{Op: bpf.ALUOpAnd, Val: 1}, // Byte is even? bpf.JumpIf{Cond: bpf.JumpEqual, Val: 0, SkipFalse: 1}, // Accept. bpf.RetConstant{Val: 4096}, // Ignore. bpf.RetConstant{Val: 0}, }) if err != nil { t.Fatalf("compiling BPF: %s", err) } if err = p.SetBPF(prog); err != nil { t.Fatalf("attaching filter to Conn: %s", err) } s, err := net.Dial("udp6", l.LocalAddr().String()) if err != nil { t.Fatal(err) } defer s.Close() go func() { for i := byte(0); i < 10; i++ { s.Write([]byte{i}) } }() l.SetDeadline(time.Now().Add(2 time.Second)) seen := make([]bool, 5) for { var b [512]byte n, _, err := l.ReadFrom(b[:]) if err != nil { t.Fatalf("reading from listener: %s", err) } if n != 1 { t.Fatalf("unexpected packet length, want 1, got %d", n) } if b[0] >= 10 { t.Fatalf("unexpected byte, want 0-9, got %d", b[0]) } if b[0]%2 != 0 { t.Fatalf("got odd byte %d, wanted only even bytes", b[0]) } seen[b[0]/2] = true seenAll := true for _, v := range seen { if !v { seenAll = false break } } if seenAll { break } } }	2.02 KB	2025-05-25 12:27
📄 control.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 ( "fmt" "net" "sync" "golang.org/x/net/internal/iana" "golang.org/x/net/internal/socket" ) // Note that RFC 3542 obsoletes RFC 2292 but OS X Snow Leopard and the // former still support RFC 2292 only. Please be aware that almost // all protocol implementations prohibit using a combination of RFC // 2292 and RFC 3542 for some practical reasons. type rawOpt struct { sync.RWMutex cflags ControlFlags } func (c rawOpt) set(f ControlFlags) { c.cflags \|= f } func (c rawOpt) clear(f ControlFlags) { c.cflags &^= f } func (c rawOpt) isset(f ControlFlags) bool { return c.cflags&f != 0 } // A ControlFlags represents per packet basis IP-level socket option // control flags. type ControlFlags uint const ( FlagTrafficClass ControlFlags = 1 << iota // pass the traffic class on the received packet FlagHopLimit // pass the hop limit on the received packet FlagSrc // pass the source address on the received packet FlagDst // pass the destination address on the received packet FlagInterface // pass the interface index on the received packet FlagPathMTU // pass the path MTU on the received packet path ) const flagPacketInfo = FlagDst \| FlagInterface // A ControlMessage represents per packet basis IP-level socket // options. type ControlMessage struct { // Receiving socket options: SetControlMessage allows to // receive the options from the protocol stack using ReadFrom // method of PacketConn. // // Specifying socket options: ControlMessage for WriteTo // method of PacketConn allows to send the options to the // protocol stack. // TrafficClass int // traffic class, must be 1 <= value <= 255 when specifying HopLimit int // hop limit, must be 1 <= value <= 255 when specifying Src net.IP // source address, specifying only Dst net.IP // destination address, receiving only IfIndex int // interface index, must be 1 <= value when specifying NextHop net.IP // next hop address, specifying only MTU int // path MTU, receiving only } func (cm ControlMessage) String() string { if cm == nil { return "<nil>" } return fmt.Sprintf("tclass=%#x hoplim=%d src=%v dst=%v ifindex=%d nexthop=%v mtu=%d", cm.TrafficClass, cm.HopLimit, cm.Src, cm.Dst, cm.IfIndex, cm.NextHop, cm.MTU) } // Marshal returns the binary encoding of cm. func (cm ControlMessage) Marshal() []byte { if cm == nil { return nil } var l int tclass := false if ctlOpts[ctlTrafficClass].name > 0 && cm.TrafficClass > 0 { tclass = true l += socket.ControlMessageSpace(ctlOpts[ctlTrafficClass].length) } hoplimit := false if ctlOpts[ctlHopLimit].name > 0 && cm.HopLimit > 0 { hoplimit = true l += socket.ControlMessageSpace(ctlOpts[ctlHopLimit].length) } pktinfo := false if ctlOpts[ctlPacketInfo].name > 0 && (cm.Src.To16() != nil && cm.Src.To4() == nil \|\| cm.IfIndex > 0) { pktinfo = true l += socket.ControlMessageSpace(ctlOpts[ctlPacketInfo].length) } nexthop := false if ctlOpts[ctlNextHop].name > 0 && cm.NextHop.To16() != nil && cm.NextHop.To4() == nil { nexthop = true l += socket.ControlMessageSpace(ctlOpts[ctlNextHop].length) } var b []byte if l > 0 { b = make([]byte, l) bb := b if tclass { bb = ctlOpts[ctlTrafficClass].marshal(bb, cm) } if hoplimit { bb = ctlOpts[ctlHopLimit].marshal(bb, cm) } if pktinfo { bb = ctlOpts[ctlPacketInfo].marshal(bb, cm) } if nexthop { bb = ctlOpts[ctlNextHop].marshal(bb, cm) } } return b } // Parse parses b as a control message and stores the result in cm. func (cm ControlMessage) Parse(b []byte) error { ms, err := socket.ControlMessage(b).Parse() if err != nil { return err } for _, m := range ms { lvl, typ, l, err := m.ParseHeader() if err != nil { return err } if lvl != iana.ProtocolIPv6 { continue } switch { case typ == ctlOpts[ctlTrafficClass].name && l >= ctlOpts[ctlTrafficClass].length: ctlOpts[ctlTrafficClass].parse(cm, m.Data(l)) case typ == ctlOpts[ctlHopLimit].name && l >= ctlOpts[ctlHopLimit].length: ctlOpts[ctlHopLimit].parse(cm, m.Data(l)) case typ == ctlOpts[ctlPacketInfo].name && l >= ctlOpts[ctlPacketInfo].length: ctlOpts[ctlPacketInfo].parse(cm, m.Data(l)) case typ == ctlOpts[ctlPathMTU].name && l >= ctlOpts[ctlPathMTU].length: ctlOpts[ctlPathMTU].parse(cm, m.Data(l)) } } return nil } // NewControlMessage returns a new control message. // // The returned message is large enough for options specified by cf. func NewControlMessage(cf ControlFlags) []byte { opt := rawOpt{cflags: cf} var l int if opt.isset(FlagTrafficClass) && ctlOpts[ctlTrafficClass].name > 0 { l += socket.ControlMessageSpace(ctlOpts[ctlTrafficClass].length) } if opt.isset(FlagHopLimit) && ctlOpts[ctlHopLimit].name > 0 { l += socket.ControlMessageSpace(ctlOpts[ctlHopLimit].length) } if opt.isset(flagPacketInfo) && ctlOpts[ctlPacketInfo].name > 0 { l += socket.ControlMessageSpace(ctlOpts[ctlPacketInfo].length) } if opt.isset(FlagPathMTU) && ctlOpts[ctlPathMTU].name > 0 { l += socket.ControlMessageSpace(ctlOpts[ctlPathMTU].length) } var b []byte if l > 0 { b = make([]byte, l) } return b } // Ancillary data socket options const ( ctlTrafficClass = iota // header field ctlHopLimit // header field ctlPacketInfo // inbound or outbound packet path ctlNextHop // nexthop ctlPathMTU // path mtu ctlMax ) // A ctlOpt represents a binding for ancillary data socket option. type ctlOpt struct { name int // option name, must be equal or greater than 1 length int // option length marshal func([]byte, ControlMessage) []byte parse func(ControlMessage, []byte) }	5.88 KB	2025-05-25 12:27
📄 control_rfc2292_unix.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. //go:build darwin package ipv6 import ( "unsafe" "golang.org/x/net/internal/iana" "golang.org/x/net/internal/socket" "golang.org/x/sys/unix" ) func marshal2292HopLimit(b []byte, cm ControlMessage) []byte { m := socket.ControlMessage(b) m.MarshalHeader(iana.ProtocolIPv6, unix.IPV6_2292HOPLIMIT, 4) if cm != nil { socket.NativeEndian.PutUint32(m.Data(4), uint32(cm.HopLimit)) } return m.Next(4) } func marshal2292PacketInfo(b []byte, cm ControlMessage) []byte { m := socket.ControlMessage(b) m.MarshalHeader(iana.ProtocolIPv6, unix.IPV6_2292PKTINFO, sizeofInet6Pktinfo) if cm != nil { pi := (inet6Pktinfo)(unsafe.Pointer(&m.Data(sizeofInet6Pktinfo)[0])) if ip := cm.Src.To16(); ip != nil && ip.To4() == nil { copy(pi.Addr[:], ip) } if cm.IfIndex > 0 { pi.setIfindex(cm.IfIndex) } } return m.Next(sizeofInet6Pktinfo) } func marshal2292NextHop(b []byte, cm ControlMessage) []byte { m := socket.ControlMessage(b) m.MarshalHeader(iana.ProtocolIPv6, unix.IPV6_2292NEXTHOP, sizeofSockaddrInet6) if cm != nil { sa := (*sockaddrInet6)(unsafe.Pointer(&m.Data(sizeofSockaddrInet6)[0])) sa.setSockaddr(cm.NextHop, cm.IfIndex) } return m.Next(sizeofSockaddrInet6) }	1.33 KB	2025-05-25 12:27
📄 control_rfc3542_unix.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. //go:build aix \|\| darwin \|\| dragonfly \|\| freebsd \|\| linux \|\| netbsd \|\| openbsd \|\| solaris \|\| zos package ipv6 import ( "net" "unsafe" "golang.org/x/net/internal/iana" "golang.org/x/net/internal/socket" "golang.org/x/sys/unix" ) func marshalTrafficClass(b []byte, cm ControlMessage) []byte { m := socket.ControlMessage(b) m.MarshalHeader(iana.ProtocolIPv6, unix.IPV6_TCLASS, 4) if cm != nil { socket.NativeEndian.PutUint32(m.Data(4), uint32(cm.TrafficClass)) } return m.Next(4) } func parseTrafficClass(cm ControlMessage, b []byte) { cm.TrafficClass = int(socket.NativeEndian.Uint32(b[:4])) } func marshalHopLimit(b []byte, cm ControlMessage) []byte { m := socket.ControlMessage(b) m.MarshalHeader(iana.ProtocolIPv6, unix.IPV6_HOPLIMIT, 4) if cm != nil { socket.NativeEndian.PutUint32(m.Data(4), uint32(cm.HopLimit)) } return m.Next(4) } func parseHopLimit(cm ControlMessage, b []byte) { cm.HopLimit = int(socket.NativeEndian.Uint32(b[:4])) } func marshalPacketInfo(b []byte, cm ControlMessage) []byte { m := socket.ControlMessage(b) m.MarshalHeader(iana.ProtocolIPv6, unix.IPV6_PKTINFO, sizeofInet6Pktinfo) if cm != nil { pi := (inet6Pktinfo)(unsafe.Pointer(&m.Data(sizeofInet6Pktinfo)[0])) if ip := cm.Src.To16(); ip != nil && ip.To4() == nil { copy(pi.Addr[:], ip) } if cm.IfIndex > 0 { pi.setIfindex(cm.IfIndex) } } return m.Next(sizeofInet6Pktinfo) } func parsePacketInfo(cm ControlMessage, b []byte) { pi := (inet6Pktinfo)(unsafe.Pointer(&b[0])) if len(cm.Dst) < net.IPv6len { cm.Dst = make(net.IP, net.IPv6len) } copy(cm.Dst, pi.Addr[:]) cm.IfIndex = int(pi.Ifindex) } func marshalNextHop(b []byte, cm ControlMessage) []byte { m := socket.ControlMessage(b) m.MarshalHeader(iana.ProtocolIPv6, unix.IPV6_NEXTHOP, sizeofSockaddrInet6) if cm != nil { sa := (sockaddrInet6)(unsafe.Pointer(&m.Data(sizeofSockaddrInet6)[0])) sa.setSockaddr(cm.NextHop, cm.IfIndex) } return m.Next(sizeofSockaddrInet6) } func parseNextHop(cm ControlMessage, b []byte) { } func marshalPathMTU(b []byte, cm ControlMessage) []byte { m := socket.ControlMessage(b) m.MarshalHeader(iana.ProtocolIPv6, unix.IPV6_PATHMTU, sizeofIPv6Mtuinfo) return m.Next(sizeofIPv6Mtuinfo) } func parsePathMTU(cm ControlMessage, b []byte) { mi := (ipv6Mtuinfo)(unsafe.Pointer(&b[0])) if len(cm.Dst) < net.IPv6len { cm.Dst = make(net.IP, net.IPv6len) } copy(cm.Dst, mi.Addr.Addr[:]) cm.IfIndex = int(mi.Addr.Scope_id) cm.MTU = int(mi.Mtu) }	2.59 KB	2025-05-25 12:27
📄 control_stub.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. //go:build !aix && !darwin && !dragonfly && !freebsd && !linux && !netbsd && !openbsd && !solaris && !windows && !zos package ipv6 import "golang.org/x/net/internal/socket" func setControlMessage(c socket.Conn, opt rawOpt, cf ControlFlags, on bool) error { return errNotImplemented }	450 B	2025-05-25 12:27
📄 control_test.go // Copyright 2017 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_test import ( "testing" "golang.org/x/net/ipv6" ) func TestControlMessageParseWithFuzz(t *testing.T) { var cm ipv6.ControlMessage for _, fuzz := range []string{ "\f\x00\x00\x00)\x00\x00\x00.\x00\x00\x00", "\f\x00\x00\x00)\x00\x00\x00,\x00\x00\x00", } { cm.Parse([]byte(fuzz)) } }	468 B	2025-05-25 12:27
📄 control_unix.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. //go:build aix \|\| darwin \|\| dragonfly \|\| freebsd \|\| linux \|\| netbsd \|\| openbsd \|\| solaris \|\| zos package ipv6 import "golang.org/x/net/internal/socket" func setControlMessage(c socket.Conn, opt rawOpt, cf ControlFlags, on bool) error { opt.Lock() defer opt.Unlock() if so, ok := sockOpts[ssoReceiveTrafficClass]; ok && cf&FlagTrafficClass != 0 { if err := so.SetInt(c, boolint(on)); err != nil { return err } if on { opt.set(FlagTrafficClass) } else { opt.clear(FlagTrafficClass) } } if so, ok := sockOpts[ssoReceiveHopLimit]; ok && cf&FlagHopLimit != 0 { if err := so.SetInt(c, boolint(on)); err != nil { return err } if on { opt.set(FlagHopLimit) } else { opt.clear(FlagHopLimit) } } if so, ok := sockOpts[ssoReceivePacketInfo]; ok && cf&flagPacketInfo != 0 { if err := so.SetInt(c, boolint(on)); err != nil { return err } if on { opt.set(cf & flagPacketInfo) } else { opt.clear(cf & flagPacketInfo) } } if so, ok := sockOpts[ssoReceivePathMTU]; ok && cf&FlagPathMTU != 0 { if err := so.SetInt(c, boolint(on)); err != nil { return err } if on { opt.set(FlagPathMTU) } else { opt.clear(FlagPathMTU) } } return nil }	1.34 KB	2025-05-25 12:27
📄 control_windows.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 "golang.org/x/net/internal/socket" func setControlMessage(c socket.Conn, opt rawOpt, cf ControlFlags, on bool) error { // TODO(mikio): implement this return errNotImplemented }	363 B	2025-05-25 12:27
📄 defs_aix.go // Copyright 2019 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. //go:build ignore // +godefs map struct_in6_addr [16]byte /* in6_addr / package ipv6 / #include <sys/param.h> #include <sys/socket.h> #include <netinet/in.h> #include <netinet/icmp6.h> */ import "C" const ( sizeofSockaddrStorage = C.sizeof_struct_sockaddr_storage sizeofSockaddrInet6 = C.sizeof_struct_sockaddr_in6 sizeofInet6Pktinfo = C.sizeof_struct_in6_pktinfo sizeofIPv6Mtuinfo = C.sizeof_struct_ip6_mtuinfo sizeofIPv6Mreq = C.sizeof_struct_ipv6_mreq sizeofGroupReq = C.sizeof_struct_group_req sizeofGroupSourceReq = C.sizeof_struct_group_source_req sizeofICMPv6Filter = C.sizeof_struct_icmp6_filter ) type sockaddrStorage C.struct_sockaddr_storage type sockaddrInet6 C.struct_sockaddr_in6 type inet6Pktinfo C.struct_in6_pktinfo type ipv6Mtuinfo C.struct_ip6_mtuinfo type ipv6Mreq C.struct_ipv6_mreq type icmpv6Filter C.struct_icmp6_filter type groupReq C.struct_group_req type groupSourceReq C.struct_group_source_req	1.1 KB	2025-05-25 12:27
📄 defs_darwin.go // Copyright 2014 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. //go:build ignore // +godefs map struct_in6_addr [16]byte /* in6_addr / package ipv6 / #define __APPLE_USE_RFC_3542 #include <netinet/in.h> #include <netinet/icmp6.h> */ import "C" const ( sizeofSockaddrStorage = C.sizeof_struct_sockaddr_storage sizeofSockaddrInet6 = C.sizeof_struct_sockaddr_in6 sizeofInet6Pktinfo = C.sizeof_struct_in6_pktinfo sizeofIPv6Mtuinfo = C.sizeof_struct_ip6_mtuinfo sizeofIPv6Mreq = C.sizeof_struct_ipv6_mreq sizeofGroupReq = C.sizeof_struct_group_req sizeofGroupSourceReq = C.sizeof_struct_group_source_req sizeofICMPv6Filter = C.sizeof_struct_icmp6_filter ) type sockaddrStorage C.struct_sockaddr_storage type sockaddrInet6 C.struct_sockaddr_in6 type inet6Pktinfo C.struct_in6_pktinfo type ipv6Mtuinfo C.struct_ip6_mtuinfo type ipv6Mreq C.struct_ipv6_mreq type icmpv6Filter C.struct_icmp6_filter type groupReq C.struct_group_req type groupSourceReq C.struct_group_source_req	1.08 KB	2025-05-25 12:27
📄 defs_dragonfly.go // Copyright 2014 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. //go:build ignore // +godefs map struct_in6_addr [16]byte /* in6_addr / package ipv6 / #include <sys/param.h> #include <sys/socket.h> #include <netinet/in.h> #include <netinet/icmp6.h> */ import "C" const ( sizeofSockaddrInet6 = C.sizeof_struct_sockaddr_in6 sizeofInet6Pktinfo = C.sizeof_struct_in6_pktinfo sizeofIPv6Mtuinfo = C.sizeof_struct_ip6_mtuinfo sizeofIPv6Mreq = C.sizeof_struct_ipv6_mreq sizeofICMPv6Filter = C.sizeof_struct_icmp6_filter ) type sockaddrInet6 C.struct_sockaddr_in6 type inet6Pktinfo C.struct_in6_pktinfo type ipv6Mtuinfo C.struct_ip6_mtuinfo type ipv6Mreq C.struct_ipv6_mreq type icmpv6Filter C.struct_icmp6_filter	823 B	2025-05-25 12:27
📄 defs_freebsd.go // Copyright 2014 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. //go:build ignore // +godefs map struct_in6_addr [16]byte /* in6_addr / package ipv6 / #include <sys/param.h> #include <sys/socket.h> #include <netinet/in.h> #include <netinet/icmp6.h> */ import "C" const ( sizeofSockaddrStorage = C.sizeof_struct_sockaddr_storage sizeofSockaddrInet6 = C.sizeof_struct_sockaddr_in6 sizeofInet6Pktinfo = C.sizeof_struct_in6_pktinfo sizeofIPv6Mtuinfo = C.sizeof_struct_ip6_mtuinfo sizeofIPv6Mreq = C.sizeof_struct_ipv6_mreq sizeofGroupReq = C.sizeof_struct_group_req sizeofGroupSourceReq = C.sizeof_struct_group_source_req sizeofICMPv6Filter = C.sizeof_struct_icmp6_filter ) type sockaddrStorage C.struct_sockaddr_storage type sockaddrInet6 C.struct_sockaddr_in6 type inet6Pktinfo C.struct_in6_pktinfo type ipv6Mtuinfo C.struct_ip6_mtuinfo type ipv6Mreq C.struct_ipv6_mreq type groupReq C.struct_group_req type groupSourceReq C.struct_group_source_req type icmpv6Filter C.struct_icmp6_filter	1.1 KB	2025-05-25 12:27
📄 defs_linux.go // Copyright 2014 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. //go:build ignore // +godefs map struct_in6_addr [16]byte /* in6_addr / package ipv6 / #include <linux/in.h> #include <linux/in6.h> #include <linux/ipv6.h> #include <linux/icmpv6.h> #include <linux/filter.h> #include <sys/socket.h> */ import "C" const ( sizeofKernelSockaddrStorage = C.sizeof_struct___kernel_sockaddr_storage sizeofSockaddrInet6 = C.sizeof_struct_sockaddr_in6 sizeofInet6Pktinfo = C.sizeof_struct_in6_pktinfo sizeofIPv6Mtuinfo = C.sizeof_struct_ip6_mtuinfo sizeofIPv6FlowlabelReq = C.sizeof_struct_in6_flowlabel_req sizeofIPv6Mreq = C.sizeof_struct_ipv6_mreq sizeofGroupReq = C.sizeof_struct_group_req sizeofGroupSourceReq = C.sizeof_struct_group_source_req sizeofICMPv6Filter = C.sizeof_struct_icmp6_filter ) type kernelSockaddrStorage C.struct___kernel_sockaddr_storage type sockaddrInet6 C.struct_sockaddr_in6 type inet6Pktinfo C.struct_in6_pktinfo type ipv6Mtuinfo C.struct_ip6_mtuinfo type ipv6FlowlabelReq C.struct_in6_flowlabel_req type ipv6Mreq C.struct_ipv6_mreq type groupReq C.struct_group_req type groupSourceReq C.struct_group_source_req type icmpv6Filter C.struct_icmp6_filter	1.31 KB	2025-05-25 12:27
📄 defs_netbsd.go // Copyright 2014 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. //go:build ignore // +godefs map struct_in6_addr [16]byte /* in6_addr / package ipv6 / #include <sys/param.h> #include <sys/socket.h> #include <netinet/in.h> #include <netinet/icmp6.h> */ import "C" const ( sizeofSockaddrInet6 = C.sizeof_struct_sockaddr_in6 sizeofInet6Pktinfo = C.sizeof_struct_in6_pktinfo sizeofIPv6Mtuinfo = C.sizeof_struct_ip6_mtuinfo sizeofIPv6Mreq = C.sizeof_struct_ipv6_mreq sizeofICMPv6Filter = C.sizeof_struct_icmp6_filter ) type sockaddrInet6 C.struct_sockaddr_in6 type inet6Pktinfo C.struct_in6_pktinfo type ipv6Mtuinfo C.struct_ip6_mtuinfo type ipv6Mreq C.struct_ipv6_mreq type icmpv6Filter C.struct_icmp6_filter	823 B	2025-05-25 12:27
📄 defs_openbsd.go // Copyright 2014 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. //go:build ignore // +godefs map struct_in6_addr [16]byte /* in6_addr / package ipv6 / #include <sys/param.h> #include <sys/socket.h> #include <netinet/in.h> #include <netinet/icmp6.h> */ import "C" const ( sizeofSockaddrInet6 = C.sizeof_struct_sockaddr_in6 sizeofInet6Pktinfo = C.sizeof_struct_in6_pktinfo sizeofIPv6Mtuinfo = C.sizeof_struct_ip6_mtuinfo sizeofIPv6Mreq = C.sizeof_struct_ipv6_mreq sizeofICMPv6Filter = C.sizeof_struct_icmp6_filter ) type sockaddrInet6 C.struct_sockaddr_in6 type inet6Pktinfo C.struct_in6_pktinfo type ipv6Mtuinfo C.struct_ip6_mtuinfo type ipv6Mreq C.struct_ipv6_mreq type icmpv6Filter C.struct_icmp6_filter	823 B	2025-05-25 12:27
📄 defs_solaris.go // Copyright 2014 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. //go:build ignore // +godefs map struct_in6_addr [16]byte /* in6_addr / package ipv6 / #include <sys/socket.h> #include <netinet/in.h> #include <netinet/icmp6.h> */ import "C" const ( sizeofSockaddrStorage = C.sizeof_struct_sockaddr_storage sizeofSockaddrInet6 = C.sizeof_struct_sockaddr_in6 sizeofInet6Pktinfo = C.sizeof_struct_in6_pktinfo sizeofIPv6Mtuinfo = C.sizeof_struct_ip6_mtuinfo sizeofIPv6Mreq = C.sizeof_struct_ipv6_mreq sizeofGroupReq = C.sizeof_struct_group_req sizeofGroupSourceReq = C.sizeof_struct_group_source_req sizeofICMPv6Filter = C.sizeof_struct_icmp6_filter ) type sockaddrStorage C.struct_sockaddr_storage type sockaddrInet6 C.struct_sockaddr_in6 type inet6Pktinfo C.struct_in6_pktinfo type ipv6Mtuinfo C.struct_ip6_mtuinfo type ipv6Mreq C.struct_ipv6_mreq type groupReq C.struct_group_req type groupSourceReq C.struct_group_source_req type icmpv6Filter C.struct_icmp6_filter	1.08 KB	2025-05-25 12:27
📄 dgramopt.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 true, // 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) }	7.54 KB	2025-05-25 12:27
📄 doc.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 implements IP-level socket options for the Internet // Protocol version 6. // // The package provides IP-level socket options that allow // manipulation of IPv6 facilities. // // The IPv6 protocol is defined in RFC 8200. // Socket interface extensions are defined in RFC 3493, RFC 3542 and // RFC 3678. // MLDv1 and MLDv2 are defined in RFC 2710 and RFC 3810. // Source-specific multicast is defined in RFC 4607. // // On Darwin, this package requires OS X Mavericks version 10.9 or // above, or equivalent. // // # Unicasting // // The options for unicasting are available for net.TCPConn, // net.UDPConn and net.IPConn which are created as network connections // that use the IPv6 transport. When a single TCP connection carrying // a data flow of multiple packets needs to indicate the flow is // important, Conn is used to set the traffic class field on the IPv6 // header for each packet. // // ln, err := net.Listen("tcp6", "[::]:1024") // if err != nil { // // error handling // } // defer ln.Close() // for { // c, err := ln.Accept() // if err != nil { // // error handling // } // go func(c net.Conn) { // defer c.Close() // // The outgoing packets will be labeled DiffServ assured forwarding // class 1 low drop precedence, known as AF11 packets. // // if err := ipv6.NewConn(c).SetTrafficClass(0x28); err != nil { // // error handling // } // if _, err := c.Write(data); err != nil { // // error handling // } // }(c) // } // // # Multicasting // // The options for multicasting are available for net.UDPConn and // net.IPConn which are created as network connections that use the // IPv6 transport. A few network facilities must be prepared before // you begin multicasting, at a minimum joining network interfaces and // multicast groups. // // en0, err := net.InterfaceByName("en0") // if err != nil { // // error handling // } // en1, err := net.InterfaceByIndex(911) // if err != nil { // // error handling // } // group := net.ParseIP("ff02::114") // // First, an application listens to an appropriate address with an // appropriate service port. // // c, err := net.ListenPacket("udp6", "[::]:1024") // if err != nil { // // error handling // } // defer c.Close() // // Second, the application joins multicast groups, starts listening to // the groups on the specified network interfaces. Note that the // service port for transport layer protocol does not matter with this // operation as joining groups affects only network and link layer // protocols, such as IPv6 and Ethernet. // // p := ipv6.NewPacketConn(c) // if err := p.JoinGroup(en0, &net.UDPAddr{IP: group}); err != nil { // // error handling // } // if err := p.JoinGroup(en1, &net.UDPAddr{IP: group}); err != nil { // // error handling // } // // The application might set per packet control message transmissions // between the protocol stack within the kernel. When the application // needs a destination address on an incoming packet, // SetControlMessage of PacketConn is used to enable control message // transmissions. // // if err := p.SetControlMessage(ipv6.FlagDst, true); err != nil { // // error handling // } // // The application could identify whether the received packets are // of interest by using the control message that contains the // destination address of the received packet. // // b := make([]byte, 1500) // for { // n, rcm, src, err := p.ReadFrom(b) // if err != nil { // // error handling // } // if rcm.Dst.IsMulticast() { // if rcm.Dst.Equal(group) { // // joined group, do something // } else { // // unknown group, discard // continue // } // } // // The application can also send both unicast and multicast packets. // // p.SetTrafficClass(0x0) // p.SetHopLimit(16) // if _, err := p.WriteTo(data[:n], nil, src); err != nil { // // error handling // } // dst := &net.UDPAddr{IP: group, Port: 1024} // wcm := ipv6.ControlMessage{TrafficClass: 0xe0, HopLimit: 1} // for _, ifi := range []*net.Interface{en0, en1} { // wcm.IfIndex = ifi.Index // if _, err := p.WriteTo(data[:n], &wcm, dst); err != nil { // // error handling // } // } // } // // # More multicasting // // An application that uses PacketConn may join multiple multicast // groups. For example, a UDP listener with port 1024 might join two // different groups across over two different network interfaces by // using: // // c, err := net.ListenPacket("udp6", "[::]:1024") // if err != nil { // // error handling // } // defer c.Close() // p := ipv6.NewPacketConn(c) // if err := p.JoinGroup(en0, &net.UDPAddr{IP: net.ParseIP("ff02::1:114")}); err != nil { // // error handling // } // if err := p.JoinGroup(en0, &net.UDPAddr{IP: net.ParseIP("ff02::2:114")}); err != nil { // // error handling // } // if err := p.JoinGroup(en1, &net.UDPAddr{IP: net.ParseIP("ff02::2:114")}); err != nil { // // error handling // } // // It is possible for multiple UDP listeners that listen on the same // UDP port to join the same multicast group. The net package will // provide a socket that listens to a wildcard address with reusable // UDP port when an appropriate multicast address prefix is passed to // the net.ListenPacket or net.ListenUDP. // // c1, err := net.ListenPacket("udp6", "[ff02::]:1024") // if err != nil { // // error handling // } // defer c1.Close() // c2, err := net.ListenPacket("udp6", "[ff02::]:1024") // if err != nil { // // error handling // } // defer c2.Close() // p1 := ipv6.NewPacketConn(c1) // if err := p1.JoinGroup(en0, &net.UDPAddr{IP: net.ParseIP("ff02::114")}); err != nil { // // error handling // } // p2 := ipv6.NewPacketConn(c2) // if err := p2.JoinGroup(en0, &net.UDPAddr{IP: net.ParseIP("ff02::114")}); err != nil { // // error handling // } // // Also it is possible for the application to leave or rejoin a // multicast group on the network interface. // // if err := p.LeaveGroup(en0, &net.UDPAddr{IP: net.ParseIP("ff02::114")}); err != nil { // // error handling // } // if err := p.JoinGroup(en0, &net.UDPAddr{IP: net.ParseIP("ff01::114")}); err != nil { // // error handling // } // // # Source-specific multicasting // // An application that uses PacketConn on MLDv2 supported platform is // able to join source-specific multicast groups. // The application may use JoinSourceSpecificGroup and // LeaveSourceSpecificGroup for the operation known as "include" mode, // // ssmgroup := net.UDPAddr{IP: net.ParseIP("ff32::8000:9")} // ssmsource := net.UDPAddr{IP: net.ParseIP("fe80::cafe")} // if err := p.JoinSourceSpecificGroup(en0, &ssmgroup, &ssmsource); err != nil { // // error handling // } // if err := p.LeaveSourceSpecificGroup(en0, &ssmgroup, &ssmsource); err != nil { // // error handling // } // // or JoinGroup, ExcludeSourceSpecificGroup, // IncludeSourceSpecificGroup and LeaveGroup for the operation known // as "exclude" mode. // // exclsource := net.UDPAddr{IP: net.ParseIP("fe80::dead")} // if err := p.JoinGroup(en0, &ssmgroup); err != nil { // // error handling // } // if err := p.ExcludeSourceSpecificGroup(en0, &ssmgroup, &exclsource); err != nil { // // error handling // } // if err := p.LeaveGroup(en0, &ssmgroup); err != nil { // // error handling // } // // Note that it depends on each platform implementation what happens // when an application which runs on MLDv2 unsupported platform uses // JoinSourceSpecificGroup and LeaveSourceSpecificGroup. // In general the platform tries to fall back to conversations using // MLDv1 and starts to listen to multicast traffic. // In the fallback case, ExcludeSourceSpecificGroup and // IncludeSourceSpecificGroup may return an error. package ipv6 // import "golang.org/x/net/ipv6" // BUG(mikio): This package is not implemented on JS, NaCl and Plan 9.	7.71 KB	2025-05-25 12:27
📄 endpoint.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" "time" "golang.org/x/net/internal/socket" ) // BUG(mikio): On Windows, the JoinSourceSpecificGroup, // LeaveSourceSpecificGroup, ExcludeSourceSpecificGroup and // IncludeSourceSpecificGroup methods of PacketConn are not // implemented. // A Conn represents a network endpoint that uses IPv6 transport. // It allows to set basic IP-level socket options such as traffic // class and hop limit. type Conn struct { genericOpt } type genericOpt struct { socket.Conn } func (c genericOpt) ok() bool { return c != nil && c.Conn != nil } // PathMTU returns a path MTU value for the destination associated // with the endpoint. func (c Conn) PathMTU() (int, error) { if !c.ok() { return 0, errInvalidConn } so, ok := sockOpts[ssoPathMTU] if !ok { return 0, errNotImplemented } _, mtu, err := so.getMTUInfo(c.Conn) if err != nil { return 0, err } return mtu, nil } // NewConn returns a new Conn. func NewConn(c net.Conn) Conn { cc, _ := socket.NewConn(c) return &Conn{ genericOpt: genericOpt{Conn: cc}, } } // A PacketConn represents a packet network endpoint that uses IPv6 // transport. It is used to control several IP-level socket options // including IPv6 header manipulation. It also provides datagram // based network I/O methods specific to the IPv6 and higher layer // protocols such as OSPF, GRE, and UDP. type PacketConn struct { genericOpt dgramOpt payloadHandler } type dgramOpt struct { socket.Conn } func (c dgramOpt) ok() bool { return c != nil && c.Conn != nil } // SetControlMessage allows to receive the per packet basis IP-level // socket options. func (c PacketConn) SetControlMessage(cf ControlFlags, on bool) error { if !c.payloadHandler.ok() { return errInvalidConn } return setControlMessage(c.dgramOpt.Conn, &c.payloadHandler.rawOpt, cf, on) } // SetDeadline sets the read and write deadlines associated with the // endpoint. func (c PacketConn) SetDeadline(t time.Time) error { if !c.payloadHandler.ok() { return errInvalidConn } return c.payloadHandler.SetDeadline(t) } // SetReadDeadline sets the read deadline associated with the // endpoint. func (c PacketConn) SetReadDeadline(t time.Time) error { if !c.payloadHandler.ok() { return errInvalidConn } return c.payloadHandler.SetReadDeadline(t) } // SetWriteDeadline sets the write deadline associated with the // endpoint. func (c PacketConn) SetWriteDeadline(t time.Time) error { if !c.payloadHandler.ok() { return errInvalidConn } return c.payloadHandler.SetWriteDeadline(t) } // Close closes the endpoint. func (c PacketConn) Close() error { if !c.payloadHandler.ok() { return errInvalidConn } return c.payloadHandler.Close() } // NewPacketConn returns a new PacketConn using c as its underlying // transport. func NewPacketConn(c net.PacketConn) PacketConn { cc, _ := socket.NewConn(c.(net.Conn)) return &PacketConn{ genericOpt: genericOpt{Conn: cc}, dgramOpt: dgramOpt{Conn: cc}, payloadHandler: payloadHandler{PacketConn: c, Conn: cc}, } }	3.13 KB	2025-05-25 12:27
📄 errors_other_test.go // Copyright 2021 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. //go:build !(aix \|\| darwin \|\| dragonfly \|\| freebsd \|\| linux \|\| netbsd \|\| openbsd \|\| solaris) package ipv6_test // isENOBUFS reports whether err is unix.ENOBUFS. // (Always false on non-Unix platforms.) func isENOBUFS(err error) bool { return false }	413 B	2025-05-25 12:27
📄 errors_unix_test.go // Copyright 2021 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. //go:build aix \|\| darwin \|\| dragonfly \|\| freebsd \|\| linux \|\| netbsd \|\| openbsd \|\| solaris package ipv6_test import ( "errors" "golang.org/x/sys/unix" ) // isENOBUFS reports whether err is unix.ENOBUFS. // (Always false on non-Unix platforms.) func isENOBUFS(err error) bool { return errors.Is(err, unix.ENOBUFS) }	481 B	2025-05-25 12:27
📄 example_test.go // Copyright 2014 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_test import ( "fmt" "log" "net" "os" "time" "golang.org/x/net/icmp" "golang.org/x/net/ipv6" ) func ExampleConn_markingTCP() { ln, err := net.Listen("tcp", "[::]:1024") if err != nil { log.Fatal(err) } defer ln.Close() for { c, err := ln.Accept() if err != nil { log.Fatal(err) } go func(c net.Conn) { defer c.Close() if c.RemoteAddr().(net.TCPAddr).IP.To16() != nil && c.RemoteAddr().(net.TCPAddr).IP.To4() == nil { p := ipv6.NewConn(c) if err := p.SetTrafficClass(0x28); err != nil { // DSCP AF11 log.Fatal(err) } if err := p.SetHopLimit(128); err != nil { log.Fatal(err) } } if _, err := c.Write([]byte("HELLO-R-U-THERE-ACK")); err != nil { log.Fatal(err) } }(c) } } func ExamplePacketConn_servingOneShotMulticastDNS() { c, err := net.ListenPacket("udp6", "[::]:5353") // mDNS over UDP if err != nil { log.Fatal(err) } defer c.Close() p := ipv6.NewPacketConn(c) en0, err := net.InterfaceByName("en0") if err != nil { log.Fatal(err) } mDNSLinkLocal := net.UDPAddr{IP: net.ParseIP("ff02::fb")} if err := p.JoinGroup(en0, &mDNSLinkLocal); err != nil { log.Fatal(err) } defer p.LeaveGroup(en0, &mDNSLinkLocal) if err := p.SetControlMessage(ipv6.FlagDst\|ipv6.FlagInterface, true); err != nil { log.Fatal(err) } var wcm ipv6.ControlMessage b := make([]byte, 1500) for { _, rcm, peer, err := p.ReadFrom(b) if err != nil { log.Fatal(err) } if !rcm.Dst.IsMulticast() \|\| !rcm.Dst.Equal(mDNSLinkLocal.IP) { continue } wcm.IfIndex = rcm.IfIndex answers := []byte("FAKE-MDNS-ANSWERS") // fake mDNS answers, you need to implement this if _, err := p.WriteTo(answers, &wcm, peer); err != nil { log.Fatal(err) } } } func ExamplePacketConn_tracingIPPacketRoute() { // Tracing an IP packet route to www.google.com. const host = "www.google.com" ips, err := net.LookupIP(host) if err != nil { log.Fatal(err) } var dst net.IPAddr for _, ip := range ips { if ip.To16() != nil && ip.To4() == nil { dst.IP = ip fmt.Printf("using %v for tracing an IP packet route to %s\n", dst.IP, host) break } } if dst.IP == nil { log.Fatal("no AAAA record found") } c, err := net.ListenPacket("ip6:58", "::") // ICMP for IPv6 if err != nil { log.Fatal(err) } defer c.Close() p := ipv6.NewPacketConn(c) if err := p.SetControlMessage(ipv6.FlagHopLimit\|ipv6.FlagSrc\|ipv6.FlagDst\|ipv6.FlagInterface, true); err != nil { log.Fatal(err) } wm := icmp.Message{ Type: ipv6.ICMPTypeEchoRequest, Code: 0, Body: &icmp.Echo{ ID: os.Getpid() & 0xffff, Data: []byte("HELLO-R-U-THERE"), }, } var f ipv6.ICMPFilter f.SetAll(true) f.Accept(ipv6.ICMPTypeTimeExceeded) f.Accept(ipv6.ICMPTypeEchoReply) if err := p.SetICMPFilter(&f); err != nil { log.Fatal(err) } var wcm ipv6.ControlMessage rb := make([]byte, 1500) for i := 1; i <= 64; i++ { // up to 64 hops wm.Body.(icmp.Echo).Seq = i wb, err := wm.Marshal(nil) if err != nil { log.Fatal(err) } // In the real world usually there are several // multiple traffic-engineered paths for each hop. // You may need to probe a few times to each hop. begin := time.Now() wcm.HopLimit = i if _, err := p.WriteTo(wb, &wcm, &dst); err != nil { log.Fatal(err) } if err := p.SetReadDeadline(time.Now().Add(3 time.Second)); err != nil { log.Fatal(err) } n, rcm, peer, err := p.ReadFrom(rb) if err != nil { if err, ok := err.(net.Error); ok && err.Timeout() { fmt.Printf("%v\t*\n", i) continue } log.Fatal(err) } rm, err := icmp.ParseMessage(58, rb[:n]) if err != nil { log.Fatal(err) } rtt := time.Since(begin) // In the real world you need to determine whether the // received message is yours using ControlMessage.Src, // ControlMesage.Dst, icmp.Echo.ID and icmp.Echo.Seq. switch rm.Type { case ipv6.ICMPTypeTimeExceeded: names, _ := net.LookupAddr(peer.String()) fmt.Printf("%d\t%v %+v %v\n\t%+v\n", i, peer, names, rtt, rcm) case ipv6.ICMPTypeEchoReply: names, _ := net.LookupAddr(peer.String()) fmt.Printf("%d\t%v %+v %v\n\t%+v\n", i, peer, names, rtt, rcm) return } } } func ExamplePacketConn_advertisingOSPFHello() { c, err := net.ListenPacket("ip6:89", "::") // OSPF for IPv6 if err != nil { log.Fatal(err) } defer c.Close() p := ipv6.NewPacketConn(c) en0, err := net.InterfaceByName("en0") if err != nil { log.Fatal(err) } allSPFRouters := net.IPAddr{IP: net.ParseIP("ff02::5")} if err := p.JoinGroup(en0, &allSPFRouters); err != nil { log.Fatal(err) } defer p.LeaveGroup(en0, &allSPFRouters) hello := make([]byte, 24) // fake hello data, you need to implement this ospf := make([]byte, 16) // fake ospf header, you need to implement this ospf[0] = 3 // version 3 ospf[1] = 1 // hello packet ospf = append(ospf, hello...) if err := p.SetChecksum(true, 12); err != nil { log.Fatal(err) } cm := ipv6.ControlMessage{ TrafficClass: 0xc0, // DSCP CS6 HopLimit: 1, IfIndex: en0.Index, } if _, err := p.WriteTo(ospf, &cm, &allSPFRouters); err != nil { log.Fatal(err) } }	5.2 KB	2025-05-25 12:27
📄 export_test.go // Copyright 2023 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 var ErrNotImplemented = errNotImplemented	216 B	2025-05-25 12:27
📄 gen.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. //go:build ignore //go:generate go run gen.go // This program generates system adaptation constants and types, // internet protocol constants and tables by reading template files // and IANA protocol registries. package main import ( "bytes" "encoding/xml" "fmt" "go/format" "io" "net/http" "os" "os/exec" "runtime" "strconv" "strings" ) func main() { if err := genzsys(); err != nil { fmt.Fprintln(os.Stderr, err) os.Exit(1) } if err := geniana(); err != nil { fmt.Fprintln(os.Stderr, err) os.Exit(1) } } func genzsys() error { defs := "defs_" + runtime.GOOS + ".go" f, err := os.Open(defs) if err != nil { if os.IsNotExist(err) { return nil } return err } f.Close() cmd := exec.Command("go", "tool", "cgo", "-godefs", defs) b, err := cmd.Output() if err != nil { return err } b, err = format.Source(b) if err != nil { return err } zsys := "zsys_" + runtime.GOOS + ".go" switch runtime.GOOS { case "freebsd", "linux": zsys = "zsys_" + runtime.GOOS + "_" + runtime.GOARCH + ".go" } if err := os.WriteFile(zsys, b, 0644); err != nil { return err } return nil } var registries = []struct { url string parse func(io.Writer, io.Reader) error }{ { "https://www.iana.org/assignments/icmpv6-parameters/icmpv6-parameters.xml", parseICMPv6Parameters, }, } func geniana() error { var bb bytes.Buffer fmt.Fprintf(&bb, "// go generate gen.go\n") fmt.Fprintf(&bb, "// Code generated by the command above; DO NOT EDIT.\n\n") fmt.Fprintf(&bb, "package ipv6\n\n") for _, r := range registries { resp, err := http.Get(r.url) if err != nil { return err } defer resp.Body.Close() if resp.StatusCode != http.StatusOK { return fmt.Errorf("got HTTP status code %v for %v\n", resp.StatusCode, r.url) } if err := r.parse(&bb, resp.Body); err != nil { return err } fmt.Fprintf(&bb, "\n") } b, err := format.Source(bb.Bytes()) if err != nil { return err } if err := os.WriteFile("iana.go", b, 0644); err != nil { return err } return nil } func parseICMPv6Parameters(w io.Writer, r io.Reader) error { dec := xml.NewDecoder(r) var icp icmpv6Parameters if err := dec.Decode(&icp); err != nil { return err } prs := icp.escape() fmt.Fprintf(w, "// %s, Updated: %s\n", icp.Title, icp.Updated) fmt.Fprintf(w, "const (\n") for _, pr := range prs { if pr.Name == "" { continue } fmt.Fprintf(w, "ICMPType%s ICMPType = %d", pr.Name, pr.Value) fmt.Fprintf(w, "// %s\n", pr.OrigName) } fmt.Fprintf(w, ")\n\n") fmt.Fprintf(w, "// %s, Updated: %s\n", icp.Title, icp.Updated) fmt.Fprintf(w, "var icmpTypes = map[ICMPType]string{\n") for _, pr := range prs { if pr.Name == "" { continue } fmt.Fprintf(w, "%d: %q,\n", pr.Value, strings.ToLower(pr.OrigName)) } fmt.Fprintf(w, "}\n") return nil } type icmpv6Parameters struct { XMLName xml.Name `xml:"registry"` Title string `xml:"title"` Updated string `xml:"updated"` Registries []struct { Title string `xml:"title"` Records []struct { Value string `xml:"value"` Name string `xml:"name"` } `xml:"record"` } `xml:"registry"` } type canonICMPv6ParamRecord struct { OrigName string Name string Value int } func (icp *icmpv6Parameters) escape() []canonICMPv6ParamRecord { id := -1 for i, r := range icp.Registries { if strings.Contains(r.Title, "Type") \|\| strings.Contains(r.Title, "type") { id = i break } } if id < 0 { return nil } prs := make([]canonICMPv6ParamRecord, len(icp.Registries[id].Records)) sr := strings.NewReplacer( "Messages", "", "Message", "", "ICMP", "", "+", "P", "-", "", "/", "", ".", "", " ", "", ) for i, pr := range icp.Registries[id].Records { if strings.Contains(pr.Name, "Reserved") \|\| strings.Contains(pr.Name, "Unassigned") \|\| strings.Contains(pr.Name, "Deprecated") \|\| strings.Contains(pr.Name, "Experiment") \|\| strings.Contains(pr.Name, "experiment") { continue } ss := strings.Split(pr.Name, "\n") if len(ss) > 1 { prs[i].Name = strings.Join(ss, " ") } else { prs[i].Name = ss[0] } s := strings.TrimSpace(prs[i].Name) prs[i].OrigName = s prs[i].Name = sr.Replace(s) prs[i].Value, _ = strconv.Atoi(pr.Value) } return prs }	4.3 KB	2025-05-25 12:27
📄 genericopt.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 // TrafficClass returns the traffic class field value for outgoing // packets. func (c genericOpt) TrafficClass() (int, error) { if !c.ok() { return 0, errInvalidConn } so, ok := sockOpts[ssoTrafficClass] if !ok { return 0, errNotImplemented } return so.GetInt(c.Conn) } // SetTrafficClass sets the traffic class field value for future // outgoing packets. func (c genericOpt) SetTrafficClass(tclass int) error { if !c.ok() { return errInvalidConn } so, ok := sockOpts[ssoTrafficClass] if !ok { return errNotImplemented } return so.SetInt(c.Conn, tclass) } // HopLimit returns the hop limit field value for outgoing packets. func (c genericOpt) HopLimit() (int, error) { if !c.ok() { return 0, errInvalidConn } so, ok := sockOpts[ssoHopLimit] if !ok { return 0, errNotImplemented } return so.GetInt(c.Conn) } // SetHopLimit sets the hop limit field value for future outgoing // packets. func (c genericOpt) SetHopLimit(hoplim int) error { if !c.ok() { return errInvalidConn } so, ok := sockOpts[ssoHopLimit] if !ok { return errNotImplemented } return so.SetInt(c.Conn, hoplim) }	1.27 KB	2025-05-25 12:27
📄 header.go // Copyright 2014 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 ( "encoding/binary" "fmt" "net" ) const ( Version = 6 // protocol version HeaderLen = 40 // header length ) // A Header represents an IPv6 base header. type Header struct { Version int // protocol version TrafficClass int // traffic class FlowLabel int // flow label PayloadLen int // payload length NextHeader int // next header HopLimit int // hop limit Src net.IP // source address Dst net.IP // destination address } func (h Header) String() string { if h == nil { return "<nil>" } return fmt.Sprintf("ver=%d tclass=%#x flowlbl=%#x payloadlen=%d nxthdr=%d hoplim=%d src=%v dst=%v", h.Version, h.TrafficClass, h.FlowLabel, h.PayloadLen, h.NextHeader, h.HopLimit, h.Src, h.Dst) } // ParseHeader parses b as an IPv6 base header. func ParseHeader(b []byte) (Header, error) { if len(b) < HeaderLen { return nil, errHeaderTooShort } h := &Header{ Version: int(b[0]) >> 4, TrafficClass: int(b[0]&0x0f)<<4 \| int(b[1])>>4, FlowLabel: int(b[1]&0x0f)<<16 \| int(b[2])<<8 \| int(b[3]), PayloadLen: int(binary.BigEndian.Uint16(b[4:6])), NextHeader: int(b[6]), HopLimit: int(b[7]), } h.Src = make(net.IP, net.IPv6len) copy(h.Src, b[8:24]) h.Dst = make(net.IP, net.IPv6len) copy(h.Dst, b[24:40]) return h, nil }	1.46 KB	2025-05-25 12:27
📄 header_test.go // Copyright 2014 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_test import ( "net" "reflect" "strings" "testing" "golang.org/x/net/internal/iana" "golang.org/x/net/ipv6" ) var ( wireHeaderFromKernel = [ipv6.HeaderLen]byte{ 0x69, 0x8b, 0xee, 0xf1, 0xca, 0xfe, 0x2c, 0x01, 0x20, 0x01, 0x0d, 0xb8, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x20, 0x01, 0x0d, 0xb8, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, } testHeader = &ipv6.Header{ Version: ipv6.Version, TrafficClass: iana.DiffServAF43, FlowLabel: 0xbeef1, PayloadLen: 0xcafe, NextHeader: iana.ProtocolIPv6Frag, HopLimit: 1, Src: net.ParseIP("2001:db8:1::1"), Dst: net.ParseIP("2001:db8:2::1"), } ) func TestParseHeader(t *testing.T) { h, err := ipv6.ParseHeader(wireHeaderFromKernel[:]) if err != nil { t.Fatal(err) } if !reflect.DeepEqual(h, testHeader) { t.Fatalf("got %#v; want %#v", h, testHeader) } s := h.String() if strings.Contains(s, ",") { t.Fatalf("should be space-separated values: %s", s) } }	1.2 KB	2025-05-25 12:27
📄 helper.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 ( "errors" "net" "runtime" ) var ( errInvalidConn = errors.New("invalid connection") errMissingAddress = errors.New("missing address") errHeaderTooShort = errors.New("header too short") errInvalidConnType = errors.New("invalid conn type") errNotImplemented = errors.New("not implemented on " + runtime.GOOS + "/" + runtime.GOARCH) ) func boolint(b bool) int { if b { return 1 } return 0 } func netAddrToIP16(a net.Addr) net.IP { switch v := a.(type) { case net.UDPAddr: if ip := v.IP.To16(); ip != nil && ip.To4() == nil { return ip } case net.IPAddr: if ip := v.IP.To16(); ip != nil && ip.To4() == nil { return ip } } return nil } func opAddr(a net.Addr) net.Addr { switch a.(type) { case net.TCPAddr: if a == nil { return nil } case net.UDPAddr: if a == nil { return nil } case *net.IPAddr: if a == nil { return nil } } return a }	1.06 KB	2025-05-25 12:27
📄 helper_posix_test.go // Copyright 2014 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. //go:build aix \|\| darwin \|\| dragonfly \|\| freebsd \|\| linux \|\| netbsd \|\| openbsd \|\| solaris \|\| windows \|\| zos package ipv6_test import ( "errors" "os" "syscall" "golang.org/x/net/ipv6" ) func protocolNotSupported(err error) bool { switch err := err.(type) { case syscall.Errno: switch err { case syscall.EPROTONOSUPPORT, syscall.ENOPROTOOPT: return true } case *os.SyscallError: switch err := err.Err.(type) { case syscall.Errno: switch err { case syscall.EPROTONOSUPPORT, syscall.ENOPROTOOPT: return true } } } return errors.Is(err, ipv6.ErrNotImplemented) }	759 B	2025-05-25 12:27
📄 helper_stub_test.go // Copyright 2014 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. //go:build !aix && !darwin && !dragonfly && !freebsd && !linux && !netbsd && !openbsd && !solaris && !windows && !zos package ipv6_test import ( "fmt" "runtime" ) func supportsIPv6MulticastDeliveryOnLoopback() (string, bool) { return fmt.Sprintf("not supported on %s/%s", runtime.GOOS, runtime.GOARCH), false } func protocolNotSupported(err error) bool { return false }	538 B	2025-05-25 12:27
📄 helper_unix_test.go // Copyright 2015 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. //go:build aix \|\| darwin \|\| dragonfly \|\| freebsd \|\| linux \|\| netbsd \|\| openbsd \|\| solaris \|\| zos package ipv6_test import ( "fmt" "runtime" ) func supportsIPv6MulticastDeliveryOnLoopback() (string, bool) { switch runtime.GOOS { case "freebsd": // See http://www.freebsd.org/cgi/query-pr.cgi?pr=180065. // Even after the fix, it looks like the latest // kernels don't deliver link-local scoped multicast // packets correctly. return fmt.Sprintf("not supported on %s/%s", runtime.GOOS, runtime.GOARCH), false case "openbsd": // Multicast packets don't seem to be delivered locally. // Issue 42064. return fmt.Sprintf("not supported on %s/%s", runtime.GOOS, runtime.GOARCH), false default: return "", true } }	895 B	2025-05-25 12:27
📄 helper_windows_test.go // Copyright 2015 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_test func supportsIPv6MulticastDeliveryOnLoopback() (string, bool) { return "", true }	262 B	2025-05-25 12:27
📄 iana.go // go generate gen.go // Code generated by the command above; DO NOT EDIT. package ipv6 // Internet Control Message Protocol version 6 (ICMPv6) Parameters, Updated: 2018-03-09 const ( ICMPTypeDestinationUnreachable ICMPType = 1 // Destination Unreachable ICMPTypePacketTooBig ICMPType = 2 // Packet Too Big ICMPTypeTimeExceeded ICMPType = 3 // Time Exceeded ICMPTypeParameterProblem ICMPType = 4 // Parameter Problem ICMPTypeEchoRequest ICMPType = 128 // Echo Request ICMPTypeEchoReply ICMPType = 129 // Echo Reply ICMPTypeMulticastListenerQuery ICMPType = 130 // Multicast Listener Query ICMPTypeMulticastListenerReport ICMPType = 131 // Multicast Listener Report ICMPTypeMulticastListenerDone ICMPType = 132 // Multicast Listener Done ICMPTypeRouterSolicitation ICMPType = 133 // Router Solicitation ICMPTypeRouterAdvertisement ICMPType = 134 // Router Advertisement ICMPTypeNeighborSolicitation ICMPType = 135 // Neighbor Solicitation ICMPTypeNeighborAdvertisement ICMPType = 136 // Neighbor Advertisement ICMPTypeRedirect ICMPType = 137 // Redirect Message ICMPTypeRouterRenumbering ICMPType = 138 // Router Renumbering ICMPTypeNodeInformationQuery ICMPType = 139 // ICMP Node Information Query ICMPTypeNodeInformationResponse ICMPType = 140 // ICMP Node Information Response ICMPTypeInverseNeighborDiscoverySolicitation ICMPType = 141 // Inverse Neighbor Discovery Solicitation Message ICMPTypeInverseNeighborDiscoveryAdvertisement ICMPType = 142 // Inverse Neighbor Discovery Advertisement Message ICMPTypeVersion2MulticastListenerReport ICMPType = 143 // Version 2 Multicast Listener Report ICMPTypeHomeAgentAddressDiscoveryRequest ICMPType = 144 // Home Agent Address Discovery Request Message ICMPTypeHomeAgentAddressDiscoveryReply ICMPType = 145 // Home Agent Address Discovery Reply Message ICMPTypeMobilePrefixSolicitation ICMPType = 146 // Mobile Prefix Solicitation ICMPTypeMobilePrefixAdvertisement ICMPType = 147 // Mobile Prefix Advertisement ICMPTypeCertificationPathSolicitation ICMPType = 148 // Certification Path Solicitation Message ICMPTypeCertificationPathAdvertisement ICMPType = 149 // Certification Path Advertisement Message ICMPTypeMulticastRouterAdvertisement ICMPType = 151 // Multicast Router Advertisement ICMPTypeMulticastRouterSolicitation ICMPType = 152 // Multicast Router Solicitation ICMPTypeMulticastRouterTermination ICMPType = 153 // Multicast Router Termination ICMPTypeFMIPv6 ICMPType = 154 // FMIPv6 Messages ICMPTypeRPLControl ICMPType = 155 // RPL Control Message ICMPTypeILNPv6LocatorUpdate ICMPType = 156 // ILNPv6 Locator Update Message ICMPTypeDuplicateAddressRequest ICMPType = 157 // Duplicate Address Request ICMPTypeDuplicateAddressConfirmation ICMPType = 158 // Duplicate Address Confirmation ICMPTypeMPLControl ICMPType = 159 // MPL Control Message ICMPTypeExtendedEchoRequest ICMPType = 160 // Extended Echo Request ICMPTypeExtendedEchoReply ICMPType = 161 // Extended Echo Reply ) // Internet Control Message Protocol version 6 (ICMPv6) Parameters, Updated: 2018-03-09 var icmpTypes = map[ICMPType]string{ 1: "destination unreachable", 2: "packet too big", 3: "time exceeded", 4: "parameter problem", 128: "echo request", 129: "echo reply", 130: "multicast listener query", 131: "multicast listener report", 132: "multicast listener done", 133: "router solicitation", 134: "router advertisement", 135: "neighbor solicitation", 136: "neighbor advertisement", 137: "redirect message", 138: "router renumbering", 139: "icmp node information query", 140: "icmp node information response", 141: "inverse neighbor discovery solicitation message", 142: "inverse neighbor discovery advertisement message", 143: "version 2 multicast listener report", 144: "home agent address discovery request message", 145: "home agent address discovery reply message", 146: "mobile prefix solicitation", 147: "mobile prefix advertisement", 148: "certification path solicitation message", 149: "certification path advertisement message", 151: "multicast router advertisement", 152: "multicast router solicitation", 153: "multicast router termination", 154: "fmipv6 messages", 155: "rpl control message", 156: "ilnpv6 locator update message", 157: "duplicate address request", 158: "duplicate address confirmation", 159: "mpl control message", 160: "extended echo request", 161: "extended echo reply", }	4.9 KB	2025-05-25 12:27
📄 icmp.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 "golang.org/x/net/internal/iana" // BUG(mikio): On Windows, methods related to ICMPFilter are not // implemented. // An ICMPType represents a type of ICMP message. type ICMPType int func (typ ICMPType) String() string { s, ok := icmpTypes[typ] if !ok { return "<nil>" } return s } // Protocol returns the ICMPv6 protocol number. func (typ ICMPType) Protocol() int { return iana.ProtocolIPv6ICMP } // An ICMPFilter represents an ICMP message filter for incoming // packets. The filter belongs to a packet delivery path on a host and // it cannot interact with forwarding packets or tunnel-outer packets. // // Note: RFC 8200 defines a reasonable role model. A node means a // device that implements IP. A router means a node that forwards IP // packets not explicitly addressed to itself, and a host means a node // that is not a router. type ICMPFilter struct { icmpv6Filter } // Accept accepts incoming ICMP packets including the type field value // typ. func (f ICMPFilter) Accept(typ ICMPType) { f.accept(typ) } // Block blocks incoming ICMP packets including the type field value // typ. func (f ICMPFilter) Block(typ ICMPType) { f.block(typ) } // SetAll sets the filter action to the filter. func (f ICMPFilter) SetAll(block bool) { f.setAll(block) } // WillBlock reports whether the ICMP type will be blocked. func (f ICMPFilter) WillBlock(typ ICMPType) bool { return f.willBlock(typ) }	1.56 KB	2025-05-25 12:27
📄 icmp_bsd.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. //go:build aix \|\| darwin \|\| dragonfly \|\| freebsd \|\| netbsd \|\| openbsd package ipv6 func (f icmpv6Filter) accept(typ ICMPType) { f.Filt[typ>>5] \|= 1 << (uint32(typ) & 31) } func (f icmpv6Filter) block(typ ICMPType) { f.Filt[typ>>5] &^= 1 << (uint32(typ) & 31) } func (f icmpv6Filter) setAll(block bool) { for i := range f.Filt { if block { f.Filt[i] = 0 } else { f.Filt[i] = 1<<32 - 1 } } } func (f icmpv6Filter) willBlock(typ ICMPType) bool { return f.Filt[typ>>5]&(1<<(uint32(typ)&31)) == 0 }	680 B	2025-05-25 12:27
📄 icmp_linux.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 func (f icmpv6Filter) accept(typ ICMPType) { f.Data[typ>>5] &^= 1 << (uint32(typ) & 31) } func (f icmpv6Filter) block(typ ICMPType) { f.Data[typ>>5] \|= 1 << (uint32(typ) & 31) } func (f icmpv6Filter) setAll(block bool) { for i := range f.Data { if block { f.Data[i] = 1<<32 - 1 } else { f.Data[i] = 0 } } } func (f icmpv6Filter) willBlock(typ ICMPType) bool { return f.Data[typ>>5]&(1<<(uint32(typ)&31)) != 0 }	609 B	2025-05-25 12:27
📄 icmp_solaris.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 func (f icmpv6Filter) accept(typ ICMPType) { f.X__icmp6_filt[typ>>5] \|= 1 << (uint32(typ) & 31) } func (f icmpv6Filter) block(typ ICMPType) { f.X__icmp6_filt[typ>>5] &^= 1 << (uint32(typ) & 31) } func (f icmpv6Filter) setAll(block bool) { for i := range f.X__icmp6_filt { if block { f.X__icmp6_filt[i] = 0 } else { f.X__icmp6_filt[i] = 1<<32 - 1 } } } func (f icmpv6Filter) willBlock(typ ICMPType) bool { return f.X__icmp6_filt[typ>>5]&(1<<(uint32(typ)&31)) == 0 }	663 B	2025-05-25 12:27
📄 icmp_stub.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. //go:build !aix && !darwin && !dragonfly && !freebsd && !linux && !netbsd && !openbsd && !solaris && !windows && !zos package ipv6 type icmpv6Filter struct { } func (f icmpv6Filter) accept(typ ICMPType) { } func (f icmpv6Filter) block(typ ICMPType) { } func (f icmpv6Filter) setAll(block bool) { } func (f icmpv6Filter) willBlock(typ ICMPType) bool { return false }	537 B	2025-05-25 12:27
📄 icmp_test.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_test import ( "errors" "net" "reflect" "runtime" "testing" "golang.org/x/net/ipv6" "golang.org/x/net/nettest" ) var icmpStringTests = []struct { in ipv6.ICMPType out string }{ {ipv6.ICMPTypeDestinationUnreachable, "destination unreachable"}, {256, "<nil>"}, } func TestICMPString(t testing.T) { for _, tt := range icmpStringTests { s := tt.in.String() if s != tt.out { t.Errorf("got %s; want %s", s, tt.out) } } } func TestICMPFilter(t testing.T) { switch runtime.GOOS { case "fuchsia", "hurd", "js", "nacl", "plan9", "wasip1", "windows": t.Skipf("not supported on %s", runtime.GOOS) } var f ipv6.ICMPFilter for _, toggle := range []bool{false, true} { f.SetAll(toggle) for _, typ := range []ipv6.ICMPType{ ipv6.ICMPTypeDestinationUnreachable, ipv6.ICMPTypeEchoReply, ipv6.ICMPTypeNeighborSolicitation, ipv6.ICMPTypeDuplicateAddressConfirmation, } { f.Accept(typ) if f.WillBlock(typ) { t.Errorf("ipv6.ICMPFilter.Set(%v, false) failed", typ) } f.Block(typ) if !f.WillBlock(typ) { t.Errorf("ipv6.ICMPFilter.Set(%v, true) failed", typ) } } } } func TestSetICMPFilter(t *testing.T) { if !nettest.SupportsIPv6() { t.Skip("ipv6 is not supported") } if !nettest.SupportsRawSocket() { t.Skipf("not supported on %s/%s", runtime.GOOS, runtime.GOARCH) } c, err := net.ListenPacket("ip6:ipv6-icmp", "::1") if err != nil { t.Fatal(err) } defer c.Close() p := ipv6.NewPacketConn(c) var f ipv6.ICMPFilter f.SetAll(true) f.Accept(ipv6.ICMPTypeEchoRequest) f.Accept(ipv6.ICMPTypeEchoReply) if err := p.SetICMPFilter(&f); errors.Is(err, ipv6.ErrNotImplemented) { t.Skipf("setting ICMP filter not supported: %v", err) } else if err != nil { t.Fatal(err) } kf, err := p.ICMPFilter() if err != nil { t.Fatal(err) } if !reflect.DeepEqual(kf, &f) { t.Fatalf("got %#v; want %#v", kf, f) } }	2.02 KB	2025-05-25 12:27
📄 icmp_windows.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 func (f icmpv6Filter) accept(typ ICMPType) { // TODO(mikio): implement this } func (f icmpv6Filter) block(typ ICMPType) { // TODO(mikio): implement this } func (f icmpv6Filter) setAll(block bool) { // TODO(mikio): implement this } func (f icmpv6Filter) willBlock(typ ICMPType) bool { // TODO(mikio): implement this return false }	516 B	2025-05-25 12:27
📄 icmp_zos.go // Copyright 2020 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 func (f icmpv6Filter) accept(typ ICMPType) { f.Filt[typ>>5] \|= 1 << (uint32(typ) & 31) } func (f icmpv6Filter) block(typ ICMPType) { f.Filt[typ>>5] &^= 1 << (uint32(typ) & 31) } func (f icmpv6Filter) setAll(block bool) { for i := range f.Filt { if block { f.Filt[i] = 0 } else { f.Filt[i] = 1<<32 - 1 } } } func (f icmpv6Filter) willBlock(typ ICMPType) bool { return f.Filt[typ>>5]&(1<<(uint32(typ)&31)) == 0 }	611 B	2025-05-25 12:27
📄 mocktransponder_test.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_test import ( "net" "testing" ) func connector(t testing.T, network, addr string, done chan<- bool) { t.Helper() defer func() { done <- true }() c, err := net.Dial(network, addr) if err != nil { t.Error(err) return } c.Close() } func acceptor(t testing.T, ln net.Listener, done chan<- bool) { t.Helper() defer func() { done <- true }() c, err := ln.Accept() if err != nil { t.Error(err) return } c.Close() }	610 B	2025-05-25 12:27
📄 multicast_test.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_test import ( "bytes" "net" "os" "runtime" "testing" "time" "golang.org/x/net/icmp" "golang.org/x/net/internal/iana" "golang.org/x/net/ipv6" "golang.org/x/net/nettest" ) var packetConnReadWriteMulticastUDPTests = []struct { addr string grp, src net.UDPAddr }{ {"[ff02::]:0", &net.UDPAddr{IP: net.ParseIP("ff02::114")}, nil}, // see RFC 4727 {"[ff30::8000:0]:0", &net.UDPAddr{IP: net.ParseIP("ff30::8000:1")}, &net.UDPAddr{IP: net.IPv6loopback}}, // see RFC 5771 } func TestPacketConnReadWriteMulticastUDP(t testing.T) { switch runtime.GOOS { case "fuchsia", "hurd", "js", "nacl", "plan9", "wasip1", "windows": t.Skipf("not supported on %s", runtime.GOOS) } if !nettest.SupportsIPv6() { t.Skip("ipv6 is not supported") } if m, ok := supportsIPv6MulticastDeliveryOnLoopback(); !ok { t.Skip(m) } ifi, err := nettest.RoutedInterface("ip6", net.FlagUp\|net.FlagMulticast\|net.FlagLoopback) if err != nil { t.Skipf("not available on %s", runtime.GOOS) } for _, tt := range packetConnReadWriteMulticastUDPTests { c, err := net.ListenPacket("udp6", tt.addr) if err != nil { t.Fatal(err) } defer c.Close() grp := tt.grp grp.Port = c.LocalAddr().(net.UDPAddr).Port p := ipv6.NewPacketConn(c) defer p.Close() if tt.src == nil { if err := p.JoinGroup(ifi, &grp); err != nil { t.Fatal(err) } defer p.LeaveGroup(ifi, &grp) } else { if err := p.JoinSourceSpecificGroup(ifi, &grp, tt.src); err != nil { switch runtime.GOOS { case "freebsd", "linux": default: // platforms that don't support MLDv2 fail here t.Logf("not supported on %s", runtime.GOOS) continue } t.Fatal(err) } defer p.LeaveSourceSpecificGroup(ifi, &grp, tt.src) } if err := p.SetMulticastInterface(ifi); err != nil { t.Fatal(err) } if _, err := p.MulticastInterface(); err != nil { t.Fatal(err) } if err := p.SetMulticastLoopback(true); err != nil { t.Fatal(err) } if _, err := p.MulticastLoopback(); err != nil { t.Fatal(err) } cm := ipv6.ControlMessage{ TrafficClass: iana.DiffServAF11 \| iana.CongestionExperienced, Src: net.IPv6loopback, IfIndex: ifi.Index, } cf := ipv6.FlagTrafficClass \| ipv6.FlagHopLimit \| ipv6.FlagSrc \| ipv6.FlagDst \| ipv6.FlagInterface \| ipv6.FlagPathMTU wb := []byte("HELLO-R-U-THERE") for i, toggle := range []bool{true, false, true} { if err := p.SetControlMessage(cf, toggle); err != nil { if protocolNotSupported(err) { t.Logf("not supported on %s", runtime.GOOS) continue } t.Fatal(err) } cm.HopLimit = i + 1 backoff := time.Millisecond for { n, err := p.WriteTo(wb, &cm, &grp) if err != nil { if n == 0 && isENOBUFS(err) { time.Sleep(backoff) backoff = 2 continue } t.Fatal(err) } if n != len(wb) { t.Fatalf("wrote %v bytes; want %v", n, len(wb)) } break } rb := make([]byte, 128) if n, _, _, err := p.ReadFrom(rb); err != nil { t.Fatal(err) } else if !bytes.Equal(rb[:n], wb) { t.Fatalf("got %v; want %v", rb[:n], wb) } } } } var packetConnReadWriteMulticastICMPTests = []struct { grp, src net.IPAddr }{ {&net.IPAddr{IP: net.ParseIP("ff02::114")}, nil}, // see RFC 4727 {&net.IPAddr{IP: net.ParseIP("ff30::8000:1")}, &net.IPAddr{IP: net.IPv6loopback}}, // see RFC 5771 } func TestPacketConnReadWriteMulticastICMP(t testing.T) { if os.Getenv("GO_BUILDER_NAME") == "openbsd-amd64-68" \|\| os.Getenv("GO_BUILDER_NAME") == "openbsd-386-68" { t.Skip(`this test is currently failing on OpenBSD 6.8 builders with "raw-read ip6: i/o timeout" ` + `and needs investigation, see golang.org/issue/42064`) } switch runtime.GOOS { case "fuchsia", "hurd", "js", "nacl", "plan9", "wasip1", "windows": t.Skipf("not supported on %s", runtime.GOOS) } if !nettest.SupportsIPv6() { t.Skip("ipv6 is not supported") } if m, ok := supportsIPv6MulticastDeliveryOnLoopback(); !ok { t.Skip(m) } if !nettest.SupportsRawSocket() { t.Skipf("not supported on %s/%s", runtime.GOOS, runtime.GOARCH) } ifi, err := nettest.RoutedInterface("ip6", net.FlagUp\|net.FlagMulticast\|net.FlagLoopback) if err != nil { t.Skipf("not available on %s", runtime.GOOS) } for _, tt := range packetConnReadWriteMulticastICMPTests { c, err := net.ListenPacket("ip6:ipv6-icmp", "::") if err != nil { t.Fatal(err) } defer c.Close() pshicmp := icmp.IPv6PseudoHeader(c.LocalAddr().(net.IPAddr).IP, tt.grp.IP) p := ipv6.NewPacketConn(c) defer p.Close() if tt.src == nil { if err := p.JoinGroup(ifi, tt.grp); err != nil { t.Fatal(err) } defer p.LeaveGroup(ifi, tt.grp) } else { if err := p.JoinSourceSpecificGroup(ifi, tt.grp, tt.src); err != nil { switch runtime.GOOS { case "freebsd", "linux": default: // platforms that don't support MLDv2 fail here t.Logf("not supported on %s", runtime.GOOS) continue } t.Fatal(err) } defer p.LeaveSourceSpecificGroup(ifi, tt.grp, tt.src) } if err := p.SetMulticastInterface(ifi); err != nil { t.Fatal(err) } if _, err := p.MulticastInterface(); err != nil { t.Fatal(err) } if err := p.SetMulticastLoopback(true); err != nil { t.Fatal(err) } if _, err := p.MulticastLoopback(); err != nil { t.Fatal(err) } cm := ipv6.ControlMessage{ TrafficClass: iana.DiffServAF11 \| iana.CongestionExperienced, Src: net.IPv6loopback, IfIndex: ifi.Index, } cf := ipv6.FlagTrafficClass \| ipv6.FlagHopLimit \| ipv6.FlagSrc \| ipv6.FlagDst \| ipv6.FlagInterface \| ipv6.FlagPathMTU var f ipv6.ICMPFilter f.SetAll(true) f.Accept(ipv6.ICMPTypeEchoReply) if err := p.SetICMPFilter(&f); err != nil { t.Fatal(err) } var psh []byte for i, toggle := range []bool{true, false, true} { if toggle { psh = nil if err := p.SetChecksum(true, 2); err != nil { // Illumos and Solaris never allow // modification of ICMP properties. if runtime.GOOS != "illumos" && runtime.GOOS != "solaris" { t.Fatal(err) } } } else { psh = pshicmp // Some platforms never allow to // disable the kernel checksum // processing. p.SetChecksum(false, -1) } wb, err := (&icmp.Message{ Type: ipv6.ICMPTypeEchoRequest, Code: 0, Body: &icmp.Echo{ ID: os.Getpid() & 0xffff, Seq: i + 1, Data: []byte("HELLO-R-U-THERE"), }, }).Marshal(psh) if err != nil { t.Fatal(err) } if err := p.SetControlMessage(cf, toggle); err != nil { if protocolNotSupported(err) { t.Logf("not supported on %s", runtime.GOOS) continue } t.Fatal(err) } cm.HopLimit = i + 1 if n, err := p.WriteTo(wb, &cm, tt.grp); err != nil { t.Fatal(err) } else if n != len(wb) { t.Fatalf("got %v; want %v", n, len(wb)) } rb := make([]byte, 128) if n, _, _, err := p.ReadFrom(rb); err != nil { switch runtime.GOOS { case "darwin", "ios": // older darwin kernels have some limitation on receiving icmp packet through raw socket t.Logf("not supported on %s", runtime.GOOS) continue } t.Fatal(err) } else { if m, err := icmp.ParseMessage(iana.ProtocolIPv6ICMP, rb[:n]); err != nil { t.Fatal(err) } else if m.Type != ipv6.ICMPTypeEchoReply \|\| m.Code != 0 { t.Fatalf("got type=%v, code=%v; want type=%v, code=%v", m.Type, m.Code, ipv6.ICMPTypeEchoReply, 0) } } } } }	7.44 KB	2025-05-25 12:27
📄 multicastlistener_test.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_test import ( "net" "runtime" "testing" "golang.org/x/net/ipv6" "golang.org/x/net/nettest" ) var udpMultipleGroupListenerTests = []net.Addr{ &net.UDPAddr{IP: net.ParseIP("ff02::114")}, // see RFC 4727 &net.UDPAddr{IP: net.ParseIP("ff02::1:114")}, &net.UDPAddr{IP: net.ParseIP("ff02::2:114")}, } func TestUDPSinglePacketConnWithMultipleGroupListeners(t testing.T) { switch runtime.GOOS { case "fuchsia", "hurd", "js", "nacl", "plan9", "wasip1", "windows": t.Skipf("not supported on %s", runtime.GOOS) } if !nettest.SupportsIPv6() { t.Skip("ipv6 is not supported") } for _, gaddr := range udpMultipleGroupListenerTests { c, err := net.ListenPacket("udp6", "[::]:0") // wildcard address with non-reusable port if err != nil { t.Fatal(err) } defer c.Close() p := ipv6.NewPacketConn(c) var mift []net.Interface ift, err := net.Interfaces() if err != nil { t.Fatal(err) } for i, ifi := range ift { if _, err := nettest.MulticastSource("ip6", &ifi); err != nil { continue } if err := p.JoinGroup(&ifi, gaddr); err != nil { t.Fatal(err) } mift = append(mift, &ift[i]) } for _, ifi := range mift { if err := p.LeaveGroup(ifi, gaddr); err != nil { t.Fatal(err) } } } } func TestUDPMultiplePacketConnWithMultipleGroupListeners(t testing.T) { switch runtime.GOOS { case "fuchsia", "hurd", "js", "nacl", "plan9", "wasip1", "windows", "zos": t.Skipf("not supported on %s", runtime.GOOS) } if !nettest.SupportsIPv6() { t.Skip("ipv6 is not supported") } for _, gaddr := range udpMultipleGroupListenerTests { c1, err := net.ListenPacket("udp6", "[ff02::]:0") // wildcard address with reusable port if err != nil { t.Fatal(err) } defer c1.Close() _, port, err := net.SplitHostPort(c1.LocalAddr().String()) if err != nil { t.Fatal(err) } c2, err := net.ListenPacket("udp6", net.JoinHostPort("ff02::", port)) // wildcard address with reusable port if err != nil { t.Fatal(err) } defer c2.Close() var ps [2]ipv6.PacketConn ps[0] = ipv6.NewPacketConn(c1) ps[1] = ipv6.NewPacketConn(c2) var mift []net.Interface ift, err := net.Interfaces() if err != nil { t.Fatal(err) } for i, ifi := range ift { if _, err := nettest.MulticastSource("ip6", &ifi); err != nil { continue } for _, p := range ps { if err := p.JoinGroup(&ifi, gaddr); err != nil { t.Fatal(err) } } mift = append(mift, &ift[i]) } for _, ifi := range mift { for _, p := range ps { if err := p.LeaveGroup(ifi, gaddr); err != nil { t.Fatal(err) } } } } } func TestUDPPerInterfaceSinglePacketConnWithSingleGroupListener(t testing.T) { switch runtime.GOOS { case "fuchsia", "hurd", "js", "nacl", "plan9", "wasip1", "windows": t.Skipf("not supported on %s", runtime.GOOS) } if !nettest.SupportsIPv6() { t.Skip("ipv6 is not supported") } gaddr := net.IPAddr{IP: net.ParseIP("ff02::114")} // see RFC 4727 type ml struct { c ipv6.PacketConn ifi net.Interface } var mlt []ml ift, err := net.Interfaces() if err != nil { t.Fatal(err) } port := "0" for i, ifi := range ift { ip, err := nettest.MulticastSource("ip6", &ifi) if err != nil { continue } c, err := net.ListenPacket("udp6", net.JoinHostPort(ip.String()+"%"+ifi.Name, port)) // unicast address with non-reusable port if err != nil { // The listen may fail when the service is // already in use, but it's fine because the // purpose of this is not to test the // bookkeeping of IP control block inside the // kernel. t.Log(err) continue } defer c.Close() if port == "0" { _, port, err = net.SplitHostPort(c.LocalAddr().String()) if err != nil { t.Fatal(err) } } p := ipv6.NewPacketConn(c) if err := p.JoinGroup(&ifi, &gaddr); err != nil { t.Fatal(err) } mlt = append(mlt, &ml{p, &ift[i]}) } for _, m := range mlt { if err := m.c.LeaveGroup(m.ifi, &gaddr); err != nil { t.Fatal(err) } } } func TestIPSinglePacketConnWithSingleGroupListener(t testing.T) { if !nettest.SupportsIPv6() { t.Skip("ipv6 is not supported") } if !nettest.SupportsRawSocket() { t.Skipf("not supported on %s/%s", runtime.GOOS, runtime.GOARCH) } c, err := net.ListenPacket("ip6:ipv6-icmp", "::") // wildcard address if err != nil { t.Fatal(err) } defer c.Close() p := ipv6.NewPacketConn(c) gaddr := net.IPAddr{IP: net.ParseIP("ff02::114")} // see RFC 4727 var mift []net.Interface ift, err := net.Interfaces() if err != nil { t.Fatal(err) } for i, ifi := range ift { if _, err := nettest.MulticastSource("ip6", &ifi); err != nil { continue } if err := p.JoinGroup(&ifi, &gaddr); err != nil { t.Fatal(err) } mift = append(mift, &ift[i]) } for _, ifi := range mift { if err := p.LeaveGroup(ifi, &gaddr); err != nil { t.Fatal(err) } } } func TestIPPerInterfaceSinglePacketConnWithSingleGroupListener(t testing.T) { switch runtime.GOOS { case "darwin", "ios", "dragonfly", "openbsd": // platforms that return fe80::1%lo0: bind: can't assign requested address t.Skipf("not supported on %s", runtime.GOOS) } if !nettest.SupportsIPv6() { t.Skip("ipv6 is not supported") } if !nettest.SupportsRawSocket() { t.Skipf("not supported on %s/%s", runtime.GOOS, runtime.GOARCH) } gaddr := net.IPAddr{IP: net.ParseIP("ff02::114")} // see RFC 4727 type ml struct { c ipv6.PacketConn ifi net.Interface } var mlt []*ml ift, err := net.Interfaces() if err != nil { t.Fatal(err) } for i, ifi := range ift { ip, err := nettest.MulticastSource("ip6", &ifi) if err != nil { continue } c, err := net.ListenPacket("ip6:ipv6-icmp", ip.String()+"%"+ifi.Name) // unicast address if err != nil { t.Fatal(err) } defer c.Close() p := ipv6.NewPacketConn(c) if err := p.JoinGroup(&ifi, &gaddr); err != nil { t.Fatal(err) } mlt = append(mlt, &ml{p, &ift[i]}) } for _, m := range mlt { if err := m.c.LeaveGroup(m.ifi, &gaddr); err != nil { t.Fatal(err) } } }	6.07 KB	2025-05-25 12:27
📄 multicastsockopt_test.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_test import ( "net" "runtime" "testing" "golang.org/x/net/ipv6" "golang.org/x/net/nettest" ) var packetConnMulticastSocketOptionTests = []struct { net, proto, addr string grp, src net.Addr }{ {"udp6", "", "[ff02::]:0", &net.UDPAddr{IP: net.ParseIP("ff02::114")}, nil}, // see RFC 4727 {"ip6", ":ipv6-icmp", "::", &net.IPAddr{IP: net.ParseIP("ff02::115")}, nil}, // see RFC 4727 {"udp6", "", "[ff30::8000:0]:0", &net.UDPAddr{IP: net.ParseIP("ff30::8000:1")}, &net.UDPAddr{IP: net.IPv6loopback}}, // see RFC 5771 {"ip6", ":ipv6-icmp", "::", &net.IPAddr{IP: net.ParseIP("ff30::8000:2")}, &net.IPAddr{IP: net.IPv6loopback}}, // see RFC 5771 } func TestPacketConnMulticastSocketOptions(t testing.T) { switch runtime.GOOS { case "fuchsia", "hurd", "js", "nacl", "plan9", "wasip1", "windows": t.Skipf("not supported on %s", runtime.GOOS) } if !nettest.SupportsIPv6() { t.Skip("ipv6 is not supported") } ifi, err := nettest.RoutedInterface("ip6", net.FlagUp\|net.FlagMulticast\|net.FlagLoopback) if err != nil { t.Skipf("not available on %s", runtime.GOOS) } ok := nettest.SupportsRawSocket() for _, tt := range packetConnMulticastSocketOptionTests { if tt.net == "ip6" && !ok { t.Logf("not supported on %s/%s", runtime.GOOS, runtime.GOARCH) continue } c, err := net.ListenPacket(tt.net+tt.proto, tt.addr) if err != nil { t.Fatal(err) } defer c.Close() p := ipv6.NewPacketConn(c) defer p.Close() if tt.src == nil { testMulticastSocketOptions(t, p, ifi, tt.grp) } else { testSourceSpecificMulticastSocketOptions(t, p, ifi, tt.grp, tt.src) } } } type testIPv6MulticastConn interface { MulticastHopLimit() (int, error) SetMulticastHopLimit(ttl int) error MulticastLoopback() (bool, error) SetMulticastLoopback(bool) error JoinGroup(net.Interface, net.Addr) error LeaveGroup(net.Interface, net.Addr) error JoinSourceSpecificGroup(net.Interface, net.Addr, net.Addr) error LeaveSourceSpecificGroup(net.Interface, net.Addr, net.Addr) error ExcludeSourceSpecificGroup(net.Interface, net.Addr, net.Addr) error IncludeSourceSpecificGroup(net.Interface, net.Addr, net.Addr) error } func testMulticastSocketOptions(t testing.T, c testIPv6MulticastConn, ifi net.Interface, grp net.Addr) { t.Helper() const hoplim = 255 if err := c.SetMulticastHopLimit(hoplim); err != nil { t.Error(err) return } if v, err := c.MulticastHopLimit(); err != nil { t.Error(err) return } else if v != hoplim { t.Errorf("got %v; want %v", v, hoplim) return } for _, toggle := range []bool{true, false} { if err := c.SetMulticastLoopback(toggle); err != nil { t.Error(err) return } if v, err := c.MulticastLoopback(); err != nil { t.Error(err) return } else if v != toggle { t.Errorf("got %v; want %v", v, toggle) return } } if err := c.JoinGroup(ifi, grp); err != nil { t.Error(err) return } if err := c.LeaveGroup(ifi, grp); err != nil { t.Error(err) return } } func testSourceSpecificMulticastSocketOptions(t testing.T, c testIPv6MulticastConn, ifi *net.Interface, grp, src net.Addr) { t.Helper() // MCAST_JOIN_GROUP -> MCAST_BLOCK_SOURCE -> MCAST_UNBLOCK_SOURCE -> MCAST_LEAVE_GROUP if err := c.JoinGroup(ifi, grp); err != nil { t.Error(err) return } if err := c.ExcludeSourceSpecificGroup(ifi, grp, src); err != nil { switch runtime.GOOS { case "freebsd", "linux": default: // platforms that don't support MLDv2 fail here t.Logf("not supported on %s", runtime.GOOS) return } t.Error(err) return } if err := c.IncludeSourceSpecificGroup(ifi, grp, src); err != nil { t.Error(err) return } if err := c.LeaveGroup(ifi, grp); err != nil { t.Error(err) return } // MCAST_JOIN_SOURCE_GROUP -> MCAST_LEAVE_SOURCE_GROUP if err := c.JoinSourceSpecificGroup(ifi, grp, src); err != nil { t.Error(err) return } if err := c.LeaveSourceSpecificGroup(ifi, grp, src); err != nil { t.Error(err) return } // MCAST_JOIN_SOURCE_GROUP -> MCAST_LEAVE_GROUP if err := c.JoinSourceSpecificGroup(ifi, grp, src); err != nil { t.Error(err) return } if err := c.LeaveGroup(ifi, grp); err != nil { t.Error(err) return } }	4.26 KB	2025-05-25 12:27
📄 payload.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/internal/socket" ) // BUG(mikio): On Windows, the ControlMessage for ReadFrom and WriteTo // methods of PacketConn is not implemented. // A payloadHandler represents the IPv6 datagram payload handler. type payloadHandler struct { net.PacketConn socket.Conn rawOpt } func (c payloadHandler) ok() bool { return c != nil && c.PacketConn != nil && c.Conn != nil }	578 B	2025-05-25 12:27
📄 payload_cmsg.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. //go:build aix \|\| darwin \|\| dragonfly \|\| freebsd \|\| linux \|\| netbsd \|\| openbsd \|\| solaris \|\| zos package ipv6 import ( "net" "golang.org/x/net/internal/socket" ) // ReadFrom reads a payload of the received IPv6 datagram, from the // endpoint c, copying the payload into b. It returns the number of // bytes copied into b, the control message cm and the source address // src of the received datagram. func (c payloadHandler) ReadFrom(b []byte) (n int, cm ControlMessage, src net.Addr, err error) { if !c.ok() { return 0, nil, nil, errInvalidConn } c.rawOpt.RLock() m := socket.Message{ Buffers: [][]byte{b}, OOB: NewControlMessage(c.rawOpt.cflags), } c.rawOpt.RUnlock() switch c.PacketConn.(type) { case net.UDPConn: if err := c.RecvMsg(&m, 0); err != nil { return 0, nil, nil, &net.OpError{Op: "read", Net: c.PacketConn.LocalAddr().Network(), Source: c.PacketConn.LocalAddr(), Err: err} } case net.IPConn: if err := c.RecvMsg(&m, 0); err != nil { return 0, nil, nil, &net.OpError{Op: "read", Net: c.PacketConn.LocalAddr().Network(), Source: c.PacketConn.LocalAddr(), Err: err} } default: return 0, nil, nil, &net.OpError{Op: "read", Net: c.PacketConn.LocalAddr().Network(), Source: c.PacketConn.LocalAddr(), Err: errInvalidConnType} } if m.NN > 0 { cm = new(ControlMessage) if err := cm.Parse(m.OOB[:m.NN]); err != nil { return 0, nil, nil, &net.OpError{Op: "read", Net: c.PacketConn.LocalAddr().Network(), Source: c.PacketConn.LocalAddr(), Err: err} } cm.Src = netAddrToIP16(m.Addr) } return m.N, cm, m.Addr, nil } // WriteTo writes a payload of the IPv6 datagram, to the destination // address dst through the endpoint c, copying the payload from b. It // returns the number of bytes written. The control message cm allows // the IPv6 header fields and the datagram path to be specified. The // cm may be nil if control of the outgoing datagram is not required. func (c payloadHandler) WriteTo(b []byte, cm ControlMessage, dst net.Addr) (n int, err error) { if !c.ok() { return 0, errInvalidConn } m := socket.Message{ Buffers: [][]byte{b}, OOB: cm.Marshal(), Addr: dst, } err = c.SendMsg(&m, 0) if err != nil { err = &net.OpError{Op: "write", Net: c.PacketConn.LocalAddr().Network(), Source: c.PacketConn.LocalAddr(), Addr: opAddr(dst), Err: err} } return m.N, err }	2.46 KB	2025-05-25 12:27
📄 payload_nocmsg.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. //go:build !aix && !darwin && !dragonfly && !freebsd && !linux && !netbsd && !openbsd && !solaris && !zos package ipv6 import "net" // ReadFrom reads a payload of the received IPv6 datagram, from the // endpoint c, copying the payload into b. It returns the number of // bytes copied into b, the control message cm and the source address // src of the received datagram. func (c payloadHandler) ReadFrom(b []byte) (n int, cm ControlMessage, src net.Addr, err error) { if !c.ok() { return 0, nil, nil, errInvalidConn } if n, src, err = c.PacketConn.ReadFrom(b); err != nil { return 0, nil, nil, err } return } // WriteTo writes a payload of the IPv6 datagram, to the destination // address dst through the endpoint c, copying the payload from b. It // returns the number of bytes written. The control message cm allows // the IPv6 header fields and the datagram path to be specified. The // cm may be nil if control of the outgoing datagram is not required. func (c payloadHandler) WriteTo(b []byte, cm ControlMessage, dst net.Addr) (n int, err error) { if !c.ok() { return 0, errInvalidConn } if dst == nil { return 0, errMissingAddress } return c.PacketConn.WriteTo(b, dst) }	1.33 KB	2025-05-25 12:27
📄 readwrite_test.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_test import ( "bytes" "fmt" "net" "runtime" "strings" "sync" "testing" "time" "golang.org/x/net/internal/iana" "golang.org/x/net/ipv6" "golang.org/x/net/nettest" ) func BenchmarkReadWriteUnicast(b testing.B) { switch runtime.GOOS { case "fuchsia", "hurd", "js", "nacl", "plan9", "wasip1", "windows": b.Skipf("not supported on %s", runtime.GOOS) } c, err := nettest.NewLocalPacketListener("udp6") if err != nil { b.Skipf("not supported on %s/%s: %v", runtime.GOOS, runtime.GOARCH, err) } defer c.Close() dst := c.LocalAddr() wb, rb := []byte("HELLO-R-U-THERE"), make([]byte, 128) b.Run("NetUDP", func(b testing.B) { for i := 0; i < b.N; i++ { if _, err := c.WriteTo(wb, dst); err != nil { b.Fatal(err) } if _, _, err := c.ReadFrom(rb); err != nil { b.Fatal(err) } } }) b.Run("IPv6UDP", func(b testing.B) { p := ipv6.NewPacketConn(c) cf := ipv6.FlagTrafficClass \| ipv6.FlagHopLimit \| ipv6.FlagSrc \| ipv6.FlagDst \| ipv6.FlagInterface \| ipv6.FlagPathMTU if err := p.SetControlMessage(cf, true); err != nil { b.Fatal(err) } cm := ipv6.ControlMessage{ TrafficClass: iana.DiffServAF11 \| iana.CongestionExperienced, HopLimit: 1, } ifi, _ := nettest.RoutedInterface("ip6", net.FlagUp\|net.FlagLoopback) if ifi != nil { cm.IfIndex = ifi.Index } for i := 0; i < b.N; i++ { if _, err := p.WriteTo(wb, &cm, dst); err != nil { b.Fatal(err) } if _, _, _, err := p.ReadFrom(rb); err != nil { b.Fatal(err) } } }) } func BenchmarkPacketConnReadWriteUnicast(b testing.B) { switch runtime.GOOS { case "fuchsia", "hurd", "js", "nacl", "plan9", "wasip1", "windows": b.Skipf("not supported on %s", runtime.GOOS) } payload := []byte("HELLO-R-U-THERE") iph := []byte{ 0x69, 0x8b, 0xee, 0xf1, 0xca, 0xfe, 0xff, 0x01, 0x20, 0x01, 0x0d, 0xb8, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x20, 0x01, 0x0d, 0xb8, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, } greh := []byte{0x00, 0x00, 0x86, 0xdd, 0x00, 0x00, 0x00, 0x00} datagram := append(greh, append(iph, payload...)...) bb := make([]byte, 128) cm := ipv6.ControlMessage{ TrafficClass: iana.DiffServAF11 \| iana.CongestionExperienced, HopLimit: 1, Src: net.IPv6loopback, } ifi, _ := nettest.RoutedInterface("ip6", net.FlagUp\|net.FlagLoopback) if ifi != nil { cm.IfIndex = ifi.Index } b.Run("UDP", func(b testing.B) { c, err := nettest.NewLocalPacketListener("udp6") if err != nil { b.Skipf("not supported on %s/%s: %v", runtime.GOOS, runtime.GOARCH, err) } defer c.Close() p := ipv6.NewPacketConn(c) dst := c.LocalAddr() cf := ipv6.FlagHopLimit \| ipv6.FlagInterface if err := p.SetControlMessage(cf, true); err != nil { b.Fatal(err) } wms := []ipv6.Message{ { Buffers: [][]byte{payload}, Addr: dst, OOB: cm.Marshal(), }, } rms := []ipv6.Message{ { Buffers: [][]byte{bb}, OOB: ipv6.NewControlMessage(cf), }, } b.Run("Net", func(b testing.B) { for i := 0; i < b.N; i++ { if _, err := c.WriteTo(payload, dst); err != nil { b.Fatal(err) } if _, _, err := c.ReadFrom(bb); err != nil { b.Fatal(err) } } }) b.Run("ToFrom", func(b testing.B) { for i := 0; i < b.N; i++ { if _, err := p.WriteTo(payload, &cm, dst); err != nil { b.Fatal(err) } if _, _, _, err := p.ReadFrom(bb); err != nil { b.Fatal(err) } } }) b.Run("Batch", func(b testing.B) { for i := 0; i < b.N; i++ { if _, err := p.WriteBatch(wms, 0); err != nil { b.Fatal(err) } if _, err := p.ReadBatch(rms, 0); err != nil { b.Fatal(err) } } }) }) b.Run("IP", func(b testing.B) { switch runtime.GOOS { case "netbsd": b.Skip("need to configure gre on netbsd") case "openbsd": b.Skip("net.inet.gre.allow=0 by default on openbsd") } c, err := net.ListenPacket(fmt.Sprintf("ip6:%d", iana.ProtocolGRE), "::1") if err != nil { b.Skipf("not supported on %s/%s: %v", runtime.GOOS, runtime.GOARCH, err) } defer c.Close() p := ipv6.NewPacketConn(c) dst := c.LocalAddr() cf := ipv6.FlagTrafficClass \| ipv6.FlagHopLimit \| ipv6.FlagSrc \| ipv6.FlagDst \| ipv6.FlagInterface \| ipv6.FlagPathMTU if err := p.SetControlMessage(cf, true); err != nil { b.Fatal(err) } wms := []ipv6.Message{ { Buffers: [][]byte{datagram}, Addr: dst, OOB: cm.Marshal(), }, } rms := []ipv6.Message{ { Buffers: [][]byte{bb}, OOB: ipv6.NewControlMessage(cf), }, } b.Run("Net", func(b testing.B) { for i := 0; i < b.N; i++ { if _, err := c.WriteTo(datagram, dst); err != nil { b.Fatal(err) } if _, _, err := c.ReadFrom(bb); err != nil { b.Fatal(err) } } }) b.Run("ToFrom", func(b testing.B) { for i := 0; i < b.N; i++ { if _, err := p.WriteTo(datagram, &cm, dst); err != nil { b.Fatal(err) } if _, _, _, err := p.ReadFrom(bb); err != nil { b.Fatal(err) } } }) b.Run("Batch", func(b testing.B) { for i := 0; i < b.N; i++ { if _, err := p.WriteBatch(wms, 0); err != nil { b.Fatal(err) } if _, err := p.ReadBatch(rms, 0); err != nil { b.Fatal(err) } } }) }) } func TestPacketConnConcurrentReadWriteUnicastUDP(t testing.T) { switch runtime.GOOS { case "fuchsia", "hurd", "js", "nacl", "plan9", "wasip1", "windows": t.Skipf("not supported on %s", runtime.GOOS) } ifi, err := nettest.RoutedInterface("ip6", net.FlagUp\|net.FlagLoopback) if err != nil { t.Skip("ipv6 is not enabled for loopback interface") } c, err := nettest.NewLocalPacketListener("udp6") if err != nil { t.Fatal(err) } defer c.Close() p := ipv6.NewPacketConn(c) defer p.Close() dst := c.LocalAddr() cf := ipv6.FlagTrafficClass \| ipv6.FlagHopLimit \| ipv6.FlagSrc \| ipv6.FlagDst \| ipv6.FlagInterface \| ipv6.FlagPathMTU wb := []byte("HELLO-R-U-THERE") if err := p.SetControlMessage(cf, true); err != nil { // probe before test if protocolNotSupported(err) { t.Skipf("not supported on %s", runtime.GOOS) } t.Fatal(err) } var firstError sync.Once fatalf := func(format string, args ...interface{}) { // On the first error, close the PacketConn to unblock the remaining // goroutines. Suppress any further errors, which may occur simply due to // closing the PacketConn. first := false firstError.Do(func() { first = true p.Close() }) if first { t.Helper() t.Errorf(format, args...) } runtime.Goexit() } var wg sync.WaitGroup reader := func() { defer wg.Done() rb := make([]byte, 128) if n, cm, _, err := p.ReadFrom(rb); err != nil { fatalf("%v", err) } else if !bytes.Equal(rb[:n], wb) { fatalf("got %v; want %v", rb[:n], wb) } else { s := cm.String() if strings.Contains(s, ",") { t.Errorf("should be space-separated values: %s", s) } } } writer := func(toggle bool) { defer wg.Done() cm := ipv6.ControlMessage{ TrafficClass: iana.DiffServAF11 \| iana.CongestionExperienced, Src: net.IPv6loopback, } if ifi != nil { cm.IfIndex = ifi.Index } if err := p.SetControlMessage(cf, toggle); err != nil { fatalf("%v", err) } backoff := time.Millisecond for { n, err := p.WriteTo(wb, &cm, dst) if err != nil { if n == 0 && isENOBUFS(err) { time.Sleep(backoff) backoff = 2 continue } fatalf("%v", err) } if n != len(wb) { fatalf("got %d; want %d", n, len(wb)) } break } } const N = 10 wg.Add(N) for i := 0; i < N; i++ { go reader() } wg.Add(2 * N) for i := 0; i < 2N; i++ { go writer(i%2 != 0) } wg.Add(N) for i := 0; i < N; i++ { go reader() } wg.Wait() } func TestPacketConnConcurrentReadWriteUnicast(t testing.T) { switch runtime.GOOS { case "fuchsia", "hurd", "js", "nacl", "plan9", "wasip1", "windows": t.Skipf("not supported on %s", runtime.GOOS) } payload := []byte("HELLO-R-U-THERE") iph := []byte{ 0x69, 0x8b, 0xee, 0xf1, 0xca, 0xfe, 0xff, 0x01, 0x20, 0x01, 0x0d, 0xb8, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x20, 0x01, 0x0d, 0xb8, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, } greh := []byte{0x00, 0x00, 0x86, 0xdd, 0x00, 0x00, 0x00, 0x00} datagram := append(greh, append(iph, payload...)...) t.Run("UDP", func(t testing.T) { c, err := nettest.NewLocalPacketListener("udp6") if err != nil { t.Skipf("not supported on %s/%s: %v", runtime.GOOS, runtime.GOARCH, err) } defer c.Close() p := ipv6.NewPacketConn(c) t.Run("ToFrom", func(t testing.T) { testPacketConnConcurrentReadWriteUnicast(t, p, payload, c.LocalAddr(), false) }) t.Run("Batch", func(t testing.T) { testPacketConnConcurrentReadWriteUnicast(t, p, payload, c.LocalAddr(), true) }) }) t.Run("IP", func(t testing.T) { switch runtime.GOOS { case "netbsd": t.Skip("need to configure gre on netbsd") case "openbsd": t.Skip("net.inet.gre.allow=0 by default on openbsd") } c, err := net.ListenPacket(fmt.Sprintf("ip6:%d", iana.ProtocolGRE), "::1") if err != nil { t.Skipf("not supported on %s/%s: %v", runtime.GOOS, runtime.GOARCH, err) } defer c.Close() p := ipv6.NewPacketConn(c) t.Run("ToFrom", func(t testing.T) { testPacketConnConcurrentReadWriteUnicast(t, p, datagram, c.LocalAddr(), false) }) t.Run("Batch", func(t testing.T) { testPacketConnConcurrentReadWriteUnicast(t, p, datagram, c.LocalAddr(), true) }) }) } func testPacketConnConcurrentReadWriteUnicast(t testing.T, p ipv6.PacketConn, data []byte, dst net.Addr, batch bool) { ifi, _ := nettest.RoutedInterface("ip6", net.FlagUp\|net.FlagLoopback) cf := ipv6.FlagTrafficClass \| ipv6.FlagHopLimit \| ipv6.FlagSrc \| ipv6.FlagDst \| ipv6.FlagInterface \| ipv6.FlagPathMTU if err := p.SetControlMessage(cf, true); err != nil { // probe before test if protocolNotSupported(err) { t.Skipf("not supported on %s", runtime.GOOS) } t.Fatal(err) } var firstError sync.Once fatalf := func(format string, args ...interface{}) { // On the first error, close the PacketConn to unblock the remaining // goroutines. Suppress any further errors, which may occur simply due to // closing the PacketConn. first := false firstError.Do(func() { first = true p.Close() }) if first { t.Helper() t.Errorf(format, args...) } runtime.Goexit() } var wg sync.WaitGroup reader := func() { defer wg.Done() b := make([]byte, 128) n, cm, _, err := p.ReadFrom(b) if err != nil { fatalf("%v", err) } if !bytes.Equal(b[:n], data) { fatalf("got %#v; want %#v", b[:n], data) } s := cm.String() if strings.Contains(s, ",") { fatalf("should be space-separated values: %s", s) } } batchReader := func() { defer wg.Done() ms := []ipv6.Message{ { Buffers: [][]byte{make([]byte, 128)}, OOB: ipv6.NewControlMessage(cf), }, } n, err := p.ReadBatch(ms, 0) if err != nil { fatalf("%v", err) } if n != len(ms) { fatalf("got %d; want %d", n, len(ms)) } var cm ipv6.ControlMessage if err := cm.Parse(ms[0].OOB[:ms[0].NN]); err != nil { fatalf("%v", err) } b := ms[0].Buffers[0][:ms[0].N] if !bytes.Equal(b, data) { fatalf("got %#v; want %#v", b, data) } s := cm.String() if strings.Contains(s, ",") { fatalf("should be space-separated values: %s", s) } } writer := func(toggle bool) { defer wg.Done() cm := ipv6.ControlMessage{ TrafficClass: iana.DiffServAF11 \| iana.CongestionExperienced, HopLimit: 1, Src: net.IPv6loopback, } if ifi != nil { cm.IfIndex = ifi.Index } if err := p.SetControlMessage(cf, toggle); err != nil { fatalf("%v", err) } backoff := time.Millisecond for { n, err := p.WriteTo(data, &cm, dst) if err != nil { if n == 0 && isENOBUFS(err) { time.Sleep(backoff) backoff = 2 continue } fatalf("%v", err) } if n != len(data) { fatalf("got %d; want %d", n, len(data)) } break } } batchWriter := func(toggle bool) { defer wg.Done() cm := ipv6.ControlMessage{ TrafficClass: iana.DiffServAF11 \| iana.CongestionExperienced, HopLimit: 1, Src: net.IPv6loopback, } if ifi != nil { cm.IfIndex = ifi.Index } if err := p.SetControlMessage(cf, toggle); err != nil { fatalf("%v", err) } ms := []ipv6.Message{ { Buffers: [][]byte{data}, OOB: cm.Marshal(), Addr: dst, }, } backoff := time.Millisecond for { n, err := p.WriteBatch(ms, 0) if err != nil { if n == 0 && isENOBUFS(err) { time.Sleep(backoff) backoff = 2 continue } fatalf("%v", err) } if n != len(ms) { fatalf("got %d; want %d", n, len(ms)) } if ms[0].N != len(data) { fatalf("got %d; want %d", ms[0].N, len(data)) } break } } const N = 10 wg.Add(N) for i := 0; i < N; i++ { if batch { go batchReader() } else { go reader() } } wg.Add(2 * N) for i := 0; i < 2*N; i++ { if batch { go batchWriter(i%2 != 0) } else { go writer(i%2 != 0) } } wg.Add(N) for i := 0; i < N; i++ { if batch { go batchReader() } else { go reader() } } wg.Wait() }	13.15 KB	2025-05-25 12:27
📄 sockopt.go // Copyright 2014 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 "golang.org/x/net/internal/socket" // Sticky socket options const ( ssoTrafficClass = iota // header field for unicast packet, RFC 3542 ssoHopLimit // header field for unicast packet, RFC 3493 ssoMulticastInterface // outbound interface for multicast packet, RFC 3493 ssoMulticastHopLimit // header field for multicast packet, RFC 3493 ssoMulticastLoopback // loopback for multicast packet, RFC 3493 ssoReceiveTrafficClass // header field on received packet, RFC 3542 ssoReceiveHopLimit // header field on received packet, RFC 2292 or 3542 ssoReceivePacketInfo // incbound or outbound packet path, RFC 2292 or 3542 ssoReceivePathMTU // path mtu, RFC 3542 ssoPathMTU // path mtu, RFC 3542 ssoChecksum // packet checksum, RFC 2292 or 3542 ssoICMPFilter // icmp filter, RFC 2292 or 3542 ssoJoinGroup // any-source multicast, RFC 3493 ssoLeaveGroup // any-source multicast, RFC 3493 ssoJoinSourceGroup // source-specific multicast ssoLeaveSourceGroup // source-specific multicast ssoBlockSourceGroup // any-source or source-specific multicast ssoUnblockSourceGroup // any-source or source-specific multicast ssoAttachFilter // attach BPF for filtering inbound traffic ) // Sticky socket option value types const ( ssoTypeIPMreq = iota + 1 ssoTypeGroupReq ssoTypeGroupSourceReq ) // A sockOpt represents a binding for sticky socket option. type sockOpt struct { socket.Option typ int // hint for option value type; optional }	1.81 KB	2025-05-25 12:27
📄 sockopt_posix.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. //go:build aix \|\| darwin \|\| dragonfly \|\| freebsd \|\| linux \|\| netbsd \|\| openbsd \|\| solaris \|\| windows \|\| zos package ipv6 import ( "net" "runtime" "unsafe" "golang.org/x/net/bpf" "golang.org/x/net/internal/socket" ) func (so sockOpt) getMulticastInterface(c socket.Conn) (net.Interface, error) { n, err := so.GetInt(c) if err != nil { return nil, err } return net.InterfaceByIndex(n) } func (so sockOpt) setMulticastInterface(c socket.Conn, ifi net.Interface) error { var n int if ifi != nil { n = ifi.Index } return so.SetInt(c, n) } func (so sockOpt) getICMPFilter(c socket.Conn) (ICMPFilter, error) { b := make([]byte, so.Len) n, err := so.Get(c, b) if err != nil { return nil, err } if n != sizeofICMPv6Filter { return nil, errNotImplemented } return (ICMPFilter)(unsafe.Pointer(&b[0])), nil } func (so sockOpt) setICMPFilter(c socket.Conn, f ICMPFilter) error { b := ([sizeofICMPv6Filter]byte)(unsafe.Pointer(f))[:sizeofICMPv6Filter] return so.Set(c, b) } func (so sockOpt) getMTUInfo(c socket.Conn) (net.Interface, int, error) { b := make([]byte, so.Len) n, err := so.Get(c, b) if err != nil { return nil, 0, err } if n != sizeofIPv6Mtuinfo { return nil, 0, errNotImplemented } mi := (ipv6Mtuinfo)(unsafe.Pointer(&b[0])) if mi.Addr.Scope_id == 0 \|\| runtime.GOOS == "aix" { // AIX kernel might return a wrong address. return nil, int(mi.Mtu), nil } ifi, err := net.InterfaceByIndex(int(mi.Addr.Scope_id)) if err != nil { return nil, 0, err } return ifi, int(mi.Mtu), nil } func (so sockOpt) setGroup(c socket.Conn, ifi net.Interface, grp net.IP) error { switch so.typ { case ssoTypeIPMreq: return so.setIPMreq(c, ifi, grp) case ssoTypeGroupReq: return so.setGroupReq(c, ifi, grp) default: return errNotImplemented } } func (so sockOpt) setSourceGroup(c socket.Conn, ifi net.Interface, grp, src net.IP) error { return so.setGroupSourceReq(c, ifi, grp, src) } func (so sockOpt) setBPF(c socket.Conn, f []bpf.RawInstruction) error { return so.setAttachFilter(c, f) }	2.18 KB	2025-05-25 12:27
📄 sockopt_stub.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. //go:build !aix && !darwin && !dragonfly && !freebsd && !linux && !netbsd && !openbsd && !solaris && !windows && !zos package ipv6 import ( "net" "golang.org/x/net/bpf" "golang.org/x/net/internal/socket" ) func (so sockOpt) getMulticastInterface(c socket.Conn) (net.Interface, error) { return nil, errNotImplemented } func (so sockOpt) setMulticastInterface(c socket.Conn, ifi net.Interface) error { return errNotImplemented } func (so sockOpt) getICMPFilter(c socket.Conn) (ICMPFilter, error) { return nil, errNotImplemented } func (so sockOpt) setICMPFilter(c socket.Conn, f ICMPFilter) error { return errNotImplemented } func (so sockOpt) getMTUInfo(c socket.Conn) (net.Interface, int, error) { return nil, 0, errNotImplemented } func (so sockOpt) setGroup(c socket.Conn, ifi net.Interface, grp net.IP) error { return errNotImplemented } func (so sockOpt) setSourceGroup(c socket.Conn, ifi net.Interface, grp, src net.IP) error { return errNotImplemented } func (so sockOpt) setBPF(c *socket.Conn, f []bpf.RawInstruction) error { return errNotImplemented }	1.23 KB	2025-05-25 12:27
📄 sockopt_test.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_test import ( "errors" "fmt" "net" "runtime" "testing" "golang.org/x/net/internal/iana" "golang.org/x/net/ipv6" "golang.org/x/net/nettest" ) func TestConnInitiatorPathMTU(t testing.T) { switch runtime.GOOS { case "fuchsia", "hurd", "js", "nacl", "plan9", "windows", "wasip1", "zos": t.Skipf("not supported on %s", runtime.GOOS) } if _, err := nettest.RoutedInterface("ip6", net.FlagUp\|net.FlagLoopback); err != nil { t.Skip("ipv6 is not enabled for loopback interface") } ln, err := net.Listen("tcp6", "[::1]:0") if err != nil { t.Fatal(err) } defer ln.Close() done := make(chan bool) go acceptor(t, ln, done) c, err := net.Dial("tcp6", ln.Addr().String()) if err != nil { t.Fatal(err) } defer c.Close() if pmtu, err := ipv6.NewConn(c).PathMTU(); err != nil { t.Fatal(err) } else { t.Logf("path mtu for %v: %v", c.RemoteAddr(), pmtu) } <-done } func TestConnResponderPathMTU(t testing.T) { switch runtime.GOOS { case "fuchsia", "hurd", "js", "nacl", "plan9", "windows", "wasip1", "zos": t.Skipf("not supported on %s", runtime.GOOS) } if _, err := nettest.RoutedInterface("ip6", net.FlagUp\|net.FlagLoopback); err != nil { t.Skip("ipv6 is not enabled for loopback interface") } ln, err := net.Listen("tcp6", "[::1]:0") if err != nil { t.Fatal(err) } defer ln.Close() done := make(chan bool) go connector(t, "tcp6", ln.Addr().String(), done) c, err := ln.Accept() if err != nil { t.Fatal(err) } defer c.Close() if pmtu, err := ipv6.NewConn(c).PathMTU(); err != nil { t.Fatal(err) } else { t.Logf("path mtu for %v: %v", c.RemoteAddr(), pmtu) } <-done } func TestPacketConnChecksum(t *testing.T) { if !nettest.SupportsIPv6() { t.Skip("ipv6 is not supported") } if !nettest.SupportsRawSocket() { t.Skipf("not supported on %s/%s", runtime.GOOS, runtime.GOARCH) } c, err := net.ListenPacket(fmt.Sprintf("ip6:%d", iana.ProtocolOSPFIGP), "::") // OSPF for IPv6 if err != nil { t.Fatal(err) } defer c.Close() p := ipv6.NewPacketConn(c) offset := 12 // see RFC 5340 for _, toggle := range []bool{false, true} { if err := p.SetChecksum(toggle, offset); errors.Is(err, ipv6.ErrNotImplemented) { t.Skipf("setting checksum not supported: %v", err) } else if err != nil { if toggle { t.Fatalf("ipv6.PacketConn.SetChecksum(%v, %v) failed: %v", toggle, offset, err) } else { // Some platforms never allow to disable the kernel // checksum processing. t.Logf("ipv6.PacketConn.SetChecksum(%v, %v) failed: %v", toggle, offset, err) } } if on, offset, err := p.Checksum(); err != nil { t.Fatal(err) } else { t.Logf("kernel checksum processing enabled=%v, offset=%v", on, offset) } } }	2.82 KB	2025-05-25 12:27
📄 sys_aix.go // Copyright 2019 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. // Added for go1.11 compatibility //go:build aix package ipv6 import ( "net" "syscall" "unsafe" "golang.org/x/net/internal/iana" "golang.org/x/net/internal/socket" "golang.org/x/sys/unix" ) var ( ctlOpts = [ctlMax]ctlOpt{ ctlTrafficClass: {unix.IPV6_TCLASS, 4, marshalTrafficClass, parseTrafficClass}, ctlHopLimit: {unix.IPV6_HOPLIMIT, 4, marshalHopLimit, parseHopLimit}, ctlPacketInfo: {unix.IPV6_PKTINFO, sizeofInet6Pktinfo, marshalPacketInfo, parsePacketInfo}, ctlNextHop: {unix.IPV6_NEXTHOP, sizeofSockaddrInet6, marshalNextHop, parseNextHop}, ctlPathMTU: {unix.IPV6_PATHMTU, sizeofIPv6Mtuinfo, marshalPathMTU, parsePathMTU}, } sockOpts = map[int]sockOpt{ ssoTrafficClass: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_TCLASS, Len: 4}}, ssoHopLimit: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_UNICAST_HOPS, Len: 4}}, ssoMulticastInterface: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_MULTICAST_IF, Len: 4}}, ssoMulticastHopLimit: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_MULTICAST_HOPS, Len: 4}}, ssoMulticastLoopback: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_MULTICAST_LOOP, Len: 4}}, ssoReceiveTrafficClass: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_RECVTCLASS, Len: 4}}, ssoReceiveHopLimit: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_RECVHOPLIMIT, Len: 4}}, ssoReceivePacketInfo: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_RECVPKTINFO, Len: 4}}, ssoReceivePathMTU: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_RECVPATHMTU, Len: 4}}, ssoPathMTU: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_PATHMTU, Len: sizeofIPv6Mtuinfo}}, ssoChecksum: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_CHECKSUM, Len: 4}}, ssoICMPFilter: {Option: socket.Option{Level: iana.ProtocolIPv6ICMP, Name: unix.ICMP6_FILTER, Len: sizeofICMPv6Filter}}, ssoJoinGroup: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_JOIN_GROUP, Len: sizeofIPv6Mreq}, typ: ssoTypeIPMreq}, ssoLeaveGroup: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_LEAVE_GROUP, Len: sizeofIPv6Mreq}, typ: ssoTypeIPMreq}, } ) func (sa sockaddrInet6) setSockaddr(ip net.IP, i int) { sa.Len = sizeofSockaddrInet6 sa.Family = syscall.AF_INET6 copy(sa.Addr[:], ip) sa.Scope_id = uint32(i) } func (pi inet6Pktinfo) setIfindex(i int) { pi.Ifindex = int32(i) } func (mreq ipv6Mreq) setIfindex(i int) { mreq.Interface = uint32(i) } func (gr groupReq) setGroup(grp net.IP) { sa := (sockaddrInet6)(unsafe.Pointer(uintptr(unsafe.Pointer(gr)) + 4)) sa.Len = sizeofSockaddrInet6 sa.Family = syscall.AF_INET6 copy(sa.Addr[:], grp) } func (gsr groupSourceReq) setSourceGroup(grp, src net.IP) { sa := (sockaddrInet6)(unsafe.Pointer(uintptr(unsafe.Pointer(gsr)) + 4)) sa.Len = sizeofSockaddrInet6 sa.Family = syscall.AF_INET6 copy(sa.Addr[:], grp) sa = (*sockaddrInet6)(unsafe.Pointer(uintptr(unsafe.Pointer(gsr)) + 132)) sa.Len = sizeofSockaddrInet6 sa.Family = syscall.AF_INET6 copy(sa.Addr[:], src) }	3.37 KB	2025-05-25 12:27
📄 sys_asmreq.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. //go:build aix \|\| darwin \|\| dragonfly \|\| freebsd \|\| linux \|\| netbsd \|\| openbsd \|\| solaris \|\| windows package ipv6 import ( "net" "unsafe" "golang.org/x/net/internal/socket" ) func (so sockOpt) setIPMreq(c socket.Conn, ifi net.Interface, grp net.IP) error { var mreq ipv6Mreq copy(mreq.Multiaddr[:], grp) if ifi != nil { mreq.setIfindex(ifi.Index) } b := ([sizeofIPv6Mreq]byte)(unsafe.Pointer(&mreq))[:sizeofIPv6Mreq] return so.Set(c, b) }	618 B	2025-05-25 12:27
📄 sys_asmreq_stub.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. //go:build !aix && !darwin && !dragonfly && !freebsd && !linux && !netbsd && !openbsd && !solaris && !windows package ipv6 import ( "net" "golang.org/x/net/internal/socket" ) func (so sockOpt) setIPMreq(c socket.Conn, ifi *net.Interface, grp net.IP) error { return errNotImplemented }	454 B	2025-05-25 12:27
📄 sys_bpf.go // Copyright 2017 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. //go:build linux package ipv6 import ( "unsafe" "golang.org/x/net/bpf" "golang.org/x/net/internal/socket" "golang.org/x/sys/unix" ) func (so sockOpt) setAttachFilter(c socket.Conn, f []bpf.RawInstruction) error { prog := unix.SockFprog{ Len: uint16(len(f)), Filter: (unix.SockFilter)(unsafe.Pointer(&f[0])), } b := ([unix.SizeofSockFprog]byte)(unsafe.Pointer(&prog))[:unix.SizeofSockFprog] return so.Set(c, b) }	595 B	2025-05-25 12:27
📄 sys_bpf_stub.go // Copyright 2017 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. //go:build !linux package ipv6 import ( "golang.org/x/net/bpf" "golang.org/x/net/internal/socket" ) func (so sockOpt) setAttachFilter(c socket.Conn, f []bpf.RawInstruction) error { return errNotImplemented }	376 B	2025-05-25 12:27
📄 sys_bsd.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. //go:build dragonfly \|\| netbsd \|\| openbsd package ipv6 import ( "net" "syscall" "golang.org/x/net/internal/iana" "golang.org/x/net/internal/socket" "golang.org/x/sys/unix" ) var ( ctlOpts = [ctlMax]ctlOpt{ ctlTrafficClass: {unix.IPV6_TCLASS, 4, marshalTrafficClass, parseTrafficClass}, ctlHopLimit: {unix.IPV6_HOPLIMIT, 4, marshalHopLimit, parseHopLimit}, ctlPacketInfo: {unix.IPV6_PKTINFO, sizeofInet6Pktinfo, marshalPacketInfo, parsePacketInfo}, ctlNextHop: {unix.IPV6_NEXTHOP, sizeofSockaddrInet6, marshalNextHop, parseNextHop}, ctlPathMTU: {unix.IPV6_PATHMTU, sizeofIPv6Mtuinfo, marshalPathMTU, parsePathMTU}, } sockOpts = map[int]sockOpt{ ssoTrafficClass: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_TCLASS, Len: 4}}, ssoHopLimit: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_UNICAST_HOPS, Len: 4}}, ssoMulticastInterface: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_MULTICAST_IF, Len: 4}}, ssoMulticastHopLimit: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_MULTICAST_HOPS, Len: 4}}, ssoMulticastLoopback: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_MULTICAST_LOOP, Len: 4}}, ssoReceiveTrafficClass: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_RECVTCLASS, Len: 4}}, ssoReceiveHopLimit: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_RECVHOPLIMIT, Len: 4}}, ssoReceivePacketInfo: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_RECVPKTINFO, Len: 4}}, ssoReceivePathMTU: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_RECVPATHMTU, Len: 4}}, ssoPathMTU: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_PATHMTU, Len: sizeofIPv6Mtuinfo}}, ssoChecksum: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_CHECKSUM, Len: 4}}, ssoICMPFilter: {Option: socket.Option{Level: iana.ProtocolIPv6ICMP, Name: unix.ICMP6_FILTER, Len: sizeofICMPv6Filter}}, ssoJoinGroup: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_JOIN_GROUP, Len: sizeofIPv6Mreq}, typ: ssoTypeIPMreq}, ssoLeaveGroup: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_LEAVE_GROUP, Len: sizeofIPv6Mreq}, typ: ssoTypeIPMreq}, } ) func (sa sockaddrInet6) setSockaddr(ip net.IP, i int) { sa.Len = sizeofSockaddrInet6 sa.Family = syscall.AF_INET6 copy(sa.Addr[:], ip) sa.Scope_id = uint32(i) } func (pi inet6Pktinfo) setIfindex(i int) { pi.Ifindex = uint32(i) } func (mreq ipv6Mreq) setIfindex(i int) { mreq.Interface = uint32(i) }	2.78 KB	2025-05-25 12:27
📄 sys_darwin.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" "syscall" "unsafe" "golang.org/x/net/internal/iana" "golang.org/x/net/internal/socket" "golang.org/x/sys/unix" ) var ( ctlOpts = [ctlMax]ctlOpt{ ctlTrafficClass: {unix.IPV6_TCLASS, 4, marshalTrafficClass, parseTrafficClass}, ctlHopLimit: {unix.IPV6_HOPLIMIT, 4, marshalHopLimit, parseHopLimit}, ctlPacketInfo: {unix.IPV6_PKTINFO, sizeofInet6Pktinfo, marshalPacketInfo, parsePacketInfo}, ctlNextHop: {unix.IPV6_NEXTHOP, sizeofSockaddrInet6, marshalNextHop, parseNextHop}, ctlPathMTU: {unix.IPV6_PATHMTU, sizeofIPv6Mtuinfo, marshalPathMTU, parsePathMTU}, } sockOpts = map[int]sockOpt{ ssoHopLimit: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_UNICAST_HOPS, Len: 4}}, ssoMulticastInterface: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_MULTICAST_IF, Len: 4}}, ssoMulticastHopLimit: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_MULTICAST_HOPS, Len: 4}}, ssoMulticastLoopback: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_MULTICAST_LOOP, Len: 4}}, ssoTrafficClass: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_TCLASS, Len: 4}}, ssoReceiveTrafficClass: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_RECVTCLASS, Len: 4}}, ssoReceiveHopLimit: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_RECVHOPLIMIT, Len: 4}}, ssoReceivePacketInfo: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_RECVPKTINFO, Len: 4}}, ssoReceivePathMTU: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_RECVPATHMTU, Len: 4}}, ssoPathMTU: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_PATHMTU, Len: sizeofIPv6Mtuinfo}}, ssoChecksum: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_CHECKSUM, Len: 4}}, ssoICMPFilter: {Option: socket.Option{Level: iana.ProtocolIPv6ICMP, Name: unix.ICMP6_FILTER, Len: sizeofICMPv6Filter}}, ssoJoinGroup: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.MCAST_JOIN_GROUP, Len: sizeofGroupReq}, typ: ssoTypeGroupReq}, ssoLeaveGroup: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.MCAST_LEAVE_GROUP, Len: sizeofGroupReq}, typ: ssoTypeGroupReq}, ssoJoinSourceGroup: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.MCAST_JOIN_SOURCE_GROUP, Len: sizeofGroupSourceReq}, typ: ssoTypeGroupSourceReq}, ssoLeaveSourceGroup: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.MCAST_LEAVE_SOURCE_GROUP, Len: sizeofGroupSourceReq}, typ: ssoTypeGroupSourceReq}, ssoBlockSourceGroup: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.MCAST_BLOCK_SOURCE, Len: sizeofGroupSourceReq}, typ: ssoTypeGroupSourceReq}, ssoUnblockSourceGroup: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.MCAST_UNBLOCK_SOURCE, Len: sizeofGroupSourceReq}, typ: ssoTypeGroupSourceReq}, } ) func (sa sockaddrInet6) setSockaddr(ip net.IP, i int) { sa.Len = sizeofSockaddrInet6 sa.Family = syscall.AF_INET6 copy(sa.Addr[:], ip) sa.Scope_id = uint32(i) } func (pi inet6Pktinfo) setIfindex(i int) { pi.Ifindex = uint32(i) } func (mreq ipv6Mreq) setIfindex(i int) { mreq.Interface = uint32(i) } func (gr groupReq) setGroup(grp net.IP) { sa := (sockaddrInet6)(unsafe.Pointer(uintptr(unsafe.Pointer(gr)) + 4)) sa.Len = sizeofSockaddrInet6 sa.Family = syscall.AF_INET6 copy(sa.Addr[:], grp) } func (gsr groupSourceReq) setSourceGroup(grp, src net.IP) { sa := (sockaddrInet6)(unsafe.Pointer(uintptr(unsafe.Pointer(gsr)) + 4)) sa.Len = sizeofSockaddrInet6 sa.Family = syscall.AF_INET6 copy(sa.Addr[:], grp) sa = (*sockaddrInet6)(unsafe.Pointer(uintptr(unsafe.Pointer(gsr)) + 132)) sa.Len = sizeofSockaddrInet6 sa.Family = syscall.AF_INET6 copy(sa.Addr[:], src) }	3.97 KB	2025-05-25 12:27
📄 sys_freebsd.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" "runtime" "strings" "syscall" "unsafe" "golang.org/x/net/internal/iana" "golang.org/x/net/internal/socket" "golang.org/x/sys/unix" ) var ( ctlOpts = [ctlMax]ctlOpt{ ctlTrafficClass: {unix.IPV6_TCLASS, 4, marshalTrafficClass, parseTrafficClass}, ctlHopLimit: {unix.IPV6_HOPLIMIT, 4, marshalHopLimit, parseHopLimit}, ctlPacketInfo: {unix.IPV6_PKTINFO, sizeofInet6Pktinfo, marshalPacketInfo, parsePacketInfo}, ctlNextHop: {unix.IPV6_NEXTHOP, sizeofSockaddrInet6, marshalNextHop, parseNextHop}, ctlPathMTU: {unix.IPV6_PATHMTU, sizeofIPv6Mtuinfo, marshalPathMTU, parsePathMTU}, } sockOpts = map[int]sockOpt{ ssoTrafficClass: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_TCLASS, Len: 4}}, ssoHopLimit: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_UNICAST_HOPS, Len: 4}}, ssoMulticastInterface: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_MULTICAST_IF, Len: 4}}, ssoMulticastHopLimit: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_MULTICAST_HOPS, Len: 4}}, ssoMulticastLoopback: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_MULTICAST_LOOP, Len: 4}}, ssoReceiveTrafficClass: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_RECVTCLASS, Len: 4}}, ssoReceiveHopLimit: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_RECVHOPLIMIT, Len: 4}}, ssoReceivePacketInfo: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_RECVPKTINFO, Len: 4}}, ssoReceivePathMTU: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_RECVPATHMTU, Len: 4}}, ssoPathMTU: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_PATHMTU, Len: sizeofIPv6Mtuinfo}}, ssoChecksum: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_CHECKSUM, Len: 4}}, ssoICMPFilter: {Option: socket.Option{Level: iana.ProtocolIPv6ICMP, Name: unix.ICMP6_FILTER, Len: sizeofICMPv6Filter}}, ssoJoinGroup: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.MCAST_JOIN_GROUP, Len: sizeofGroupReq}, typ: ssoTypeGroupReq}, ssoLeaveGroup: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.MCAST_LEAVE_GROUP, Len: sizeofGroupReq}, typ: ssoTypeGroupReq}, ssoJoinSourceGroup: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.MCAST_JOIN_SOURCE_GROUP, Len: sizeofGroupSourceReq}, typ: ssoTypeGroupSourceReq}, ssoLeaveSourceGroup: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.MCAST_LEAVE_SOURCE_GROUP, Len: sizeofGroupSourceReq}, typ: ssoTypeGroupSourceReq}, ssoBlockSourceGroup: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.MCAST_BLOCK_SOURCE, Len: sizeofGroupSourceReq}, typ: ssoTypeGroupSourceReq}, ssoUnblockSourceGroup: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.MCAST_UNBLOCK_SOURCE, Len: sizeofGroupSourceReq}, typ: ssoTypeGroupSourceReq}, } ) func init() { if runtime.GOOS == "freebsd" && runtime.GOARCH == "386" { archs, _ := syscall.Sysctl("kern.supported_archs") for _, s := range strings.Fields(archs) { if s == "amd64" { compatFreeBSD32 = true break } } } } func (sa sockaddrInet6) setSockaddr(ip net.IP, i int) { sa.Len = sizeofSockaddrInet6 sa.Family = syscall.AF_INET6 copy(sa.Addr[:], ip) sa.Scope_id = uint32(i) } func (pi inet6Pktinfo) setIfindex(i int) { pi.Ifindex = uint32(i) } func (mreq ipv6Mreq) setIfindex(i int) { mreq.Interface = uint32(i) } func (gr groupReq) setGroup(grp net.IP) { sa := (sockaddrInet6)(unsafe.Pointer(&gr.Group)) sa.Len = sizeofSockaddrInet6 sa.Family = syscall.AF_INET6 copy(sa.Addr[:], grp) } func (gsr groupSourceReq) setSourceGroup(grp, src net.IP) { sa := (sockaddrInet6)(unsafe.Pointer(&gsr.Group)) sa.Len = sizeofSockaddrInet6 sa.Family = syscall.AF_INET6 copy(sa.Addr[:], grp) sa = (sockaddrInet6)(unsafe.Pointer(&gsr.Source)) sa.Len = sizeofSockaddrInet6 sa.Family = syscall.AF_INET6 copy(sa.Addr[:], src) }	4.17 KB	2025-05-25 12:27
📄 sys_linux.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" "syscall" "unsafe" "golang.org/x/net/internal/iana" "golang.org/x/net/internal/socket" "golang.org/x/sys/unix" ) var ( ctlOpts = [ctlMax]ctlOpt{ ctlTrafficClass: {unix.IPV6_TCLASS, 4, marshalTrafficClass, parseTrafficClass}, ctlHopLimit: {unix.IPV6_HOPLIMIT, 4, marshalHopLimit, parseHopLimit}, ctlPacketInfo: {unix.IPV6_PKTINFO, sizeofInet6Pktinfo, marshalPacketInfo, parsePacketInfo}, ctlPathMTU: {unix.IPV6_PATHMTU, sizeofIPv6Mtuinfo, marshalPathMTU, parsePathMTU}, } sockOpts = map[int]sockOpt{ ssoTrafficClass: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_TCLASS, Len: 4}}, ssoHopLimit: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_UNICAST_HOPS, Len: 4}}, ssoMulticastInterface: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_MULTICAST_IF, Len: 4}}, ssoMulticastHopLimit: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_MULTICAST_HOPS, Len: 4}}, ssoMulticastLoopback: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_MULTICAST_LOOP, Len: 4}}, ssoReceiveTrafficClass: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_RECVTCLASS, Len: 4}}, ssoReceiveHopLimit: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_RECVHOPLIMIT, Len: 4}}, ssoReceivePacketInfo: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_RECVPKTINFO, Len: 4}}, ssoReceivePathMTU: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_RECVPATHMTU, Len: 4}}, ssoPathMTU: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_PATHMTU, Len: sizeofIPv6Mtuinfo}}, ssoChecksum: {Option: socket.Option{Level: iana.ProtocolReserved, Name: unix.IPV6_CHECKSUM, Len: 4}}, ssoICMPFilter: {Option: socket.Option{Level: iana.ProtocolIPv6ICMP, Name: unix.ICMPV6_FILTER, Len: sizeofICMPv6Filter}}, ssoJoinGroup: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.MCAST_JOIN_GROUP, Len: sizeofGroupReq}, typ: ssoTypeGroupReq}, ssoLeaveGroup: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.MCAST_LEAVE_GROUP, Len: sizeofGroupReq}, typ: ssoTypeGroupReq}, ssoJoinSourceGroup: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.MCAST_JOIN_SOURCE_GROUP, Len: sizeofGroupSourceReq}, typ: ssoTypeGroupSourceReq}, ssoLeaveSourceGroup: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.MCAST_LEAVE_SOURCE_GROUP, Len: sizeofGroupSourceReq}, typ: ssoTypeGroupSourceReq}, ssoBlockSourceGroup: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.MCAST_BLOCK_SOURCE, Len: sizeofGroupSourceReq}, typ: ssoTypeGroupSourceReq}, ssoUnblockSourceGroup: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.MCAST_UNBLOCK_SOURCE, Len: sizeofGroupSourceReq}, typ: ssoTypeGroupSourceReq}, ssoAttachFilter: {Option: socket.Option{Level: unix.SOL_SOCKET, Name: unix.SO_ATTACH_FILTER, Len: unix.SizeofSockFprog}}, } ) func (sa sockaddrInet6) setSockaddr(ip net.IP, i int) { sa.Family = syscall.AF_INET6 copy(sa.Addr[:], ip) sa.Scope_id = uint32(i) } func (pi inet6Pktinfo) setIfindex(i int) { pi.Ifindex = int32(i) } func (mreq ipv6Mreq) setIfindex(i int) { mreq.Ifindex = int32(i) } func (gr groupReq) setGroup(grp net.IP) { sa := (sockaddrInet6)(unsafe.Pointer(&gr.Group)) sa.Family = syscall.AF_INET6 copy(sa.Addr[:], grp) } func (gsr groupSourceReq) setSourceGroup(grp, src net.IP) { sa := (sockaddrInet6)(unsafe.Pointer(&gsr.Group)) sa.Family = syscall.AF_INET6 copy(sa.Addr[:], grp) sa = (*sockaddrInet6)(unsafe.Pointer(&gsr.Source)) sa.Family = syscall.AF_INET6 copy(sa.Addr[:], src) }	3.83 KB	2025-05-25 12:27
📄 sys_solaris.go // Copyright 2016 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" "syscall" "unsafe" "golang.org/x/net/internal/iana" "golang.org/x/net/internal/socket" "golang.org/x/sys/unix" ) var ( ctlOpts = [ctlMax]ctlOpt{ ctlTrafficClass: {unix.IPV6_TCLASS, 4, marshalTrafficClass, parseTrafficClass}, ctlHopLimit: {unix.IPV6_HOPLIMIT, 4, marshalHopLimit, parseHopLimit}, ctlPacketInfo: {unix.IPV6_PKTINFO, sizeofInet6Pktinfo, marshalPacketInfo, parsePacketInfo}, ctlNextHop: {unix.IPV6_NEXTHOP, sizeofSockaddrInet6, marshalNextHop, parseNextHop}, ctlPathMTU: {unix.IPV6_PATHMTU, sizeofIPv6Mtuinfo, marshalPathMTU, parsePathMTU}, } sockOpts = map[int]sockOpt{ ssoTrafficClass: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_TCLASS, Len: 4}}, ssoHopLimit: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_UNICAST_HOPS, Len: 4}}, ssoMulticastInterface: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_MULTICAST_IF, Len: 4}}, ssoMulticastHopLimit: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_MULTICAST_HOPS, Len: 4}}, ssoMulticastLoopback: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_MULTICAST_LOOP, Len: 4}}, ssoReceiveTrafficClass: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_RECVTCLASS, Len: 4}}, ssoReceiveHopLimit: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_RECVHOPLIMIT, Len: 4}}, ssoReceivePacketInfo: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_RECVPKTINFO, Len: 4}}, ssoReceivePathMTU: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_RECVPATHMTU, Len: 4}}, ssoPathMTU: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_PATHMTU, Len: sizeofIPv6Mtuinfo}}, ssoChecksum: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_CHECKSUM, Len: 4}}, ssoICMPFilter: {Option: socket.Option{Level: iana.ProtocolIPv6ICMP, Name: unix.ICMP6_FILTER, Len: sizeofICMPv6Filter}}, ssoJoinGroup: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.MCAST_JOIN_GROUP, Len: sizeofGroupReq}, typ: ssoTypeGroupReq}, ssoLeaveGroup: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.MCAST_LEAVE_GROUP, Len: sizeofGroupReq}, typ: ssoTypeGroupReq}, ssoJoinSourceGroup: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.MCAST_JOIN_SOURCE_GROUP, Len: sizeofGroupSourceReq}, typ: ssoTypeGroupSourceReq}, ssoLeaveSourceGroup: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.MCAST_LEAVE_SOURCE_GROUP, Len: sizeofGroupSourceReq}, typ: ssoTypeGroupSourceReq}, ssoBlockSourceGroup: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.MCAST_BLOCK_SOURCE, Len: sizeofGroupSourceReq}, typ: ssoTypeGroupSourceReq}, ssoUnblockSourceGroup: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.MCAST_UNBLOCK_SOURCE, Len: sizeofGroupSourceReq}, typ: ssoTypeGroupSourceReq}, } ) func (sa sockaddrInet6) setSockaddr(ip net.IP, i int) { sa.Family = syscall.AF_INET6 copy(sa.Addr[:], ip) sa.Scope_id = uint32(i) } func (pi inet6Pktinfo) setIfindex(i int) { pi.Ifindex = uint32(i) } func (mreq ipv6Mreq) setIfindex(i int) { mreq.Interface = uint32(i) } func (gr groupReq) setGroup(grp net.IP) { sa := (sockaddrInet6)(unsafe.Pointer(uintptr(unsafe.Pointer(gr)) + 4)) sa.Family = syscall.AF_INET6 copy(sa.Addr[:], grp) } func (gsr groupSourceReq) setSourceGroup(grp, src net.IP) { sa := (sockaddrInet6)(unsafe.Pointer(uintptr(unsafe.Pointer(gsr)) + 4)) sa.Family = syscall.AF_INET6 copy(sa.Addr[:], grp) sa = (*sockaddrInet6)(unsafe.Pointer(uintptr(unsafe.Pointer(gsr)) + 260)) sa.Family = syscall.AF_INET6 copy(sa.Addr[:], src) }	3.86 KB	2025-05-25 12:27
📄 sys_ssmreq.go // Copyright 2014 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. //go:build aix \|\| darwin \|\| freebsd \|\| linux \|\| solaris \|\| zos package ipv6 import ( "net" "unsafe" "golang.org/x/net/internal/socket" ) var compatFreeBSD32 bool // 386 emulation on amd64 func (so sockOpt) setGroupReq(c socket.Conn, ifi net.Interface, grp net.IP) error { var gr groupReq if ifi != nil { gr.Interface = uint32(ifi.Index) } gr.setGroup(grp) var b []byte if compatFreeBSD32 { var d [sizeofGroupReq + 4]byte s := ([sizeofGroupReq]byte)(unsafe.Pointer(&gr)) copy(d[:4], s[:4]) copy(d[8:], s[4:]) b = d[:] } else { b = ([sizeofGroupReq]byte)(unsafe.Pointer(&gr))[:sizeofGroupReq] } return so.Set(c, b) } func (so sockOpt) setGroupSourceReq(c socket.Conn, ifi net.Interface, grp, src net.IP) error { var gsr groupSourceReq if ifi != nil { gsr.Interface = uint32(ifi.Index) } gsr.setSourceGroup(grp, src) var b []byte if compatFreeBSD32 { var d [sizeofGroupSourceReq + 4]byte s := ([sizeofGroupSourceReq]byte)(unsafe.Pointer(&gsr)) copy(d[:4], s[:4]) copy(d[8:], s[4:]) b = d[:] } else { b = ([sizeofGroupSourceReq]byte)(unsafe.Pointer(&gsr))[:sizeofGroupSourceReq] } return so.Set(c, b) }	1.29 KB	2025-05-25 12:27
📄 sys_ssmreq_stub.go // Copyright 2014 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. //go:build !aix && !darwin && !freebsd && !linux && !solaris && !zos package ipv6 import ( "net" "golang.org/x/net/internal/socket" ) func (so sockOpt) setGroupReq(c socket.Conn, ifi net.Interface, grp net.IP) error { return errNotImplemented } func (so sockOpt) setGroupSourceReq(c socket.Conn, ifi net.Interface, grp, src net.IP) error { return errNotImplemented }	542 B	2025-05-25 12:27
📄 sys_stub.go // Copyright 2014 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. //go:build !aix && !darwin && !dragonfly && !freebsd && !linux && !netbsd && !openbsd && !solaris && !windows && !zos package ipv6 var ( ctlOpts = [ctlMax]ctlOpt{} sockOpts = map[int]*sockOpt{} )	361 B	2025-05-25 12:27
📄 sys_windows.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" "syscall" "golang.org/x/net/internal/iana" "golang.org/x/net/internal/socket" "golang.org/x/sys/windows" ) const ( sizeofSockaddrInet6 = 0x1c sizeofIPv6Mreq = 0x14 sizeofIPv6Mtuinfo = 0x20 sizeofICMPv6Filter = 0 ) type sockaddrInet6 struct { Family uint16 Port uint16 Flowinfo uint32 Addr [16]byte /* in6_addr / Scope_id uint32 } type ipv6Mreq struct { Multiaddr [16]byte / in6_addr / Interface uint32 } type ipv6Mtuinfo struct { Addr sockaddrInet6 Mtu uint32 } type icmpv6Filter struct { // TODO(mikio): implement this } var ( ctlOpts = [ctlMax]ctlOpt{} sockOpts = map[int]sockOpt{ ssoHopLimit: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: windows.IPV6_UNICAST_HOPS, Len: 4}}, ssoMulticastInterface: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: windows.IPV6_MULTICAST_IF, Len: 4}}, ssoMulticastHopLimit: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: windows.IPV6_MULTICAST_HOPS, Len: 4}}, ssoMulticastLoopback: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: windows.IPV6_MULTICAST_LOOP, Len: 4}}, ssoJoinGroup: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: windows.IPV6_JOIN_GROUP, Len: sizeofIPv6Mreq}, typ: ssoTypeIPMreq}, ssoLeaveGroup: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: windows.IPV6_LEAVE_GROUP, Len: sizeofIPv6Mreq}, typ: ssoTypeIPMreq}, } ) func (sa sockaddrInet6) setSockaddr(ip net.IP, i int) { sa.Family = syscall.AF_INET6 copy(sa.Addr[:], ip) sa.Scope_id = uint32(i) } func (mreq ipv6Mreq) setIfindex(i int) { mreq.Interface = uint32(i) }	1.76 KB	2025-05-25 12:27
📄 sys_zos.go // Copyright 2020 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" "syscall" "unsafe" "golang.org/x/net/internal/iana" "golang.org/x/net/internal/socket" "golang.org/x/sys/unix" ) var ( ctlOpts = [ctlMax]ctlOpt{ ctlHopLimit: {unix.IPV6_HOPLIMIT, 4, marshalHopLimit, parseHopLimit}, ctlPacketInfo: {unix.IPV6_PKTINFO, sizeofInet6Pktinfo, marshalPacketInfo, parsePacketInfo}, ctlPathMTU: {unix.IPV6_PATHMTU, sizeofIPv6Mtuinfo, marshalPathMTU, parsePathMTU}, } sockOpts = map[int]sockOpt{ ssoTrafficClass: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_TCLASS, Len: 4}}, ssoHopLimit: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_UNICAST_HOPS, Len: 4}}, ssoMulticastInterface: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_MULTICAST_IF, Len: 4}}, ssoMulticastHopLimit: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_MULTICAST_HOPS, Len: 4}}, ssoMulticastLoopback: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_MULTICAST_LOOP, Len: 4}}, ssoReceiveTrafficClass: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_RECVTCLASS, Len: 4}}, ssoReceiveHopLimit: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_RECVHOPLIMIT, Len: 4}}, ssoReceivePacketInfo: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_RECVPKTINFO, Len: 4}}, ssoReceivePathMTU: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_RECVPATHMTU, Len: 4}}, ssoChecksum: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.IPV6_CHECKSUM, Len: 4}}, ssoICMPFilter: {Option: socket.Option{Level: iana.ProtocolIPv6ICMP, Name: unix.ICMP6_FILTER, Len: sizeofICMPv6Filter}}, ssoJoinGroup: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.MCAST_JOIN_GROUP, Len: sizeofGroupReq}, typ: ssoTypeGroupReq}, ssoLeaveGroup: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.MCAST_LEAVE_GROUP, Len: sizeofGroupReq}, typ: ssoTypeGroupReq}, ssoJoinSourceGroup: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.MCAST_JOIN_SOURCE_GROUP, Len: sizeofGroupSourceReq}, typ: ssoTypeGroupSourceReq}, ssoLeaveSourceGroup: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.MCAST_LEAVE_SOURCE_GROUP, Len: sizeofGroupSourceReq}, typ: ssoTypeGroupSourceReq}, ssoBlockSourceGroup: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.MCAST_BLOCK_SOURCE, Len: sizeofGroupSourceReq}, typ: ssoTypeGroupSourceReq}, ssoUnblockSourceGroup: {Option: socket.Option{Level: iana.ProtocolIPv6, Name: unix.MCAST_UNBLOCK_SOURCE, Len: sizeofGroupSourceReq}, typ: ssoTypeGroupSourceReq}, } ) func (sa sockaddrInet6) setSockaddr(ip net.IP, i int) { sa.Family = syscall.AF_INET6 copy(sa.Addr[:], ip) sa.Scope_id = uint32(i) } func (pi inet6Pktinfo) setIfindex(i int) { pi.Ifindex = uint32(i) } func (gr groupReq) setGroup(grp net.IP) { sa := (sockaddrInet6)(unsafe.Pointer(&gr.Group)) sa.Family = syscall.AF_INET6 sa.Len = sizeofSockaddrInet6 copy(sa.Addr[:], grp) } func (gsr groupSourceReq) setSourceGroup(grp, src net.IP) { sa := (sockaddrInet6)(unsafe.Pointer(&gsr.Group)) sa.Family = syscall.AF_INET6 sa.Len = sizeofSockaddrInet6 copy(sa.Addr[:], grp) sa = (sockaddrInet6)(unsafe.Pointer(&gsr.Source)) sa.Family = syscall.AF_INET6 sa.Len = sizeofSockaddrInet6 copy(sa.Addr[:], src) }	3.51 KB	2025-05-25 12:27
📄 unicast_test.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_test import ( "bytes" "errors" "net" "os" "runtime" "testing" "time" "golang.org/x/net/icmp" "golang.org/x/net/internal/iana" "golang.org/x/net/ipv6" "golang.org/x/net/nettest" ) func TestPacketConnReadWriteUnicastUDP(t testing.T) { switch runtime.GOOS { case "fuchsia", "hurd", "js", "nacl", "plan9", "wasip1", "windows": t.Skipf("not supported on %s", runtime.GOOS) } if _, err := nettest.RoutedInterface("ip6", net.FlagUp\|net.FlagLoopback); err != nil { t.Skip("ipv6 is not enabled for loopback interface") } c, err := nettest.NewLocalPacketListener("udp6") if err != nil { t.Fatal(err) } defer c.Close() p := ipv6.NewPacketConn(c) defer p.Close() dst := c.LocalAddr() cm := ipv6.ControlMessage{ TrafficClass: iana.DiffServAF11 \| iana.CongestionExperienced, Src: net.IPv6loopback, } cf := ipv6.FlagTrafficClass \| ipv6.FlagHopLimit \| ipv6.FlagSrc \| ipv6.FlagDst \| ipv6.FlagInterface \| ipv6.FlagPathMTU ifi, _ := nettest.RoutedInterface("ip6", net.FlagUp\|net.FlagLoopback) if ifi != nil { cm.IfIndex = ifi.Index } wb := []byte("HELLO-R-U-THERE") for i, toggle := range []bool{true, false, true} { if err := p.SetControlMessage(cf, toggle); err != nil { if protocolNotSupported(err) { t.Logf("not supported on %s", runtime.GOOS) continue } t.Fatal(err) } cm.HopLimit = i + 1 backoff := time.Millisecond for { n, err := p.WriteTo(wb, &cm, dst) if err != nil { if n == 0 && isENOBUFS(err) { time.Sleep(backoff) backoff = 2 continue } t.Fatal(err) } if n != len(wb) { t.Fatalf("got %d; want %d", n, len(wb)) } break } rb := make([]byte, 128) if n, _, _, err := p.ReadFrom(rb); err != nil { t.Fatal(err) } else if !bytes.Equal(rb[:n], wb) { t.Fatalf("got %v; want %v", rb[:n], wb) } } } func TestPacketConnReadWriteUnicastICMP(t testing.T) { if !nettest.SupportsIPv6() { t.Skip("ipv6 is not supported") } if !nettest.SupportsRawSocket() { t.Skipf("not supported on %s/%s", runtime.GOOS, runtime.GOARCH) } c, err := net.ListenPacket("ip6:ipv6-icmp", "::1") if err != nil { t.Fatal(err) } defer c.Close() p := ipv6.NewPacketConn(c) defer p.Close() dst, err := net.ResolveIPAddr("ip6", "::1") if err != nil { t.Fatal(err) } pshicmp := icmp.IPv6PseudoHeader(c.LocalAddr().(net.IPAddr).IP, dst.IP) cm := ipv6.ControlMessage{ TrafficClass: iana.DiffServAF11 \| iana.CongestionExperienced, Src: net.IPv6loopback, } cf := ipv6.FlagTrafficClass \| ipv6.FlagHopLimit \| ipv6.FlagSrc \| ipv6.FlagDst \| ipv6.FlagInterface \| ipv6.FlagPathMTU ifi, _ := nettest.RoutedInterface("ip6", net.FlagUp\|net.FlagLoopback) if ifi != nil { cm.IfIndex = ifi.Index } var f ipv6.ICMPFilter f.SetAll(true) f.Accept(ipv6.ICMPTypeEchoReply) if err := p.SetICMPFilter(&f); errors.Is(err, ipv6.ErrNotImplemented) { t.Skipf("setting ICMP filter not supported: %v", err) } else if err != nil { t.Fatal(err) } var psh []byte for i, toggle := range []bool{true, false, true} { if toggle { psh = nil if err := p.SetChecksum(true, 2); err != nil { // AIX, Illumos and Solaris never allow // modification of ICMP properties. switch runtime.GOOS { case "aix", "illumos", "solaris": default: t.Fatal(err) } } } else { psh = pshicmp // Some platforms never allow to disable the // kernel checksum processing. p.SetChecksum(false, -1) } wb, err := (&icmp.Message{ Type: ipv6.ICMPTypeEchoRequest, Code: 0, Body: &icmp.Echo{ ID: os.Getpid() & 0xffff, Seq: i + 1, Data: []byte("HELLO-R-U-THERE"), }, }).Marshal(psh) if err != nil { t.Fatal(err) } if err := p.SetControlMessage(cf, toggle); err != nil { if protocolNotSupported(err) { t.Logf("not supported on %s", runtime.GOOS) continue } t.Fatal(err) } cm.HopLimit = i + 1 backoff := time.Millisecond for { n, err := p.WriteTo(wb, &cm, dst) if err != nil { if n == 0 && isENOBUFS(err) { time.Sleep(backoff) backoff *= 2 continue } t.Fatal(err) } if n != len(wb) { t.Fatalf("got %d; want %d", n, len(wb)) } break } rb := make([]byte, 128) if n, _, _, err := p.ReadFrom(rb); err != nil { t.Fatal(err) } else { if m, err := icmp.ParseMessage(iana.ProtocolIPv6ICMP, rb[:n]); err != nil { t.Fatal(err) } else if m.Type != ipv6.ICMPTypeEchoReply \|\| m.Code != 0 { t.Fatalf("got type=%v, code=%v; want type=%v, code=%v", m.Type, m.Code, ipv6.ICMPTypeEchoReply, 0) } } } }	4.63 KB	2025-05-25 12:27
📄 unicastsockopt_test.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_test import ( "net" "runtime" "testing" "golang.org/x/net/internal/iana" "golang.org/x/net/ipv6" "golang.org/x/net/nettest" ) func TestConnUnicastSocketOptions(t testing.T) { switch runtime.GOOS { case "fuchsia", "hurd", "js", "nacl", "plan9", "wasip1", "windows": t.Skipf("not supported on %s", runtime.GOOS) } if _, err := nettest.RoutedInterface("ip6", net.FlagUp\|net.FlagLoopback); err != nil { t.Skip("ipv6 is not enabled for loopback interface") } ln, err := net.Listen("tcp6", "[::1]:0") if err != nil { t.Fatal(err) } defer ln.Close() errc := make(chan error, 1) go func() { c, err := ln.Accept() if err != nil { errc <- err return } errc <- c.Close() }() c, err := net.Dial("tcp6", ln.Addr().String()) if err != nil { t.Fatal(err) } defer c.Close() testUnicastSocketOptions(t, ipv6.NewConn(c)) if err := <-errc; err != nil { t.Errorf("server: %v", err) } } var packetConnUnicastSocketOptionTests = []struct { net, proto, addr string }{ {"udp6", "", "[::1]:0"}, {"ip6", ":ipv6-icmp", "::1"}, } func TestPacketConnUnicastSocketOptions(t testing.T) { switch runtime.GOOS { case "fuchsia", "hurd", "js", "nacl", "plan9", "wasip1", "windows": t.Skipf("not supported on %s", runtime.GOOS) } if _, err := nettest.RoutedInterface("ip6", net.FlagUp\|net.FlagLoopback); err != nil { t.Skip("ipv6 is not enabled for loopback interface") } ok := nettest.SupportsRawSocket() for _, tt := range packetConnUnicastSocketOptionTests { if tt.net == "ip6" && !ok { t.Logf("not supported on %s/%s", runtime.GOOS, runtime.GOARCH) continue } c, err := net.ListenPacket(tt.net+tt.proto, tt.addr) if err != nil { t.Fatal(err) } defer c.Close() testUnicastSocketOptions(t, ipv6.NewPacketConn(c)) } } type testIPv6UnicastConn interface { TrafficClass() (int, error) SetTrafficClass(int) error HopLimit() (int, error) SetHopLimit(int) error } func testUnicastSocketOptions(t *testing.T, c testIPv6UnicastConn) { t.Helper() tclass := iana.DiffServCS0 \| iana.NotECNTransport if err := c.SetTrafficClass(tclass); err != nil { t.Fatal(err) } if v, err := c.TrafficClass(); err != nil { t.Fatal(err) } else if v != tclass { t.Fatalf("got %v; want %v", v, tclass) } hoplim := 255 if err := c.SetHopLimit(hoplim); err != nil { t.Fatal(err) } if v, err := c.HopLimit(); err != nil { t.Fatal(err) } else if v != hoplim { t.Fatalf("got %v; want %v", v, hoplim) } }	2.58 KB	2025-05-25 12:27
📄 zsys_aix_ppc64.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_aix.go // Added for go1.11 compatibility //go:build aix package ipv6 const ( sizeofSockaddrStorage = 0x508 sizeofSockaddrInet6 = 0x1c sizeofInet6Pktinfo = 0x14 sizeofIPv6Mtuinfo = 0x20 sizeofIPv6Mreq = 0x14 sizeofGroupReq = 0x510 sizeofGroupSourceReq = 0xa18 sizeofICMPv6Filter = 0x20 ) type sockaddrStorage struct { X__ss_len uint8 Family uint8 X__ss_pad1 [6]uint8 X__ss_align int64 X__ss_pad2 [1265]uint8 Pad_cgo_0 [7]byte } type sockaddrInet6 struct { Len uint8 Family uint8 Port uint16 Flowinfo uint32 Addr [16]byte /* in6_addr / Scope_id uint32 } type inet6Pktinfo struct { Addr [16]byte / in6_addr / Ifindex int32 } type ipv6Mtuinfo struct { Addr sockaddrInet6 Mtu uint32 } type ipv6Mreq struct { Multiaddr [16]byte / in6_addr */ Interface uint32 } type icmpv6Filter struct { Filt [8]uint32 } type groupReq struct { Interface uint32 Group sockaddrStorage } type groupSourceReq struct { Interface uint32 Group sockaddrStorage Source sockaddrStorage }	1.11 KB	2025-05-25 12:27
📄 zsys_darwin.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_darwin.go package ipv6 const ( sizeofSockaddrStorage = 0x80 sizeofSockaddrInet6 = 0x1c sizeofInet6Pktinfo = 0x14 sizeofIPv6Mtuinfo = 0x20 sizeofIPv6Mreq = 0x14 sizeofGroupReq = 0x84 sizeofGroupSourceReq = 0x104 sizeofICMPv6Filter = 0x20 ) type sockaddrStorage struct { Len uint8 Family uint8 X__ss_pad1 [6]int8 X__ss_align int64 X__ss_pad2 [112]int8 } type sockaddrInet6 struct { Len uint8 Family uint8 Port uint16 Flowinfo uint32 Addr [16]byte /* in6_addr / Scope_id uint32 } type inet6Pktinfo struct { Addr [16]byte / in6_addr / Ifindex uint32 } type ipv6Mtuinfo struct { Addr sockaddrInet6 Mtu uint32 } type ipv6Mreq struct { Multiaddr [16]byte / in6_addr */ Interface uint32 } type icmpv6Filter struct { Filt [8]uint32 } type groupReq struct { Interface uint32 Pad_cgo_0 [128]byte } type groupSourceReq struct { Interface uint32 Pad_cgo_0 [128]byte Pad_cgo_1 [128]byte }	1.02 KB	2025-05-25 12:27
📄 zsys_dragonfly.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_dragonfly.go package ipv6 const ( sizeofSockaddrInet6 = 0x1c sizeofInet6Pktinfo = 0x14 sizeofIPv6Mtuinfo = 0x20 sizeofIPv6Mreq = 0x14 sizeofICMPv6Filter = 0x20 ) type sockaddrInet6 struct { Len uint8 Family uint8 Port uint16 Flowinfo uint32 Addr [16]byte /* in6_addr / Scope_id uint32 } type inet6Pktinfo struct { Addr [16]byte / in6_addr / Ifindex uint32 } type ipv6Mtuinfo struct { Addr sockaddrInet6 Mtu uint32 } type ipv6Mreq struct { Multiaddr [16]byte / in6_addr */ Interface uint32 } type icmpv6Filter struct { Filt [8]uint32 }	659 B	2025-05-25 12:27
📄 zsys_freebsd_386.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_freebsd.go package ipv6 const ( sizeofSockaddrStorage = 0x80 sizeofSockaddrInet6 = 0x1c sizeofInet6Pktinfo = 0x14 sizeofIPv6Mtuinfo = 0x20 sizeofIPv6Mreq = 0x14 sizeofGroupReq = 0x84 sizeofGroupSourceReq = 0x104 sizeofICMPv6Filter = 0x20 ) type sockaddrStorage struct { Len uint8 Family uint8 X__ss_pad1 [6]int8 X__ss_align int64 X__ss_pad2 [112]int8 } type sockaddrInet6 struct { Len uint8 Family uint8 Port uint16 Flowinfo uint32 Addr [16]byte /* in6_addr / Scope_id uint32 } type inet6Pktinfo struct { Addr [16]byte / in6_addr / Ifindex uint32 } type ipv6Mtuinfo struct { Addr sockaddrInet6 Mtu uint32 } type ipv6Mreq struct { Multiaddr [16]byte / in6_addr */ Interface uint32 } type groupReq struct { Interface uint32 Group sockaddrStorage } type groupSourceReq struct { Interface uint32 Group sockaddrStorage Source sockaddrStorage } type icmpv6Filter struct { Filt [8]uint32 }	1.04 KB	2025-05-25 12:27
📄 zsys_freebsd_amd64.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_freebsd.go package ipv6 const ( sizeofSockaddrStorage = 0x80 sizeofSockaddrInet6 = 0x1c sizeofInet6Pktinfo = 0x14 sizeofIPv6Mtuinfo = 0x20 sizeofIPv6Mreq = 0x14 sizeofGroupReq = 0x88 sizeofGroupSourceReq = 0x108 sizeofICMPv6Filter = 0x20 ) type sockaddrStorage struct { Len uint8 Family uint8 X__ss_pad1 [6]int8 X__ss_align int64 X__ss_pad2 [112]int8 } type sockaddrInet6 struct { Len uint8 Family uint8 Port uint16 Flowinfo uint32 Addr [16]byte /* in6_addr / Scope_id uint32 } type inet6Pktinfo struct { Addr [16]byte / in6_addr / Ifindex uint32 } type ipv6Mtuinfo struct { Addr sockaddrInet6 Mtu uint32 } type ipv6Mreq struct { Multiaddr [16]byte / in6_addr */ Interface uint32 } type groupReq struct { Interface uint32 Pad_cgo_0 [4]byte Group sockaddrStorage } type groupSourceReq struct { Interface uint32 Pad_cgo_0 [4]byte Group sockaddrStorage Source sockaddrStorage } type icmpv6Filter struct { Filt [8]uint32 }	1.08 KB	2025-05-25 12:27
📄 zsys_freebsd_arm.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_freebsd.go package ipv6 const ( sizeofSockaddrStorage = 0x80 sizeofSockaddrInet6 = 0x1c sizeofInet6Pktinfo = 0x14 sizeofIPv6Mtuinfo = 0x20 sizeofIPv6Mreq = 0x14 sizeofGroupReq = 0x88 sizeofGroupSourceReq = 0x108 sizeofICMPv6Filter = 0x20 ) type sockaddrStorage struct { Len uint8 Family uint8 X__ss_pad1 [6]int8 X__ss_align int64 X__ss_pad2 [112]int8 } type sockaddrInet6 struct { Len uint8 Family uint8 Port uint16 Flowinfo uint32 Addr [16]byte /* in6_addr / Scope_id uint32 } type inet6Pktinfo struct { Addr [16]byte / in6_addr / Ifindex uint32 } type ipv6Mtuinfo struct { Addr sockaddrInet6 Mtu uint32 } type ipv6Mreq struct { Multiaddr [16]byte / in6_addr */ Interface uint32 } type groupReq struct { Interface uint32 Pad_cgo_0 [4]byte Group sockaddrStorage } type groupSourceReq struct { Interface uint32 Pad_cgo_0 [4]byte Group sockaddrStorage Source sockaddrStorage } type icmpv6Filter struct { Filt [8]uint32 }	1.08 KB	2025-05-25 12:27
📄 zsys_freebsd_arm64.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_freebsd.go package ipv6 const ( sizeofSockaddrStorage = 0x80 sizeofSockaddrInet6 = 0x1c sizeofInet6Pktinfo = 0x14 sizeofIPv6Mtuinfo = 0x20 sizeofIPv6Mreq = 0x14 sizeofGroupReq = 0x88 sizeofGroupSourceReq = 0x108 sizeofICMPv6Filter = 0x20 ) type sockaddrStorage struct { Len uint8 Family uint8 X__ss_pad1 [6]uint8 X__ss_align int64 X__ss_pad2 [112]uint8 } type sockaddrInet6 struct { Len uint8 Family uint8 Port uint16 Flowinfo uint32 Addr [16]byte /* in6_addr / Scope_id uint32 } type inet6Pktinfo struct { Addr [16]byte / in6_addr / Ifindex uint32 } type ipv6Mtuinfo struct { Addr sockaddrInet6 Mtu uint32 } type ipv6Mreq struct { Multiaddr [16]byte / in6_addr */ Interface uint32 } type groupReq struct { Interface uint32 Group sockaddrStorage } type groupSourceReq struct { Interface uint32 Group sockaddrStorage Source sockaddrStorage } type icmpv6Filter struct { Filt [8]uint32 }	1.04 KB	2025-05-25 12:27
📄 zsys_freebsd_riscv64.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_freebsd.go package ipv6 const ( sizeofSockaddrStorage = 0x80 sizeofSockaddrInet6 = 0x1c sizeofInet6Pktinfo = 0x14 sizeofIPv6Mtuinfo = 0x20 sizeofIPv6Mreq = 0x14 sizeofGroupReq = 0x88 sizeofGroupSourceReq = 0x108 sizeofICMPv6Filter = 0x20 ) type sockaddrStorage struct { Len uint8 Family uint8 X__ss_pad1 [6]uint8 X__ss_align int64 X__ss_pad2 [112]uint8 } type sockaddrInet6 struct { Len uint8 Family uint8 Port uint16 Flowinfo uint32 Addr [16]byte /* in6_addr / Scope_id uint32 } type inet6Pktinfo struct { Addr [16]byte / in6_addr / Ifindex uint32 } type ipv6Mtuinfo struct { Addr sockaddrInet6 Mtu uint32 } type ipv6Mreq struct { Multiaddr [16]byte / in6_addr */ Interface uint32 } type groupReq struct { Interface uint32 Group sockaddrStorage } type groupSourceReq struct { Interface uint32 Group sockaddrStorage Source sockaddrStorage } type icmpv6Filter struct { Filt [8]uint32 }	1.04 KB	2025-05-25 12:27
📄 zsys_linux_386.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_linux.go package ipv6 const ( sizeofKernelSockaddrStorage = 0x80 sizeofSockaddrInet6 = 0x1c sizeofInet6Pktinfo = 0x14 sizeofIPv6Mtuinfo = 0x20 sizeofIPv6FlowlabelReq = 0x20 sizeofIPv6Mreq = 0x14 sizeofGroupReq = 0x84 sizeofGroupSourceReq = 0x104 sizeofICMPv6Filter = 0x20 ) type kernelSockaddrStorage struct { Family uint16 X__data [126]int8 } type sockaddrInet6 struct { Family uint16 Port uint16 Flowinfo uint32 Addr [16]byte /* in6_addr / Scope_id uint32 } type inet6Pktinfo struct { Addr [16]byte / in6_addr / Ifindex int32 } type ipv6Mtuinfo struct { Addr sockaddrInet6 Mtu uint32 } type ipv6FlowlabelReq struct { Dst [16]byte / in6_addr / Label uint32 Action uint8 Share uint8 Flags uint16 Expires uint16 Linger uint16 X__flr_pad uint32 } type ipv6Mreq struct { Multiaddr [16]byte / in6_addr */ Ifindex int32 } type groupReq struct { Interface uint32 Group kernelSockaddrStorage } type groupSourceReq struct { Interface uint32 Group kernelSockaddrStorage Source kernelSockaddrStorage } type icmpv6Filter struct { Data [8]uint32 }	1.24 KB	2025-05-25 12:27
📄 zsys_linux_amd64.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_linux.go package ipv6 const ( sizeofKernelSockaddrStorage = 0x80 sizeofSockaddrInet6 = 0x1c sizeofInet6Pktinfo = 0x14 sizeofIPv6Mtuinfo = 0x20 sizeofIPv6FlowlabelReq = 0x20 sizeofIPv6Mreq = 0x14 sizeofGroupReq = 0x88 sizeofGroupSourceReq = 0x108 sizeofICMPv6Filter = 0x20 ) type kernelSockaddrStorage struct { Family uint16 X__data [126]int8 } type sockaddrInet6 struct { Family uint16 Port uint16 Flowinfo uint32 Addr [16]byte /* in6_addr / Scope_id uint32 } type inet6Pktinfo struct { Addr [16]byte / in6_addr / Ifindex int32 } type ipv6Mtuinfo struct { Addr sockaddrInet6 Mtu uint32 } type ipv6FlowlabelReq struct { Dst [16]byte / in6_addr / Label uint32 Action uint8 Share uint8 Flags uint16 Expires uint16 Linger uint16 X__flr_pad uint32 } type ipv6Mreq struct { Multiaddr [16]byte / in6_addr */ Ifindex int32 } type groupReq struct { Interface uint32 Pad_cgo_0 [4]byte Group kernelSockaddrStorage } type groupSourceReq struct { Interface uint32 Pad_cgo_0 [4]byte Group kernelSockaddrStorage Source kernelSockaddrStorage } type icmpv6Filter struct { Data [8]uint32 }	1.27 KB	2025-05-25 12:27
📄 zsys_linux_arm.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_linux.go package ipv6 const ( sizeofKernelSockaddrStorage = 0x80 sizeofSockaddrInet6 = 0x1c sizeofInet6Pktinfo = 0x14 sizeofIPv6Mtuinfo = 0x20 sizeofIPv6FlowlabelReq = 0x20 sizeofIPv6Mreq = 0x14 sizeofGroupReq = 0x84 sizeofGroupSourceReq = 0x104 sizeofICMPv6Filter = 0x20 ) type kernelSockaddrStorage struct { Family uint16 X__data [126]int8 } type sockaddrInet6 struct { Family uint16 Port uint16 Flowinfo uint32 Addr [16]byte /* in6_addr / Scope_id uint32 } type inet6Pktinfo struct { Addr [16]byte / in6_addr / Ifindex int32 } type ipv6Mtuinfo struct { Addr sockaddrInet6 Mtu uint32 } type ipv6FlowlabelReq struct { Dst [16]byte / in6_addr / Label uint32 Action uint8 Share uint8 Flags uint16 Expires uint16 Linger uint16 X__flr_pad uint32 } type ipv6Mreq struct { Multiaddr [16]byte / in6_addr */ Ifindex int32 } type groupReq struct { Interface uint32 Group kernelSockaddrStorage } type groupSourceReq struct { Interface uint32 Group kernelSockaddrStorage Source kernelSockaddrStorage } type icmpv6Filter struct { Data [8]uint32 }	1.24 KB	2025-05-25 12:27
📄 zsys_linux_arm64.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_linux.go package ipv6 const ( sizeofKernelSockaddrStorage = 0x80 sizeofSockaddrInet6 = 0x1c sizeofInet6Pktinfo = 0x14 sizeofIPv6Mtuinfo = 0x20 sizeofIPv6FlowlabelReq = 0x20 sizeofIPv6Mreq = 0x14 sizeofGroupReq = 0x88 sizeofGroupSourceReq = 0x108 sizeofICMPv6Filter = 0x20 ) type kernelSockaddrStorage struct { Family uint16 X__data [126]int8 } type sockaddrInet6 struct { Family uint16 Port uint16 Flowinfo uint32 Addr [16]byte /* in6_addr / Scope_id uint32 } type inet6Pktinfo struct { Addr [16]byte / in6_addr / Ifindex int32 } type ipv6Mtuinfo struct { Addr sockaddrInet6 Mtu uint32 } type ipv6FlowlabelReq struct { Dst [16]byte / in6_addr / Label uint32 Action uint8 Share uint8 Flags uint16 Expires uint16 Linger uint16 X__flr_pad uint32 } type ipv6Mreq struct { Multiaddr [16]byte / in6_addr */ Ifindex int32 } type groupReq struct { Interface uint32 Pad_cgo_0 [4]byte Group kernelSockaddrStorage } type groupSourceReq struct { Interface uint32 Pad_cgo_0 [4]byte Group kernelSockaddrStorage Source kernelSockaddrStorage } type icmpv6Filter struct { Data [8]uint32 }	1.27 KB	2025-05-25 12:27
📄 zsys_linux_loong64.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_linux.go //go:build loong64 package ipv6 const ( sizeofKernelSockaddrStorage = 0x80 sizeofSockaddrInet6 = 0x1c sizeofInet6Pktinfo = 0x14 sizeofIPv6Mtuinfo = 0x20 sizeofIPv6FlowlabelReq = 0x20 sizeofIPv6Mreq = 0x14 sizeofGroupReq = 0x88 sizeofGroupSourceReq = 0x108 sizeofICMPv6Filter = 0x20 ) type kernelSockaddrStorage struct { Family uint16 X__data [126]int8 } type sockaddrInet6 struct { Family uint16 Port uint16 Flowinfo uint32 Addr [16]byte /* in6_addr / Scope_id uint32 } type inet6Pktinfo struct { Addr [16]byte / in6_addr / Ifindex int32 } type ipv6Mtuinfo struct { Addr sockaddrInet6 Mtu uint32 } type ipv6FlowlabelReq struct { Dst [16]byte / in6_addr / Label uint32 Action uint8 Share uint8 Flags uint16 Expires uint16 Linger uint16 X__flr_pad uint32 } type ipv6Mreq struct { Multiaddr [16]byte / in6_addr */ Ifindex int32 } type groupReq struct { Interface uint32 Pad_cgo_0 [4]byte Group kernelSockaddrStorage } type groupSourceReq struct { Interface uint32 Pad_cgo_0 [4]byte Group kernelSockaddrStorage Source kernelSockaddrStorage } type icmpv6Filter struct { Data [8]uint32 }	1.29 KB	2025-05-25 12:27
📄 zsys_linux_mips.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_linux.go package ipv6 const ( sizeofKernelSockaddrStorage = 0x80 sizeofSockaddrInet6 = 0x1c sizeofInet6Pktinfo = 0x14 sizeofIPv6Mtuinfo = 0x20 sizeofIPv6FlowlabelReq = 0x20 sizeofIPv6Mreq = 0x14 sizeofGroupReq = 0x84 sizeofGroupSourceReq = 0x104 sizeofICMPv6Filter = 0x20 ) type kernelSockaddrStorage struct { Family uint16 X__data [126]int8 } type sockaddrInet6 struct { Family uint16 Port uint16 Flowinfo uint32 Addr [16]byte /* in6_addr / Scope_id uint32 } type inet6Pktinfo struct { Addr [16]byte / in6_addr / Ifindex int32 } type ipv6Mtuinfo struct { Addr sockaddrInet6 Mtu uint32 } type ipv6FlowlabelReq struct { Dst [16]byte / in6_addr / Label uint32 Action uint8 Share uint8 Flags uint16 Expires uint16 Linger uint16 X__flr_pad uint32 } type ipv6Mreq struct { Multiaddr [16]byte / in6_addr */ Ifindex int32 } type groupReq struct { Interface uint32 Group kernelSockaddrStorage } type groupSourceReq struct { Interface uint32 Group kernelSockaddrStorage Source kernelSockaddrStorage } type icmpv6Filter struct { Data [8]uint32 }	1.24 KB	2025-05-25 12:27
📄 zsys_linux_mips64.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_linux.go package ipv6 const ( sizeofKernelSockaddrStorage = 0x80 sizeofSockaddrInet6 = 0x1c sizeofInet6Pktinfo = 0x14 sizeofIPv6Mtuinfo = 0x20 sizeofIPv6FlowlabelReq = 0x20 sizeofIPv6Mreq = 0x14 sizeofGroupReq = 0x88 sizeofGroupSourceReq = 0x108 sizeofICMPv6Filter = 0x20 ) type kernelSockaddrStorage struct { Family uint16 X__data [126]int8 } type sockaddrInet6 struct { Family uint16 Port uint16 Flowinfo uint32 Addr [16]byte /* in6_addr / Scope_id uint32 } type inet6Pktinfo struct { Addr [16]byte / in6_addr / Ifindex int32 } type ipv6Mtuinfo struct { Addr sockaddrInet6 Mtu uint32 } type ipv6FlowlabelReq struct { Dst [16]byte / in6_addr / Label uint32 Action uint8 Share uint8 Flags uint16 Expires uint16 Linger uint16 X__flr_pad uint32 } type ipv6Mreq struct { Multiaddr [16]byte / in6_addr */ Ifindex int32 } type groupReq struct { Interface uint32 Pad_cgo_0 [4]byte Group kernelSockaddrStorage } type groupSourceReq struct { Interface uint32 Pad_cgo_0 [4]byte Group kernelSockaddrStorage Source kernelSockaddrStorage } type icmpv6Filter struct { Data [8]uint32 }	1.27 KB	2025-05-25 12:27
📄 zsys_linux_mips64le.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_linux.go package ipv6 const ( sizeofKernelSockaddrStorage = 0x80 sizeofSockaddrInet6 = 0x1c sizeofInet6Pktinfo = 0x14 sizeofIPv6Mtuinfo = 0x20 sizeofIPv6FlowlabelReq = 0x20 sizeofIPv6Mreq = 0x14 sizeofGroupReq = 0x88 sizeofGroupSourceReq = 0x108 sizeofICMPv6Filter = 0x20 ) type kernelSockaddrStorage struct { Family uint16 X__data [126]int8 } type sockaddrInet6 struct { Family uint16 Port uint16 Flowinfo uint32 Addr [16]byte /* in6_addr / Scope_id uint32 } type inet6Pktinfo struct { Addr [16]byte / in6_addr / Ifindex int32 } type ipv6Mtuinfo struct { Addr sockaddrInet6 Mtu uint32 } type ipv6FlowlabelReq struct { Dst [16]byte / in6_addr / Label uint32 Action uint8 Share uint8 Flags uint16 Expires uint16 Linger uint16 X__flr_pad uint32 } type ipv6Mreq struct { Multiaddr [16]byte / in6_addr */ Ifindex int32 } type groupReq struct { Interface uint32 Pad_cgo_0 [4]byte Group kernelSockaddrStorage } type groupSourceReq struct { Interface uint32 Pad_cgo_0 [4]byte Group kernelSockaddrStorage Source kernelSockaddrStorage } type icmpv6Filter struct { Data [8]uint32 }	1.27 KB	2025-05-25 12:27
📄 zsys_linux_mipsle.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_linux.go package ipv6 const ( sizeofKernelSockaddrStorage = 0x80 sizeofSockaddrInet6 = 0x1c sizeofInet6Pktinfo = 0x14 sizeofIPv6Mtuinfo = 0x20 sizeofIPv6FlowlabelReq = 0x20 sizeofIPv6Mreq = 0x14 sizeofGroupReq = 0x84 sizeofGroupSourceReq = 0x104 sizeofICMPv6Filter = 0x20 ) type kernelSockaddrStorage struct { Family uint16 X__data [126]int8 } type sockaddrInet6 struct { Family uint16 Port uint16 Flowinfo uint32 Addr [16]byte /* in6_addr / Scope_id uint32 } type inet6Pktinfo struct { Addr [16]byte / in6_addr / Ifindex int32 } type ipv6Mtuinfo struct { Addr sockaddrInet6 Mtu uint32 } type ipv6FlowlabelReq struct { Dst [16]byte / in6_addr / Label uint32 Action uint8 Share uint8 Flags uint16 Expires uint16 Linger uint16 X__flr_pad uint32 } type ipv6Mreq struct { Multiaddr [16]byte / in6_addr */ Ifindex int32 } type groupReq struct { Interface uint32 Group kernelSockaddrStorage } type groupSourceReq struct { Interface uint32 Group kernelSockaddrStorage Source kernelSockaddrStorage } type icmpv6Filter struct { Data [8]uint32 }	1.24 KB	2025-05-25 12:27
📄 zsys_linux_ppc.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_linux.go package ipv6 const ( sizeofKernelSockaddrStorage = 0x80 sizeofSockaddrInet6 = 0x1c sizeofInet6Pktinfo = 0x14 sizeofIPv6Mtuinfo = 0x20 sizeofIPv6FlowlabelReq = 0x20 sizeofIPv6Mreq = 0x14 sizeofGroupReq = 0x84 sizeofGroupSourceReq = 0x104 sizeofICMPv6Filter = 0x20 ) type kernelSockaddrStorage struct { Family uint16 X__data [126]uint8 } type sockaddrInet6 struct { Family uint16 Port uint16 Flowinfo uint32 Addr [16]byte /* in6_addr / Scope_id uint32 } type inet6Pktinfo struct { Addr [16]byte / in6_addr / Ifindex int32 } type ipv6Mtuinfo struct { Addr sockaddrInet6 Mtu uint32 } type ipv6FlowlabelReq struct { Dst [16]byte / in6_addr / Label uint32 Action uint8 Share uint8 Flags uint16 Expires uint16 Linger uint16 X__flr_pad uint32 } type ipv6Mreq struct { Multiaddr [16]byte / in6_addr */ Ifindex int32 } type groupReq struct { Interface uint32 Group kernelSockaddrStorage } type groupSourceReq struct { Interface uint32 Group kernelSockaddrStorage Source kernelSockaddrStorage } type icmpv6Filter struct { Data [8]uint32 }	1.24 KB	2025-05-25 12:27
📄 zsys_linux_ppc64.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_linux.go package ipv6 const ( sizeofKernelSockaddrStorage = 0x80 sizeofSockaddrInet6 = 0x1c sizeofInet6Pktinfo = 0x14 sizeofIPv6Mtuinfo = 0x20 sizeofIPv6FlowlabelReq = 0x20 sizeofIPv6Mreq = 0x14 sizeofGroupReq = 0x88 sizeofGroupSourceReq = 0x108 sizeofICMPv6Filter = 0x20 ) type kernelSockaddrStorage struct { Family uint16 X__data [126]int8 } type sockaddrInet6 struct { Family uint16 Port uint16 Flowinfo uint32 Addr [16]byte /* in6_addr / Scope_id uint32 } type inet6Pktinfo struct { Addr [16]byte / in6_addr / Ifindex int32 } type ipv6Mtuinfo struct { Addr sockaddrInet6 Mtu uint32 } type ipv6FlowlabelReq struct { Dst [16]byte / in6_addr / Label uint32 Action uint8 Share uint8 Flags uint16 Expires uint16 Linger uint16 X__flr_pad uint32 } type ipv6Mreq struct { Multiaddr [16]byte / in6_addr */ Ifindex int32 } type groupReq struct { Interface uint32 Pad_cgo_0 [4]byte Group kernelSockaddrStorage } type groupSourceReq struct { Interface uint32 Pad_cgo_0 [4]byte Group kernelSockaddrStorage Source kernelSockaddrStorage } type icmpv6Filter struct { Data [8]uint32 }	1.27 KB	2025-05-25 12:27
📄 zsys_linux_ppc64le.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_linux.go package ipv6 const ( sizeofKernelSockaddrStorage = 0x80 sizeofSockaddrInet6 = 0x1c sizeofInet6Pktinfo = 0x14 sizeofIPv6Mtuinfo = 0x20 sizeofIPv6FlowlabelReq = 0x20 sizeofIPv6Mreq = 0x14 sizeofGroupReq = 0x88 sizeofGroupSourceReq = 0x108 sizeofICMPv6Filter = 0x20 ) type kernelSockaddrStorage struct { Family uint16 X__data [126]int8 } type sockaddrInet6 struct { Family uint16 Port uint16 Flowinfo uint32 Addr [16]byte /* in6_addr / Scope_id uint32 } type inet6Pktinfo struct { Addr [16]byte / in6_addr / Ifindex int32 } type ipv6Mtuinfo struct { Addr sockaddrInet6 Mtu uint32 } type ipv6FlowlabelReq struct { Dst [16]byte / in6_addr / Label uint32 Action uint8 Share uint8 Flags uint16 Expires uint16 Linger uint16 X__flr_pad uint32 } type ipv6Mreq struct { Multiaddr [16]byte / in6_addr */ Ifindex int32 } type groupReq struct { Interface uint32 Pad_cgo_0 [4]byte Group kernelSockaddrStorage } type groupSourceReq struct { Interface uint32 Pad_cgo_0 [4]byte Group kernelSockaddrStorage Source kernelSockaddrStorage } type icmpv6Filter struct { Data [8]uint32 }	1.27 KB	2025-05-25 12:27
📄 zsys_linux_riscv64.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_linux.go //go:build riscv64 package ipv6 const ( sizeofKernelSockaddrStorage = 0x80 sizeofSockaddrInet6 = 0x1c sizeofInet6Pktinfo = 0x14 sizeofIPv6Mtuinfo = 0x20 sizeofIPv6FlowlabelReq = 0x20 sizeofIPv6Mreq = 0x14 sizeofGroupReq = 0x88 sizeofGroupSourceReq = 0x108 sizeofICMPv6Filter = 0x20 ) type kernelSockaddrStorage struct { Family uint16 X__data [126]int8 } type sockaddrInet6 struct { Family uint16 Port uint16 Flowinfo uint32 Addr [16]byte /* in6_addr / Scope_id uint32 } type inet6Pktinfo struct { Addr [16]byte / in6_addr / Ifindex int32 } type ipv6Mtuinfo struct { Addr sockaddrInet6 Mtu uint32 } type ipv6FlowlabelReq struct { Dst [16]byte / in6_addr / Label uint32 Action uint8 Share uint8 Flags uint16 Expires uint16 Linger uint16 X__flr_pad uint32 } type ipv6Mreq struct { Multiaddr [16]byte / in6_addr */ Ifindex int32 } type groupReq struct { Interface uint32 Pad_cgo_0 [4]byte Group kernelSockaddrStorage } type groupSourceReq struct { Interface uint32 Pad_cgo_0 [4]byte Group kernelSockaddrStorage Source kernelSockaddrStorage } type icmpv6Filter struct { Data [8]uint32 }	1.29 KB	2025-05-25 12:27
📄 zsys_linux_s390x.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_linux.go package ipv6 const ( sizeofKernelSockaddrStorage = 0x80 sizeofSockaddrInet6 = 0x1c sizeofInet6Pktinfo = 0x14 sizeofIPv6Mtuinfo = 0x20 sizeofIPv6FlowlabelReq = 0x20 sizeofIPv6Mreq = 0x14 sizeofGroupReq = 0x88 sizeofGroupSourceReq = 0x108 sizeofICMPv6Filter = 0x20 ) type kernelSockaddrStorage struct { Family uint16 X__data [126]int8 } type sockaddrInet6 struct { Family uint16 Port uint16 Flowinfo uint32 Addr [16]byte /* in6_addr / Scope_id uint32 } type inet6Pktinfo struct { Addr [16]byte / in6_addr / Ifindex int32 } type ipv6Mtuinfo struct { Addr sockaddrInet6 Mtu uint32 } type ipv6FlowlabelReq struct { Dst [16]byte / in6_addr / Label uint32 Action uint8 Share uint8 Flags uint16 Expires uint16 Linger uint16 X__flr_pad uint32 } type ipv6Mreq struct { Multiaddr [16]byte / in6_addr */ Ifindex int32 } type groupReq struct { Interface uint32 Pad_cgo_0 [4]byte Group kernelSockaddrStorage } type groupSourceReq struct { Interface uint32 Pad_cgo_0 [4]byte Group kernelSockaddrStorage Source kernelSockaddrStorage } type icmpv6Filter struct { Data [8]uint32 }	1.27 KB	2025-05-25 12:27
📄 zsys_netbsd.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_netbsd.go package ipv6 const ( sizeofSockaddrInet6 = 0x1c sizeofInet6Pktinfo = 0x14 sizeofIPv6Mtuinfo = 0x20 sizeofIPv6Mreq = 0x14 sizeofICMPv6Filter = 0x20 ) type sockaddrInet6 struct { Len uint8 Family uint8 Port uint16 Flowinfo uint32 Addr [16]byte /* in6_addr / Scope_id uint32 } type inet6Pktinfo struct { Addr [16]byte / in6_addr / Ifindex uint32 } type ipv6Mtuinfo struct { Addr sockaddrInet6 Mtu uint32 } type ipv6Mreq struct { Multiaddr [16]byte / in6_addr */ Interface uint32 } type icmpv6Filter struct { Filt [8]uint32 }	656 B	2025-05-25 12:27
📄 zsys_openbsd.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_openbsd.go package ipv6 const ( sizeofSockaddrInet6 = 0x1c sizeofInet6Pktinfo = 0x14 sizeofIPv6Mtuinfo = 0x20 sizeofIPv6Mreq = 0x14 sizeofICMPv6Filter = 0x20 ) type sockaddrInet6 struct { Len uint8 Family uint8 Port uint16 Flowinfo uint32 Addr [16]byte /* in6_addr / Scope_id uint32 } type inet6Pktinfo struct { Addr [16]byte / in6_addr / Ifindex uint32 } type ipv6Mtuinfo struct { Addr sockaddrInet6 Mtu uint32 } type ipv6Mreq struct { Multiaddr [16]byte / in6_addr */ Interface uint32 } type icmpv6Filter struct { Filt [8]uint32 }	657 B	2025-05-25 12:27
📄 zsys_solaris.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_solaris.go package ipv6 const ( sizeofSockaddrStorage = 0x100 sizeofSockaddrInet6 = 0x20 sizeofInet6Pktinfo = 0x14 sizeofIPv6Mtuinfo = 0x24 sizeofIPv6Mreq = 0x14 sizeofGroupReq = 0x104 sizeofGroupSourceReq = 0x204 sizeofICMPv6Filter = 0x20 ) type sockaddrStorage struct { Family uint16 X_ss_pad1 [6]int8 X_ss_align float64 X_ss_pad2 [240]int8 } type sockaddrInet6 struct { Family uint16 Port uint16 Flowinfo uint32 Addr [16]byte /* in6_addr / Scope_id uint32 X__sin6_src_id uint32 } type inet6Pktinfo struct { Addr [16]byte / in6_addr / Ifindex uint32 } type ipv6Mtuinfo struct { Addr sockaddrInet6 Mtu uint32 } type ipv6Mreq struct { Multiaddr [16]byte / in6_addr */ Interface uint32 } type groupReq struct { Interface uint32 Pad_cgo_0 [256]byte } type groupSourceReq struct { Interface uint32 Pad_cgo_0 [256]byte Pad_cgo_1 [256]byte } type icmpv6Filter struct { X__icmp6_filt [8]uint32 }	1.05 KB	2025-05-25 12:27
📄 zsys_zos_s390x.go // Copyright 2020 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. // Hand edited based on zerrors_zos_s390x.go // TODO(Bill O'Farrell): auto-generate. package ipv6 const ( sizeofSockaddrStorage = 128 sizeofICMPv6Filter = 32 sizeofInet6Pktinfo = 20 sizeofIPv6Mtuinfo = 32 sizeofSockaddrInet6 = 28 sizeofGroupReq = 136 sizeofGroupSourceReq = 264 ) type sockaddrStorage struct { Len uint8 Family byte ss_pad1 [6]byte ss_align int64 ss_pad2 [112]byte } type sockaddrInet6 struct { Len uint8 Family uint8 Port uint16 Flowinfo uint32 Addr [16]byte Scope_id uint32 } type inet6Pktinfo struct { Addr [16]byte Ifindex uint32 } type ipv6Mtuinfo struct { Addr sockaddrInet6 Mtu uint32 } type groupReq struct { Interface uint32 reserved uint32 Group sockaddrStorage } type groupSourceReq struct { Interface uint32 reserved uint32 Group sockaddrStorage Source sockaddrStorage } type icmpv6Filter struct { Filt [8]uint32 }	1.08 KB	2025-05-25 12:27

Edit File:

Terminal