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 ipv4 import ( "net" "runtime" "golang.org/x/net/internal/socket" ) // BUG(mikio): On Windows, the ReadBatch and WriteBatch methods of // PacketConn are not implemented. // BUG(mikio): On Windows, the ReadBatch and WriteBatch methods of // RawConn 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. // // Unlike the ReadFrom method, it doesn't strip the IPv4 header // followed by option headers from the received IPv4 datagram when the // underlying transport is net.IPConn. Each Buffers field of Message // must be large enough to accommodate an IPv4 header and option // headers. 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} } if compatFreeBSD32 && ms[0].NN > 0 { adjustFreeBSD32(&ms[0]) } 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 } } // 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 packetHandler) 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.IPConn.LocalAddr().Network(), Source: c.IPConn.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.IPConn.LocalAddr().Network(), Source: c.IPConn.LocalAddr(), Err: err} } if compatFreeBSD32 && ms[0].NN > 0 { adjustFreeBSD32(&ms[0]) } 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 packetHandler) 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.IPConn.LocalAddr().Network(), Source: c.IPConn.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.IPConn.LocalAddr().Network(), Source: c.IPConn.LocalAddr(), Err: err} } return n, err } }	5.59 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 ipv4_test import ( "net" "runtime" "testing" "time" "golang.org/x/net/bpf" "golang.org/x/net/ipv4" ) func TestBPF(t testing.T) { if runtime.GOOS != "linux" { t.Skipf("not supported on %s", runtime.GOOS) } l, err := net.ListenPacket("udp4", "127.0.0.1:0") if err != nil { t.Fatal(err) } defer l.Close() p := ipv4.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("udp4", 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 } } }	1.85 KB	2025-05-25 12:27
📄 control.go // Copyright 2012 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 ipv4 import ( "fmt" "net" "sync" "golang.org/x/net/internal/iana" "golang.org/x/net/internal/socket" ) 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 } type ControlFlags uint const ( FlagTTL ControlFlags = 1 << iota // pass the TTL 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 ) // 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 or RawConn. // // Specifying socket options: ControlMessage for WriteTo // method of PacketConn or RawConn allows to send the options // to the protocol stack. // TTL int // time-to-live, receiving only Src net.IP // source address, specifying only Dst net.IP // destination address, receiving only IfIndex int // interface index, must be 1 <= value when specifying } func (cm ControlMessage) String() string { if cm == nil { return "<nil>" } return fmt.Sprintf("ttl=%d src=%v dst=%v ifindex=%d", cm.TTL, cm.Src, cm.Dst, cm.IfIndex) } // Marshal returns the binary encoding of cm. func (cm ControlMessage) Marshal() []byte { if cm == nil { return nil } var m socket.ControlMessage if ctlOpts[ctlPacketInfo].name > 0 && (cm.Src.To4() != nil \|\| cm.IfIndex > 0) { m = socket.NewControlMessage([]int{ctlOpts[ctlPacketInfo].length}) } if len(m) > 0 { ctlOpts[ctlPacketInfo].marshal(m, cm) } return m } // 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.ProtocolIP { continue } switch { case typ == ctlOpts[ctlTTL].name && l >= ctlOpts[ctlTTL].length: ctlOpts[ctlTTL].parse(cm, m.Data(l)) case typ == ctlOpts[ctlDst].name && l >= ctlOpts[ctlDst].length: ctlOpts[ctlDst].parse(cm, m.Data(l)) case typ == ctlOpts[ctlInterface].name && l >= ctlOpts[ctlInterface].length: ctlOpts[ctlInterface].parse(cm, m.Data(l)) case typ == ctlOpts[ctlPacketInfo].name && l >= ctlOpts[ctlPacketInfo].length: ctlOpts[ctlPacketInfo].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(FlagTTL) && ctlOpts[ctlTTL].name > 0 { l += socket.ControlMessageSpace(ctlOpts[ctlTTL].length) } if ctlOpts[ctlPacketInfo].name > 0 { if opt.isset(FlagSrc \| FlagDst \| FlagInterface) { l += socket.ControlMessageSpace(ctlOpts[ctlPacketInfo].length) } } else { if opt.isset(FlagDst) && ctlOpts[ctlDst].name > 0 { l += socket.ControlMessageSpace(ctlOpts[ctlDst].length) } if opt.isset(FlagInterface) && ctlOpts[ctlInterface].name > 0 { l += socket.ControlMessageSpace(ctlOpts[ctlInterface].length) } } var b []byte if l > 0 { b = make([]byte, l) } return b } // Ancillary data socket options const ( ctlTTL = iota // header field ctlSrc // header field ctlDst // header field ctlInterface // inbound or outbound interface ctlPacketInfo // inbound or outbound packet path 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) }	4.22 KB	2025-05-25 12:27
📄 control_bsd.go // Copyright 2012 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 ipv4 import ( "net" "syscall" "unsafe" "golang.org/x/net/internal/iana" "golang.org/x/net/internal/socket" "golang.org/x/sys/unix" ) func marshalDst(b []byte, cm ControlMessage) []byte { m := socket.ControlMessage(b) m.MarshalHeader(iana.ProtocolIP, unix.IP_RECVDSTADDR, net.IPv4len) return m.Next(net.IPv4len) } func parseDst(cm ControlMessage, b []byte) { if len(cm.Dst) < net.IPv4len { cm.Dst = make(net.IP, net.IPv4len) } copy(cm.Dst, b[:net.IPv4len]) } func marshalInterface(b []byte, cm ControlMessage) []byte { m := socket.ControlMessage(b) m.MarshalHeader(iana.ProtocolIP, sockoptReceiveInterface, syscall.SizeofSockaddrDatalink) return m.Next(syscall.SizeofSockaddrDatalink) } func parseInterface(cm ControlMessage, b []byte) { var sadl syscall.SockaddrDatalink copy((*[unsafe.Sizeof(sadl)]byte)(unsafe.Pointer(&sadl))[:], b) cm.IfIndex = int(sadl.Index) }	1.11 KB	2025-05-25 12:27
📄 control_pktinfo.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 darwin \|\| linux \|\| solaris package ipv4 import ( "net" "unsafe" "golang.org/x/net/internal/iana" "golang.org/x/net/internal/socket" "golang.org/x/sys/unix" ) func marshalPacketInfo(b []byte, cm ControlMessage) []byte { m := socket.ControlMessage(b) m.MarshalHeader(iana.ProtocolIP, unix.IP_PKTINFO, sizeofInetPktinfo) if cm != nil { pi := (inetPktinfo)(unsafe.Pointer(&m.Data(sizeofInetPktinfo)[0])) if ip := cm.Src.To4(); ip != nil { copy(pi.Spec_dst[:], ip) } if cm.IfIndex > 0 { pi.setIfindex(cm.IfIndex) } } return m.Next(sizeofInetPktinfo) } func parsePacketInfo(cm ControlMessage, b []byte) { pi := (inetPktinfo)(unsafe.Pointer(&b[0])) cm.IfIndex = int(pi.Ifindex) if len(cm.Dst) < net.IPv4len { cm.Dst = make(net.IP, net.IPv4len) } copy(cm.Dst, pi.Addr[:]) }	980 B	2025-05-25 12:27
📄 control_stub.go // Copyright 2012 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 ipv4 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 ipv4_test import ( "testing" "golang.org/x/net/ipv4" ) func TestControlMessageParseWithFuzz(t *testing.T) { var cm ipv4.ControlMessage for _, fuzz := range []string{ "\f\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00", "\f\x00\x00\x00\x00\x00\x00\x00\x1a\x00\x00\x00", } { cm.Parse([]byte(fuzz)) } }	480 B	2025-05-25 12:27
📄 control_unix.go // Copyright 2012 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 ipv4 import ( "unsafe" "golang.org/x/net/internal/iana" "golang.org/x/net/internal/socket" "golang.org/x/sys/unix" ) func setControlMessage(c socket.Conn, opt rawOpt, cf ControlFlags, on bool) error { opt.Lock() defer opt.Unlock() if so, ok := sockOpts[ssoReceiveTTL]; ok && cf&FlagTTL != 0 { if err := so.SetInt(c, boolint(on)); err != nil { return err } if on { opt.set(FlagTTL) } else { opt.clear(FlagTTL) } } if so, ok := sockOpts[ssoPacketInfo]; ok { if cf&(FlagSrc\|FlagDst\|FlagInterface) != 0 { if err := so.SetInt(c, boolint(on)); err != nil { return err } if on { opt.set(cf & (FlagSrc \| FlagDst \| FlagInterface)) } else { opt.clear(cf & (FlagSrc \| FlagDst \| FlagInterface)) } } } else { if so, ok := sockOpts[ssoReceiveDst]; ok && cf&FlagDst != 0 { if err := so.SetInt(c, boolint(on)); err != nil { return err } if on { opt.set(FlagDst) } else { opt.clear(FlagDst) } } if so, ok := sockOpts[ssoReceiveInterface]; ok && cf&FlagInterface != 0 { if err := so.SetInt(c, boolint(on)); err != nil { return err } if on { opt.set(FlagInterface) } else { opt.clear(FlagInterface) } } } return nil } func marshalTTL(b []byte, cm ControlMessage) []byte { m := socket.ControlMessage(b) m.MarshalHeader(iana.ProtocolIP, unix.IP_RECVTTL, 1) return m.Next(1) } func parseTTL(cm ControlMessage, b []byte) { cm.TTL = int((byte)(unsafe.Pointer(&b[:1][0]))) }	1.71 KB	2025-05-25 12:27
📄 control_windows.go // Copyright 2012 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 ipv4 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
📄 control_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 ipv4 import ( "net" "unsafe" "golang.org/x/net/internal/iana" "golang.org/x/net/internal/socket" "golang.org/x/sys/unix" ) func marshalPacketInfo(b []byte, cm ControlMessage) []byte { m := socket.ControlMessage(b) m.MarshalHeader(iana.ProtocolIP, unix.IP_PKTINFO, sizeofInetPktinfo) if cm != nil { pi := (inetPktinfo)(unsafe.Pointer(&m.Data(sizeofInetPktinfo)[0])) if ip := cm.Src.To4(); ip != nil { copy(pi.Addr[:], ip) } if cm.IfIndex > 0 { pi.setIfindex(cm.IfIndex) } } return m.Next(sizeofInetPktinfo) } func parsePacketInfo(cm ControlMessage, b []byte) { pi := (inetPktinfo)(unsafe.Pointer(&b[0])) cm.IfIndex = int(pi.Ifindex) if len(cm.Dst) < net.IPv4len { cm.Dst = make(net.IP, net.IPv4len) } copy(cm.Dst, pi.Addr[:]) } func setControlMessage(c socket.Conn, opt rawOpt, cf ControlFlags, on bool) error { opt.Lock() defer opt.Unlock() if so, ok := sockOpts[ssoReceiveTTL]; ok && cf&FlagTTL != 0 { if err := so.SetInt(c, boolint(on)); err != nil { return err } if on { opt.set(FlagTTL) } else { opt.clear(FlagTTL) } } if so, ok := sockOpts[ssoPacketInfo]; ok { if cf&(FlagSrc\|FlagDst\|FlagInterface) != 0 { if err := so.SetInt(c, boolint(on)); err != nil { return err } if on { opt.set(cf & (FlagSrc \| FlagDst \| FlagInterface)) } else { opt.clear(cf & (FlagSrc \| FlagDst \| FlagInterface)) } } } else { if so, ok := sockOpts[ssoReceiveDst]; ok && cf&FlagDst != 0 { if err := so.SetInt(c, boolint(on)); err != nil { return err } if on { opt.set(FlagDst) } else { opt.clear(FlagDst) } } if so, ok := sockOpts[ssoReceiveInterface]; ok && cf&FlagInterface != 0 { if err := so.SetInt(c, boolint(on)); err != nil { return err } if on { opt.set(FlagInterface) } else { opt.clear(FlagInterface) } } } return nil }	1.99 KB	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_in_addr [4]byte /* in_addr / package ipv4 / #include <netinet/in.h> */ import "C" const ( sizeofIPMreq = C.sizeof_struct_ip_mreq ) type ipMreq C.struct_ip_mreq	368 B	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_in_addr [4]byte /* in_addr / package ipv4 / #include <sys/socket.h> #include <netinet/in.h> */ import "C" const ( sizeofSockaddrStorage = C.sizeof_struct_sockaddr_storage sizeofSockaddrInet = C.sizeof_struct_sockaddr_in sizeofInetPktinfo = C.sizeof_struct_in_pktinfo sizeofIPMreq = C.sizeof_struct_ip_mreq sizeofIPMreqSource = C.sizeof_struct_ip_mreq_source sizeofGroupReq = C.sizeof_struct_group_req sizeofGroupSourceReq = C.sizeof_struct_group_source_req ) type sockaddrStorage C.struct_sockaddr_storage type sockaddrInet C.struct_sockaddr_in type inetPktinfo C.struct_in_pktinfo type ipMreq C.struct_ip_mreq type ipMreqSource C.struct_ip_mreq_source type groupReq C.struct_group_req type groupSourceReq C.struct_group_source_req	977 B	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_in_addr [4]byte /* in_addr / package ipv4 / #include <netinet/in.h> */ import "C" const ( sizeofIPMreq = C.sizeof_struct_ip_mreq ) type ipMreq C.struct_ip_mreq	368 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_in_addr [4]byte /* in_addr / package ipv4 / #include <sys/socket.h> #include <netinet/in.h> */ import "C" const ( sizeofSockaddrStorage = C.sizeof_struct_sockaddr_storage sizeofSockaddrInet = C.sizeof_struct_sockaddr_in sizeofIPMreq = C.sizeof_struct_ip_mreq sizeofIPMreqSource = C.sizeof_struct_ip_mreq_source sizeofGroupReq = C.sizeof_struct_group_req sizeofGroupSourceReq = C.sizeof_struct_group_source_req ) type sockaddrStorage C.struct_sockaddr_storage type sockaddrInet C.struct_sockaddr_in type ipMreq C.struct_ip_mreq type ipMreqSource C.struct_ip_mreq_source type groupReq C.struct_group_req type groupSourceReq C.struct_group_source_req	887 B	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_in_addr [4]byte /* in_addr / package ipv4 / #include <time.h> #include <linux/errqueue.h> #include <linux/icmp.h> #include <linux/in.h> #include <linux/filter.h> #include <sys/socket.h> */ import "C" const ( sizeofKernelSockaddrStorage = C.sizeof_struct___kernel_sockaddr_storage sizeofSockaddrInet = C.sizeof_struct_sockaddr_in sizeofInetPktinfo = C.sizeof_struct_in_pktinfo sizeofSockExtendedErr = C.sizeof_struct_sock_extended_err sizeofIPMreq = C.sizeof_struct_ip_mreq sizeofIPMreqSource = C.sizeof_struct_ip_mreq_source sizeofGroupReq = C.sizeof_struct_group_req sizeofGroupSourceReq = C.sizeof_struct_group_source_req sizeofICMPFilter = C.sizeof_struct_icmp_filter ) type kernelSockaddrStorage C.struct___kernel_sockaddr_storage type sockaddrInet C.struct_sockaddr_in type inetPktinfo C.struct_in_pktinfo type sockExtendedErr C.struct_sock_extended_err type ipMreq C.struct_ip_mreq type ipMreqSource C.struct_ip_mreq_source type groupReq C.struct_group_req type groupSourceReq C.struct_group_source_req type icmpFilter C.struct_icmp_filter	1.28 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_in_addr [4]byte /* in_addr / package ipv4 / #include <netinet/in.h> */ import "C" const ( sizeofIPMreq = C.sizeof_struct_ip_mreq ) type ipMreq C.struct_ip_mreq	368 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_in_addr [4]byte /* in_addr / package ipv4 / #include <netinet/in.h> */ import "C" const ( sizeofIPMreq = C.sizeof_struct_ip_mreq ) type ipMreq C.struct_ip_mreq	368 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_in_addr [4]byte /* in_addr / package ipv4 / #include <sys/socket.h> #include <netinet/in.h> */ import "C" const ( sizeofSockaddrStorage = C.sizeof_struct_sockaddr_storage sizeofSockaddrInet = C.sizeof_struct_sockaddr_in sizeofInetPktinfo = C.sizeof_struct_in_pktinfo sizeofIPMreq = C.sizeof_struct_ip_mreq sizeofIPMreqSource = C.sizeof_struct_ip_mreq_source sizeofGroupReq = C.sizeof_struct_group_req sizeofGroupSourceReq = C.sizeof_struct_group_source_req ) type sockaddrStorage C.struct_sockaddr_storage type sockaddrInet C.struct_sockaddr_in type inetPktinfo C.struct_in_pktinfo type ipMreq C.struct_ip_mreq type ipMreqSource C.struct_ip_mreq_source type groupReq C.struct_group_req type groupSourceReq C.struct_group_source_req	977 B	2025-05-25 12:27
📄 dgramopt.go // Copyright 2012 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 ipv4 import ( "net" "golang.org/x/net/bpf" ) // MulticastTTL returns the time-to-live field value for outgoing // multicast packets. func (c dgramOpt) MulticastTTL() (int, error) { if !c.ok() { return 0, errInvalidConn } so, ok := sockOpts[ssoMulticastTTL] if !ok { return 0, errNotImplemented } return so.GetInt(c.Conn) } // SetMulticastTTL sets the time-to-live field value for future // outgoing multicast packets. func (c dgramOpt) SetMulticastTTL(ttl int) error { if !c.ok() { return errInvalidConn } so, ok := sockOpts[ssoMulticastTTL] if !ok { return errNotImplemented } return so.SetInt(c.Conn, ttl) } // 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 := netAddrToIP4(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 := netAddrToIP4(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 := netAddrToIP4(group) if grp == nil { return errMissingAddress } src := netAddrToIP4(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 := netAddrToIP4(group) if grp == nil { return errMissingAddress } src := netAddrToIP4(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 := netAddrToIP4(group) if grp == nil { return errMissingAddress } src := netAddrToIP4(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 := netAddrToIP4(group) if grp == nil { return errMissingAddress } src := netAddrToIP4(source) if src == nil { return errMissingAddress } return so.setSourceGroup(c.Conn, ifi, grp, src) } // ICMPFilter returns an ICMP filter. // Currently only Linux supports this. 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. // Currently only Linux supports this. 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) }	6.61 KB	2025-05-25 12:27
📄 doc.go // Copyright 2012 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 ipv4 implements IP-level socket options for the Internet // Protocol version 4. // // The package provides IP-level socket options that allow // manipulation of IPv4 facilities. // // The IPv4 protocol and basic host requirements for IPv4 are defined // in RFC 791 and RFC 1122. // Host extensions for multicasting and socket interface extensions // for multicast source filters are defined in RFC 1112 and RFC 3678. // IGMPv1, IGMPv2 and IGMPv3 are defined in RFC 1112, RFC 2236 and RFC // 3376. // Source-specific multicast is defined in RFC 4607. // // # Unicasting // // The options for unicasting are available for net.TCPConn, // net.UDPConn and net.IPConn which are created as network connections // that use the IPv4 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 type-of-service field on the // IPv4 header for each packet. // // ln, err := net.Listen("tcp4", "0.0.0.0: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 := ipv4.NewConn(c).SetTOS(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 // IPv4 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.IPv4(224, 0, 0, 250) // // First, an application listens to an appropriate address with an // appropriate service port. // // c, err := net.ListenPacket("udp4", "0.0.0.0: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 IPv4 and Ethernet. // // p := ipv4.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(ipv4.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, cm, src, err := p.ReadFrom(b) // if err != nil { // // error handling // } // if cm.Dst.IsMulticast() { // if cm.Dst.Equal(group) { // // joined group, do something // } else { // // unknown group, discard // continue // } // } // // The application can also send both unicast and multicast packets. // // p.SetTOS(0x0) // p.SetTTL(16) // if _, err := p.WriteTo(data, nil, src); err != nil { // // error handling // } // dst := &net.UDPAddr{IP: group, Port: 1024} // for _, ifi := range []*net.Interface{en0, en1} { // if err := p.SetMulticastInterface(ifi); err != nil { // // error handling // } // p.SetMulticastTTL(2) // if _, err := p.WriteTo(data, nil, dst); err != nil { // // error handling // } // } // } // // # More multicasting // // An application that uses PacketConn or RawConn 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("udp4", "0.0.0.0:1024") // if err != nil { // // error handling // } // defer c.Close() // p := ipv4.NewPacketConn(c) // if err := p.JoinGroup(en0, &net.UDPAddr{IP: net.IPv4(224, 0, 0, 248)}); err != nil { // // error handling // } // if err := p.JoinGroup(en0, &net.UDPAddr{IP: net.IPv4(224, 0, 0, 249)}); err != nil { // // error handling // } // if err := p.JoinGroup(en1, &net.UDPAddr{IP: net.IPv4(224, 0, 0, 249)}); 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("udp4", "224.0.0.0:1024") // if err != nil { // // error handling // } // defer c1.Close() // c2, err := net.ListenPacket("udp4", "224.0.0.0:1024") // if err != nil { // // error handling // } // defer c2.Close() // p1 := ipv4.NewPacketConn(c1) // if err := p1.JoinGroup(en0, &net.UDPAddr{IP: net.IPv4(224, 0, 0, 248)}); err != nil { // // error handling // } // p2 := ipv4.NewPacketConn(c2) // if err := p2.JoinGroup(en0, &net.UDPAddr{IP: net.IPv4(224, 0, 0, 248)}); 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.IPv4(224, 0, 0, 248)}); err != nil { // // error handling // } // if err := p.JoinGroup(en0, &net.UDPAddr{IP: net.IPv4(224, 0, 0, 250)}); err != nil { // // error handling // } // // # Source-specific multicasting // // An application that uses PacketConn or RawConn on IGMPv3 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.IPv4(232, 7, 8, 9)} // ssmsource := net.UDPAddr{IP: net.IPv4(192, 168, 0, 1)} // 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.IPv4(192, 168, 0, 254)} // 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 IGMPv3 unsupported platform uses // JoinSourceSpecificGroup and LeaveSourceSpecificGroup. // In general the platform tries to fall back to conversations using // IGMPv1 or IGMPv2 and starts to listen to multicast traffic. // In the fallback case, ExcludeSourceSpecificGroup and // IncludeSourceSpecificGroup may return an error. package ipv4 // import "golang.org/x/net/ipv4" // BUG(mikio): This package is not implemented on JS, NaCl and Plan 9.	7.77 KB	2025-05-25 12:27
📄 endpoint.go // Copyright 2012 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 ipv4 import ( "net" "time" "golang.org/x/net/internal/socket" ) // BUG(mikio): On Windows, the JoinSourceSpecificGroup, // LeaveSourceSpecificGroup, ExcludeSourceSpecificGroup and // IncludeSourceSpecificGroup methods of PacketConn and RawConn are // not implemented. // A Conn represents a network endpoint that uses the IPv4 transport. // It is used to control basic IP-level socket options such as TOS and // TTL. type Conn struct { genericOpt } type genericOpt struct { socket.Conn } func (c genericOpt) ok() bool { return c != nil && c.Conn != 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 the // IPv4 transport. It is used to control several IP-level socket // options including multicasting. It also provides datagram based // network I/O methods specific to the IPv4 and higher layer protocols // such as UDP. type PacketConn struct { genericOpt dgramOpt payloadHandler } type dgramOpt struct { socket.Conn } func (c dgramOpt) ok() bool { return c != nil && c.Conn != nil } // SetControlMessage sets the per packet 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.PacketConn.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.PacketConn.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.PacketConn.SetWriteDeadline(t) } // Close closes the endpoint. func (c PacketConn) Close() error { if !c.payloadHandler.ok() { return errInvalidConn } return c.payloadHandler.PacketConn.Close() } // NewPacketConn returns a new PacketConn using c as its underlying // transport. func NewPacketConn(c net.PacketConn) PacketConn { cc, _ := socket.NewConn(c.(net.Conn)) p := &PacketConn{ genericOpt: genericOpt{Conn: cc}, dgramOpt: dgramOpt{Conn: cc}, payloadHandler: payloadHandler{PacketConn: c, Conn: cc}, } return p } // A RawConn represents a packet network endpoint that uses the IPv4 // transport. It is used to control several IP-level socket options // including IPv4 header manipulation. It also provides datagram // based network I/O methods specific to the IPv4 and higher layer // protocols that handle IPv4 datagram directly such as OSPF, GRE. type RawConn struct { genericOpt dgramOpt packetHandler } // SetControlMessage sets the per packet IP-level socket options. func (c RawConn) SetControlMessage(cf ControlFlags, on bool) error { if !c.packetHandler.ok() { return errInvalidConn } return setControlMessage(c.dgramOpt.Conn, &c.packetHandler.rawOpt, cf, on) } // SetDeadline sets the read and write deadlines associated with the // endpoint. func (c RawConn) SetDeadline(t time.Time) error { if !c.packetHandler.ok() { return errInvalidConn } return c.packetHandler.IPConn.SetDeadline(t) } // SetReadDeadline sets the read deadline associated with the // endpoint. func (c RawConn) SetReadDeadline(t time.Time) error { if !c.packetHandler.ok() { return errInvalidConn } return c.packetHandler.IPConn.SetReadDeadline(t) } // SetWriteDeadline sets the write deadline associated with the // endpoint. func (c RawConn) SetWriteDeadline(t time.Time) error { if !c.packetHandler.ok() { return errInvalidConn } return c.packetHandler.IPConn.SetWriteDeadline(t) } // Close closes the endpoint. func (c RawConn) Close() error { if !c.packetHandler.ok() { return errInvalidConn } return c.packetHandler.IPConn.Close() } // NewRawConn returns a new RawConn using c as its underlying // transport. func NewRawConn(c net.PacketConn) (RawConn, error) { cc, err := socket.NewConn(c.(net.Conn)) if err != nil { return nil, err } r := &RawConn{ genericOpt: genericOpt{Conn: cc}, dgramOpt: dgramOpt{Conn: cc}, packetHandler: packetHandler{IPConn: c.(net.IPConn), Conn: cc}, } so, ok := sockOpts[ssoHeaderPrepend] if !ok { return nil, errNotImplemented } if err := so.SetInt(r.dgramOpt.Conn, boolint(true)); err != nil { return nil, err } return r, nil }	4.87 KB	2025-05-25 12:27
📄 errors_other_test.go // Copyright 2022 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 ipv4_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 2022 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 ipv4_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 2012 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 ipv4_test import ( "fmt" "log" "net" "os" "runtime" "time" "golang.org/x/net/icmp" "golang.org/x/net/ipv4" ) func ExampleConn_markingTCP() { ln, err := net.Listen("tcp", "0.0.0.0: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.To4() != nil { p := ipv4.NewConn(c) if err := p.SetTOS(0x28); err != nil { // DSCP AF11 log.Fatal(err) } if err := p.SetTTL(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("udp4", "0.0.0.0:5353") // mDNS over UDP if err != nil { log.Fatal(err) } defer c.Close() p := ipv4.NewPacketConn(c) en0, err := net.InterfaceByName("en0") if err != nil { log.Fatal(err) } mDNSLinkLocal := net.UDPAddr{IP: net.IPv4(224, 0, 0, 251)} if err := p.JoinGroup(en0, &mDNSLinkLocal); err != nil { log.Fatal(err) } defer p.LeaveGroup(en0, &mDNSLinkLocal) if err := p.SetControlMessage(ipv4.FlagDst, true); err != nil { log.Fatal(err) } b := make([]byte, 1500) for { _, cm, peer, err := p.ReadFrom(b) if err != nil { log.Fatal(err) } if !cm.Dst.IsMulticast() \|\| !cm.Dst.Equal(mDNSLinkLocal.IP) { continue } answers := []byte("FAKE-MDNS-ANSWERS") // fake mDNS answers, you need to implement this if _, err := p.WriteTo(answers, nil, 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.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 A record found") } c, err := net.ListenPacket("ip4:1", "0.0.0.0") // ICMP for IPv4 if err != nil { log.Fatal(err) } defer c.Close() p := ipv4.NewPacketConn(c) if err := p.SetControlMessage(ipv4.FlagTTL\|ipv4.FlagSrc\|ipv4.FlagDst\|ipv4.FlagInterface, true); err != nil { log.Fatal(err) } wm := icmp.Message{ Type: ipv4.ICMPTypeEcho, Code: 0, Body: &icmp.Echo{ ID: os.Getpid() & 0xffff, Data: []byte("HELLO-R-U-THERE"), }, } 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) } if err := p.SetTTL(i); 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() if _, err := p.WriteTo(wb, nil, &dst); err != nil { log.Fatal(err) } if err := p.SetReadDeadline(time.Now().Add(3 * time.Second)); err != nil { log.Fatal(err) } n, cm, 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(1, 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, // ControlMessage.Dst, icmp.Echo.ID and icmp.Echo.Seq. switch rm.Type { case ipv4.ICMPTypeTimeExceeded: names, _ := net.LookupAddr(peer.String()) fmt.Printf("%d\t%v %+v %v\n\t%+v\n", i, peer, names, rtt, cm) case ipv4.ICMPTypeEchoReply: names, _ := net.LookupAddr(peer.String()) fmt.Printf("%d\t%v %+v %v\n\t%+v\n", i, peer, names, rtt, cm) return default: log.Printf("unknown ICMP message: %+v\n", rm) } } } func ExampleRawConn_advertisingOSPFHello() { c, err := net.ListenPacket("ip4:89", "0.0.0.0") // OSPF for IPv4 if err != nil { log.Fatal(err) } defer c.Close() r, err := ipv4.NewRawConn(c) if err != nil { log.Fatal(err) } en0, err := net.InterfaceByName("en0") if err != nil { log.Fatal(err) } allSPFRouters := net.IPAddr{IP: net.IPv4(224, 0, 0, 5)} if err := r.JoinGroup(en0, &allSPFRouters); err != nil { log.Fatal(err) } defer r.LeaveGroup(en0, &allSPFRouters) hello := make([]byte, 24) // fake hello data, you need to implement this ospf := make([]byte, 24) // fake ospf header, you need to implement this ospf[0] = 2 // version 2 ospf[1] = 1 // hello packet ospf = append(ospf, hello...) iph := &ipv4.Header{ Version: ipv4.Version, Len: ipv4.HeaderLen, TOS: 0xc0, // DSCP CS6 TotalLen: ipv4.HeaderLen + len(ospf), TTL: 1, Protocol: 89, Dst: allSPFRouters.IP.To4(), } var cm ipv4.ControlMessage switch runtime.GOOS { case "darwin", "ios", "linux": cm = &ipv4.ControlMessage{IfIndex: en0.Index} default: if err := r.SetMulticastInterface(en0); err != nil { log.Fatal(err) } } if err := r.WriteTo(iph, ospf, cm); err != nil { log.Fatal(err) } }	5.22 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 ipv4 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/icmp-parameters/icmp-parameters.xml", parseICMPv4Parameters, }, } 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 ipv4\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 parseICMPv4Parameters(w io.Writer, r io.Reader) error { dec := xml.NewDecoder(r) var icp icmpv4Parameters 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.Descr == "" { continue } fmt.Fprintf(w, "ICMPType%s ICMPType = %d", pr.Descr, pr.Value) fmt.Fprintf(w, "// %s\n", pr.OrigDescr) } 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.Descr == "" { continue } fmt.Fprintf(w, "%d: %q,\n", pr.Value, strings.ToLower(pr.OrigDescr)) } fmt.Fprintf(w, "}\n") return nil } type icmpv4Parameters 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"` Descr string `xml:"description"` } `xml:"record"` } `xml:"registry"` } type canonICMPv4ParamRecord struct { OrigDescr string Descr string Value int } func (icp *icmpv4Parameters) escape() []canonICMPv4ParamRecord { 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([]canonICMPv4ParamRecord, len(icp.Registries[id].Records)) sr := strings.NewReplacer( "Messages", "", "Message", "", "ICMP", "", "+", "P", "-", "", "/", "", ".", "", " ", "", ) for i, pr := range icp.Registries[id].Records { if strings.Contains(pr.Descr, "Reserved") \|\| strings.Contains(pr.Descr, "Unassigned") \|\| strings.Contains(pr.Descr, "Deprecated") \|\| strings.Contains(pr.Descr, "Experiment") \|\| strings.Contains(pr.Descr, "experiment") { continue } ss := strings.Split(pr.Descr, "\n") if len(ss) > 1 { prs[i].Descr = strings.Join(ss, " ") } else { prs[i].Descr = ss[0] } s := strings.TrimSpace(prs[i].Descr) prs[i].OrigDescr = s prs[i].Descr = sr.Replace(s) prs[i].Value, _ = strconv.Atoi(pr.Value) } return prs }	4.32 KB	2025-05-25 12:27
📄 genericopt.go // Copyright 2012 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 ipv4 // TOS returns the type-of-service field value for outgoing packets. func (c genericOpt) TOS() (int, error) { if !c.ok() { return 0, errInvalidConn } so, ok := sockOpts[ssoTOS] if !ok { return 0, errNotImplemented } return so.GetInt(c.Conn) } // SetTOS sets the type-of-service field value for future outgoing // packets. func (c genericOpt) SetTOS(tos int) error { if !c.ok() { return errInvalidConn } so, ok := sockOpts[ssoTOS] if !ok { return errNotImplemented } return so.SetInt(c.Conn, tos) } // TTL returns the time-to-live field value for outgoing packets. func (c genericOpt) TTL() (int, error) { if !c.ok() { return 0, errInvalidConn } so, ok := sockOpts[ssoTTL] if !ok { return 0, errNotImplemented } return so.GetInt(c.Conn) } // SetTTL sets the time-to-live field value for future outgoing // packets. func (c genericOpt) SetTTL(ttl int) error { if !c.ok() { return errInvalidConn } so, ok := sockOpts[ssoTTL] if !ok { return errNotImplemented } return so.SetInt(c.Conn, ttl) }	1.18 KB	2025-05-25 12:27
📄 header.go // Copyright 2012 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 ipv4 import ( "encoding/binary" "fmt" "net" "runtime" "golang.org/x/net/internal/socket" ) const ( Version = 4 // protocol version HeaderLen = 20 // header length without extension headers ) type HeaderFlags int const ( MoreFragments HeaderFlags = 1 << iota // more fragments flag DontFragment // don't fragment flag ) // A Header represents an IPv4 header. type Header struct { Version int // protocol version Len int // header length TOS int // type-of-service TotalLen int // packet total length ID int // identification Flags HeaderFlags // flags FragOff int // fragment offset TTL int // time-to-live Protocol int // next protocol Checksum int // checksum Src net.IP // source address Dst net.IP // destination address Options []byte // options, extension headers } func (h Header) String() string { if h == nil { return "<nil>" } return fmt.Sprintf("ver=%d hdrlen=%d tos=%#x totallen=%d id=%#x flags=%#x fragoff=%#x ttl=%d proto=%d cksum=%#x src=%v dst=%v", h.Version, h.Len, h.TOS, h.TotalLen, h.ID, h.Flags, h.FragOff, h.TTL, h.Protocol, h.Checksum, h.Src, h.Dst) } // Marshal returns the binary encoding of h. // // The returned slice is in the format used by a raw IP socket on the // local system. // This may differ from the wire format, depending on the system. func (h Header) Marshal() ([]byte, error) { if h == nil { return nil, errNilHeader } if h.Len < HeaderLen { return nil, errHeaderTooShort } hdrlen := HeaderLen + len(h.Options) b := make([]byte, hdrlen) b[0] = byte(Version<<4 \| (hdrlen >> 2 & 0x0f)) b[1] = byte(h.TOS) flagsAndFragOff := (h.FragOff & 0x1fff) \| int(h.Flags<<13) switch runtime.GOOS { case "darwin", "ios", "dragonfly", "netbsd": socket.NativeEndian.PutUint16(b[2:4], uint16(h.TotalLen)) socket.NativeEndian.PutUint16(b[6:8], uint16(flagsAndFragOff)) case "freebsd": if freebsdVersion < 1100000 { socket.NativeEndian.PutUint16(b[2:4], uint16(h.TotalLen)) socket.NativeEndian.PutUint16(b[6:8], uint16(flagsAndFragOff)) } else { binary.BigEndian.PutUint16(b[2:4], uint16(h.TotalLen)) binary.BigEndian.PutUint16(b[6:8], uint16(flagsAndFragOff)) } default: binary.BigEndian.PutUint16(b[2:4], uint16(h.TotalLen)) binary.BigEndian.PutUint16(b[6:8], uint16(flagsAndFragOff)) } binary.BigEndian.PutUint16(b[4:6], uint16(h.ID)) b[8] = byte(h.TTL) b[9] = byte(h.Protocol) binary.BigEndian.PutUint16(b[10:12], uint16(h.Checksum)) if ip := h.Src.To4(); ip != nil { copy(b[12:16], ip[:net.IPv4len]) } if ip := h.Dst.To4(); ip != nil { copy(b[16:20], ip[:net.IPv4len]) } else { return nil, errMissingAddress } if len(h.Options) > 0 { copy(b[HeaderLen:], h.Options) } return b, nil } // Parse parses b as an IPv4 header and stores the result in h. // // The provided b must be in the format used by a raw IP socket on the // local system. // This may differ from the wire format, depending on the system. func (h Header) Parse(b []byte) error { if h == nil \|\| b == nil { return errNilHeader } if len(b) < HeaderLen { return errHeaderTooShort } hdrlen := int(b[0]&0x0f) << 2 if len(b) < hdrlen { return errExtHeaderTooShort } h.Version = int(b[0] >> 4) h.Len = hdrlen h.TOS = int(b[1]) h.ID = int(binary.BigEndian.Uint16(b[4:6])) h.TTL = int(b[8]) h.Protocol = int(b[9]) h.Checksum = int(binary.BigEndian.Uint16(b[10:12])) h.Src = net.IPv4(b[12], b[13], b[14], b[15]) h.Dst = net.IPv4(b[16], b[17], b[18], b[19]) switch runtime.GOOS { case "darwin", "ios", "dragonfly", "netbsd": h.TotalLen = int(socket.NativeEndian.Uint16(b[2:4])) + hdrlen h.FragOff = int(socket.NativeEndian.Uint16(b[6:8])) case "freebsd": if freebsdVersion < 1100000 { h.TotalLen = int(socket.NativeEndian.Uint16(b[2:4])) if freebsdVersion < 1000000 { h.TotalLen += hdrlen } h.FragOff = int(socket.NativeEndian.Uint16(b[6:8])) } else { h.TotalLen = int(binary.BigEndian.Uint16(b[2:4])) h.FragOff = int(binary.BigEndian.Uint16(b[6:8])) } default: h.TotalLen = int(binary.BigEndian.Uint16(b[2:4])) h.FragOff = int(binary.BigEndian.Uint16(b[6:8])) } h.Flags = HeaderFlags(h.FragOff&0xe000) >> 13 h.FragOff = h.FragOff & 0x1fff optlen := hdrlen - HeaderLen if optlen > 0 && len(b) >= hdrlen { if cap(h.Options) < optlen { h.Options = make([]byte, optlen) } else { h.Options = h.Options[:optlen] } copy(h.Options, b[HeaderLen:hdrlen]) } return nil } // ParseHeader parses b as an IPv4 header. // // The provided b must be in the format used by a raw IP socket on the // local system. // This may differ from the wire format, depending on the system. func ParseHeader(b []byte) (Header, error) { h := new(Header) if err := h.Parse(b); err != nil { return nil, err } return h, nil }	4.97 KB	2025-05-25 12:27
📄 header_test.go // Copyright 2012 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 ipv4 import ( "bytes" "encoding/binary" "net" "reflect" "runtime" "strings" "testing" "golang.org/x/net/internal/socket" ) type headerTest struct { wireHeaderFromKernel []byte wireHeaderToKernel []byte wireHeaderFromTradBSDKernel []byte wireHeaderToTradBSDKernel []byte wireHeaderFromFreeBSD10Kernel []byte wireHeaderToFreeBSD10Kernel []byte Header } var headerLittleEndianTests = []headerTest{ // TODO(mikio): Add platform dependent wire header formats when // we support new platforms. { wireHeaderFromKernel: []byte{ 0x45, 0x01, 0xbe, 0xef, 0xca, 0xfe, 0x45, 0xdc, 0xff, 0x01, 0xde, 0xad, 172, 16, 254, 254, 192, 168, 0, 1, }, wireHeaderToKernel: []byte{ 0x45, 0x01, 0xbe, 0xef, 0xca, 0xfe, 0x45, 0xdc, 0xff, 0x01, 0xde, 0xad, 172, 16, 254, 254, 192, 168, 0, 1, }, wireHeaderFromTradBSDKernel: []byte{ 0x45, 0x01, 0xdb, 0xbe, 0xca, 0xfe, 0xdc, 0x45, 0xff, 0x01, 0xde, 0xad, 172, 16, 254, 254, 192, 168, 0, 1, }, wireHeaderToTradBSDKernel: []byte{ 0x45, 0x01, 0xef, 0xbe, 0xca, 0xfe, 0xdc, 0x45, 0xff, 0x01, 0xde, 0xad, 172, 16, 254, 254, 192, 168, 0, 1, }, wireHeaderFromFreeBSD10Kernel: []byte{ 0x45, 0x01, 0xef, 0xbe, 0xca, 0xfe, 0xdc, 0x45, 0xff, 0x01, 0xde, 0xad, 172, 16, 254, 254, 192, 168, 0, 1, }, wireHeaderToFreeBSD10Kernel: []byte{ 0x45, 0x01, 0xef, 0xbe, 0xca, 0xfe, 0xdc, 0x45, 0xff, 0x01, 0xde, 0xad, 172, 16, 254, 254, 192, 168, 0, 1, }, Header: &Header{ Version: Version, Len: HeaderLen, TOS: 1, TotalLen: 0xbeef, ID: 0xcafe, Flags: DontFragment, FragOff: 1500, TTL: 255, Protocol: 1, Checksum: 0xdead, Src: net.IPv4(172, 16, 254, 254), Dst: net.IPv4(192, 168, 0, 1), }, }, // with option headers { wireHeaderFromKernel: []byte{ 0x46, 0x01, 0xbe, 0xf3, 0xca, 0xfe, 0x45, 0xdc, 0xff, 0x01, 0xde, 0xad, 172, 16, 254, 254, 192, 168, 0, 1, 0xff, 0xfe, 0xfe, 0xff, }, wireHeaderToKernel: []byte{ 0x46, 0x01, 0xbe, 0xf3, 0xca, 0xfe, 0x45, 0xdc, 0xff, 0x01, 0xde, 0xad, 172, 16, 254, 254, 192, 168, 0, 1, 0xff, 0xfe, 0xfe, 0xff, }, wireHeaderFromTradBSDKernel: []byte{ 0x46, 0x01, 0xdb, 0xbe, 0xca, 0xfe, 0xdc, 0x45, 0xff, 0x01, 0xde, 0xad, 172, 16, 254, 254, 192, 168, 0, 1, 0xff, 0xfe, 0xfe, 0xff, }, wireHeaderToTradBSDKernel: []byte{ 0x46, 0x01, 0xf3, 0xbe, 0xca, 0xfe, 0xdc, 0x45, 0xff, 0x01, 0xde, 0xad, 172, 16, 254, 254, 192, 168, 0, 1, 0xff, 0xfe, 0xfe, 0xff, }, wireHeaderFromFreeBSD10Kernel: []byte{ 0x46, 0x01, 0xf3, 0xbe, 0xca, 0xfe, 0xdc, 0x45, 0xff, 0x01, 0xde, 0xad, 172, 16, 254, 254, 192, 168, 0, 1, 0xff, 0xfe, 0xfe, 0xff, }, wireHeaderToFreeBSD10Kernel: []byte{ 0x46, 0x01, 0xf3, 0xbe, 0xca, 0xfe, 0xdc, 0x45, 0xff, 0x01, 0xde, 0xad, 172, 16, 254, 254, 192, 168, 0, 1, 0xff, 0xfe, 0xfe, 0xff, }, Header: &Header{ Version: Version, Len: HeaderLen + 4, TOS: 1, TotalLen: 0xbef3, ID: 0xcafe, Flags: DontFragment, FragOff: 1500, TTL: 255, Protocol: 1, Checksum: 0xdead, Src: net.IPv4(172, 16, 254, 254), Dst: net.IPv4(192, 168, 0, 1), Options: []byte{0xff, 0xfe, 0xfe, 0xff}, }, }, } func TestMarshalHeader(t testing.T) { for i, tt := range []struct { h Header err error }{ {nil, errNilHeader}, {&Header{Len: HeaderLen - 1}, errHeaderTooShort}, } { if _, err := tt.h.Marshal(); err != tt.err { t.Errorf("#%d: got %v; want %v", i, err, tt.err) } } if socket.NativeEndian != binary.LittleEndian { t.Skip("no test for non-little endian machine yet") } for _, tt := range headerLittleEndianTests { b, err := tt.Header.Marshal() if err != nil { t.Fatal(err) } var wh []byte switch runtime.GOOS { case "darwin", "ios", "dragonfly", "netbsd": wh = tt.wireHeaderToTradBSDKernel case "freebsd": switch { case freebsdVersion < 1000000: wh = tt.wireHeaderToTradBSDKernel case 1000000 <= freebsdVersion && freebsdVersion < 1100000: wh = tt.wireHeaderToFreeBSD10Kernel default: wh = tt.wireHeaderToKernel } default: wh = tt.wireHeaderToKernel } if !bytes.Equal(b, wh) { t.Fatalf("got %#v; want %#v", b, wh) } } } func TestParseHeader(t testing.T) { for i, tt := range []struct { h *Header wh []byte err error }{ {nil, nil, errNilHeader}, {&Header{}, nil, errNilHeader}, {&Header{}, make([]byte, HeaderLen-1), errHeaderTooShort}, {&Header{}, []byte{ 0x46, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, }, errExtHeaderTooShort}, } { if err := tt.h.Parse(tt.wh); err != tt.err { t.Fatalf("#%d: got %v; want %v", i, err, tt.err) } } if socket.NativeEndian != binary.LittleEndian { t.Skip("no test for big endian machine yet") } for _, tt := range headerLittleEndianTests { var wh []byte switch runtime.GOOS { case "darwin", "ios", "dragonfly", "netbsd": wh = tt.wireHeaderFromTradBSDKernel case "freebsd": switch { case freebsdVersion < 1000000: wh = tt.wireHeaderFromTradBSDKernel case 1000000 <= freebsdVersion && freebsdVersion < 1100000: wh = tt.wireHeaderFromFreeBSD10Kernel default: wh = tt.wireHeaderFromKernel } default: wh = tt.wireHeaderFromKernel } h, err := ParseHeader(wh) if err != nil { t.Fatal(err) } if err := h.Parse(wh); err != nil { t.Fatal(err) } if !reflect.DeepEqual(h, tt.Header) { t.Fatalf("got %#v; want %#v", h, tt.Header) } s := h.String() if strings.Contains(s, ",") { t.Fatalf("should be space-separated values: %s", s) } } }	5.84 KB	2025-05-25 12:27
📄 helper.go // Copyright 2012 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 ipv4 import ( "errors" "net" "runtime" "golang.org/x/net/internal/socket" ) var ( errInvalidConn = errors.New("invalid connection") errMissingAddress = errors.New("missing address") errNilHeader = errors.New("nil header") errHeaderTooShort = errors.New("header too short") errExtHeaderTooShort = errors.New("extension header too short") errInvalidConnType = errors.New("invalid conn type") errNotImplemented = errors.New("not implemented on " + runtime.GOOS + "/" + runtime.GOARCH) // See https://www.freebsd.org/doc/en/books/porters-handbook/versions.html. freebsdVersion uint32 compatFreeBSD32 bool // 386 emulation on amd64 ) // See golang.org/issue/30899. func adjustFreeBSD32(m socket.Message) { // FreeBSD 12.0-RELEASE is affected by https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=236737 if 1200086 <= freebsdVersion && freebsdVersion < 1201000 { l := (m.NN + 4 - 1) &^ (4 - 1) if m.NN < l && l <= len(m.OOB) { m.NN = l } } } func boolint(b bool) int { if b { return 1 } return 0 } func netAddrToIP4(a net.Addr) net.IP { switch v := a.(type) { case net.UDPAddr: if ip := v.IP.To4(); ip != nil { return ip } case net.IPAddr: if ip := v.IP.To4(); ip != 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.64 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 ipv4_test import ( "errors" "os" "syscall" "golang.org/x/net/ipv4" ) 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, ipv4.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 ipv4_test func protocolNotSupported(err error) bool { return false }	358 B	2025-05-25 12:27
📄 iana.go // go generate gen.go // Code generated by the command above; DO NOT EDIT. package ipv4 // Internet Control Message Protocol (ICMP) Parameters, Updated: 2018-02-26 const ( ICMPTypeEchoReply ICMPType = 0 // Echo Reply ICMPTypeDestinationUnreachable ICMPType = 3 // Destination Unreachable ICMPTypeRedirect ICMPType = 5 // Redirect ICMPTypeEcho ICMPType = 8 // Echo ICMPTypeRouterAdvertisement ICMPType = 9 // Router Advertisement ICMPTypeRouterSolicitation ICMPType = 10 // Router Solicitation ICMPTypeTimeExceeded ICMPType = 11 // Time Exceeded ICMPTypeParameterProblem ICMPType = 12 // Parameter Problem ICMPTypeTimestamp ICMPType = 13 // Timestamp ICMPTypeTimestampReply ICMPType = 14 // Timestamp Reply ICMPTypePhoturis ICMPType = 40 // Photuris ICMPTypeExtendedEchoRequest ICMPType = 42 // Extended Echo Request ICMPTypeExtendedEchoReply ICMPType = 43 // Extended Echo Reply ) // Internet Control Message Protocol (ICMP) Parameters, Updated: 2018-02-26 var icmpTypes = map[ICMPType]string{ 0: "echo reply", 3: "destination unreachable", 5: "redirect", 8: "echo", 9: "router advertisement", 10: "router solicitation", 11: "time exceeded", 12: "parameter problem", 13: "timestamp", 14: "timestamp reply", 40: "photuris", 42: "extended echo request", 43: "extended echo reply", }	1.4 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 ipv4 import "golang.org/x/net/internal/iana" // 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 ICMPv4 protocol number. func (typ ICMPType) Protocol() int { return iana.ProtocolICMP } // 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 and it works not // only for IPv6 but IPv4. 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 { icmpFilter } // 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.51 KB	2025-05-25 12:27
📄 icmp_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. package ipv4 func (f icmpFilter) accept(typ ICMPType) { f.Data &^= 1 << (uint32(typ) & 31) } func (f icmpFilter) block(typ ICMPType) { f.Data \|= 1 << (uint32(typ) & 31) } func (f icmpFilter) setAll(block bool) { if block { f.Data = 1<<32 - 1 } else { f.Data = 0 } } func (f icmpFilter) willBlock(typ ICMPType) bool { return f.Data&(1<<(uint32(typ)&31)) != 0 }	538 B	2025-05-25 12:27
📄 icmp_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 !linux package ipv4 const sizeofICMPFilter = 0x0 type icmpFilter struct { } func (f icmpFilter) accept(typ ICMPType) { } func (f icmpFilter) block(typ ICMPType) { } func (f icmpFilter) setAll(block bool) { } func (f icmpFilter) willBlock(typ ICMPType) bool { return false }	457 B	2025-05-25 12:27
📄 icmp_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 ipv4_test import ( "net" "reflect" "runtime" "testing" "golang.org/x/net/ipv4" "golang.org/x/net/nettest" ) var icmpStringTests = []struct { in ipv4.ICMPType out string }{ {ipv4.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 "linux": default: t.Skipf("not supported on %s", runtime.GOOS) } var f ipv4.ICMPFilter for _, toggle := range []bool{false, true} { f.SetAll(toggle) for _, typ := range []ipv4.ICMPType{ ipv4.ICMPTypeDestinationUnreachable, ipv4.ICMPTypeEchoReply, ipv4.ICMPTypeTimeExceeded, ipv4.ICMPTypeParameterProblem, } { f.Accept(typ) if f.WillBlock(typ) { t.Errorf("ipv4.ICMPFilter.Set(%v, false) failed", typ) } f.Block(typ) if !f.WillBlock(typ) { t.Errorf("ipv4.ICMPFilter.Set(%v, true) failed", typ) } } } } func TestSetICMPFilter(t *testing.T) { switch runtime.GOOS { case "linux": default: t.Skipf("not supported on %s", runtime.GOOS) } if !nettest.SupportsRawSocket() { t.Skipf("not supported on %s/%s", runtime.GOOS, runtime.GOARCH) } c, err := net.ListenPacket("ip4:icmp", "127.0.0.1") if err != nil { t.Fatal(err) } defer c.Close() p := ipv4.NewPacketConn(c) var f ipv4.ICMPFilter f.SetAll(true) f.Accept(ipv4.ICMPTypeEcho) f.Accept(ipv4.ICMPTypeEchoReply) if err := p.SetICMPFilter(&f); 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) } }	1.86 KB	2025-05-25 12:27
📄 multicast_test.go // Copyright 2012 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 ipv4_test import ( "bytes" "fmt" "net" "os" "runtime" "testing" "golang.org/x/net/icmp" "golang.org/x/net/internal/iana" "golang.org/x/net/ipv4" "golang.org/x/net/nettest" ) var packetConnReadWriteMulticastUDPTests = []struct { addr string grp, src net.IPAddr }{ {"224.0.0.0:0", &net.IPAddr{IP: net.IPv4(224, 0, 0, 254)}, nil}, // see RFC 4727 {"232.0.1.0:0", &net.IPAddr{IP: net.IPv4(232, 0, 1, 254)}, &net.IPAddr{IP: net.IPv4(127, 0, 0, 1)}}, // see RFC 5771 } func TestPacketConnReadWriteMulticastUDP(t testing.T) { switch runtime.GOOS { case "fuchsia", "hurd", "illumos", "js", "nacl", "plan9", "solaris", "wasip1", "windows", "zos": t.Skipf("not supported on %s", runtime.GOOS) } ifi, err := nettest.RoutedInterface("ip4", net.FlagUp\|net.FlagMulticast\|net.FlagLoopback) if err != nil { t.Skip(err) } for _, tt := range packetConnReadWriteMulticastUDPTests { t.Run(fmt.Sprintf("addr=%s/grp=%s/src=%s", tt.addr, tt.grp, tt.src), func(t testing.T) { c, err := net.ListenPacket("udp4", tt.addr) if err != nil { t.Fatal(err) } p := ipv4.NewPacketConn(c) defer func() { if err := p.Close(); err != nil { t.Error(err) } }() grp := p.LocalAddr().(net.UDPAddr) grp.IP = tt.grp.IP if tt.src == nil { if err := p.JoinGroup(ifi, &grp); err != nil { t.Fatal(err) } defer func() { if err := p.LeaveGroup(ifi, &grp); err != nil { t.Error(err) } }() } else { if err := p.JoinSourceSpecificGroup(ifi, &grp, tt.src); err != nil { switch runtime.GOOS { case "freebsd", "linux": default: // platforms that don't support IGMPv2/3 fail here t.Skipf("not supported on %s", runtime.GOOS) } t.Fatal(err) } defer func() { if err := p.LeaveSourceSpecificGroup(ifi, &grp, tt.src); err != nil { t.Error(err) } }() } 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) } cf := ipv4.FlagTTL \| ipv4.FlagDst \| ipv4.FlagInterface 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) } if err := p.SetMulticastTTL(i + 1); err != nil { t.Fatal(err) } } if n, err := p.WriteTo(wb, nil, &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 { 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.IPv4(224, 0, 0, 254)}, nil}, // see RFC 4727 {&net.IPAddr{IP: net.IPv4(232, 0, 1, 254)}, &net.IPAddr{IP: net.IPv4(127, 0, 0, 1)}}, // see RFC 5771 } func TestPacketConnReadWriteMulticastICMP(t testing.T) { if !nettest.SupportsRawSocket() { t.Skipf("not supported on %s/%s", runtime.GOOS, runtime.GOARCH) } ifi, err := nettest.RoutedInterface("ip4", net.FlagUp\|net.FlagMulticast\|net.FlagLoopback) // Unable to obtain loopback interface on z/OS, so instead we test on any multicast // capable interface. if runtime.GOOS == "zos" { ifi, err = nettest.RoutedInterface("ip4", net.FlagUp\|net.FlagMulticast) } if err != nil { t.Skip(err) } for _, tt := range packetConnReadWriteMulticastICMPTests { t.Run(fmt.Sprintf("grp=%s/src=%s", tt.grp, tt.src), func(t testing.T) { c, err := net.ListenPacket("ip4:icmp", "0.0.0.0") if err != nil { t.Fatal(err) } p := ipv4.NewPacketConn(c) defer func() { if err := p.Close(); err != nil { t.Error(err) } }() if tt.src == nil { if err := p.JoinGroup(ifi, tt.grp); err != nil { t.Fatal(err) } defer func() { if err := p.LeaveGroup(ifi, tt.grp); err != nil { t.Error(err) } }() } else { if err := p.JoinSourceSpecificGroup(ifi, tt.grp, tt.src); err != nil { switch runtime.GOOS { case "freebsd", "linux": default: // platforms that don't support IGMPv2/3 fail here t.Skipf("not supported on %s", runtime.GOOS) } t.Fatal(err) } defer func() { if err := p.LeaveSourceSpecificGroup(ifi, tt.grp, tt.src); err != nil { t.Error(err) } }() } 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) } cf := ipv4.FlagDst \| ipv4.FlagInterface if runtime.GOOS != "illumos" && runtime.GOOS != "solaris" { // Illumos and Solaris never allow modification of ICMP properties. cf \|= ipv4.FlagTTL } for i, toggle := range []bool{true, false, true} { wb, err := (&icmp.Message{ Type: ipv4.ICMPTypeEcho, Code: 0, Body: &icmp.Echo{ ID: os.Getpid() & 0xffff, Seq: i + 1, Data: []byte("HELLO-R-U-THERE"), }, }).Marshal(nil) 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) } if err := p.SetMulticastTTL(i + 1); err != nil { t.Fatal(err) } if n, err := p.WriteTo(wb, nil, 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 { t.Fatal(err) } else { m, err := icmp.ParseMessage(iana.ProtocolICMP, rb[:n]) if err != nil { t.Fatal(err) } switch { case m.Type == ipv4.ICMPTypeEchoReply && m.Code == 0: // net.inet.icmp.bmcastecho=1 case m.Type == ipv4.ICMPTypeEcho && m.Code == 0: // net.inet.icmp.bmcastecho=0 default: t.Fatalf("got type=%v, code=%v; want type=%v, code=%v", m.Type, m.Code, ipv4.ICMPTypeEchoReply, 0) } } } }) } } var rawConnReadWriteMulticastICMPTests = []struct { grp, src net.IPAddr }{ {&net.IPAddr{IP: net.IPv4(224, 0, 0, 254)}, nil}, // see RFC 4727 {&net.IPAddr{IP: net.IPv4(232, 0, 1, 254)}, &net.IPAddr{IP: net.IPv4(127, 0, 0, 1)}}, // see RFC 5771 } func TestRawConnReadWriteMulticastICMP(t testing.T) { if testing.Short() { t.Skip("to avoid external network") } if !nettest.SupportsRawSocket() { t.Skipf("not supported on %s/%s", runtime.GOOS, runtime.GOARCH) } ifi, err := nettest.RoutedInterface("ip4", net.FlagUp\|net.FlagMulticast\|net.FlagLoopback) if err != nil { t.Skipf("not available on %s", runtime.GOOS) } for _, tt := range rawConnReadWriteMulticastICMPTests { c, err := net.ListenPacket("ip4:icmp", "0.0.0.0") if err != nil { t.Fatal(err) } defer c.Close() r, err := ipv4.NewRawConn(c) if err != nil { t.Fatal(err) } defer r.Close() if tt.src == nil { if err := r.JoinGroup(ifi, tt.grp); err != nil { t.Fatal(err) } defer r.LeaveGroup(ifi, tt.grp) } else { if err := r.JoinSourceSpecificGroup(ifi, tt.grp, tt.src); err != nil { switch runtime.GOOS { case "freebsd", "linux": default: // platforms that don't support IGMPv2/3 fail here t.Logf("not supported on %s", runtime.GOOS) continue } t.Fatal(err) } defer r.LeaveSourceSpecificGroup(ifi, tt.grp, tt.src) } if err := r.SetMulticastInterface(ifi); err != nil { t.Fatal(err) } if _, err := r.MulticastInterface(); err != nil { t.Fatal(err) } if err := r.SetMulticastLoopback(true); err != nil { t.Fatal(err) } if _, err := r.MulticastLoopback(); err != nil { t.Fatal(err) } cf := ipv4.FlagTTL \| ipv4.FlagDst \| ipv4.FlagInterface for i, toggle := range []bool{true, false, true} { wb, err := (&icmp.Message{ Type: ipv4.ICMPTypeEcho, Code: 0, Body: &icmp.Echo{ ID: os.Getpid() & 0xffff, Seq: i + 1, Data: []byte("HELLO-R-U-THERE"), }, }).Marshal(nil) if err != nil { t.Fatal(err) } wh := &ipv4.Header{ Version: ipv4.Version, Len: ipv4.HeaderLen, TOS: i + 1, TotalLen: ipv4.HeaderLen + len(wb), Protocol: 1, Dst: tt.grp.IP, } if err := r.SetControlMessage(cf, toggle); err != nil { if protocolNotSupported(err) { t.Logf("not supported on %s", runtime.GOOS) continue } t.Fatal(err) } r.SetMulticastTTL(i + 1) if err := r.WriteTo(wh, wb, nil); err != nil { t.Fatal(err) } rb := make([]byte, ipv4.HeaderLen+128) if rh, b, _, err := r.ReadFrom(rb); err != nil { t.Fatal(err) } else { m, err := icmp.ParseMessage(iana.ProtocolICMP, b) if err != nil { t.Fatal(err) } switch { case (rh.Dst.IsLoopback() \|\| rh.Dst.IsLinkLocalUnicast() \|\| rh.Dst.IsGlobalUnicast()) && m.Type == ipv4.ICMPTypeEchoReply && m.Code == 0: // net.inet.icmp.bmcastecho=1 case rh.Dst.IsMulticast() && m.Type == ipv4.ICMPTypeEcho && m.Code == 0: // net.inet.icmp.bmcastecho=0 default: t.Fatalf("got type=%v, code=%v; want type=%v, code=%v", m.Type, m.Code, ipv4.ICMPTypeEchoReply, 0) } } } } }	9.56 KB	2025-05-25 12:27
📄 multicastlistener_test.go // Copyright 2012 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 ipv4_test import ( "net" "runtime" "testing" "golang.org/x/net/ipv4" "golang.org/x/net/nettest" ) var udpMultipleGroupListenerTests = []net.Addr{ &net.UDPAddr{IP: net.IPv4(224, 0, 0, 249)}, // see RFC 4727 &net.UDPAddr{IP: net.IPv4(224, 0, 0, 250)}, &net.UDPAddr{IP: net.IPv4(224, 0, 0, 254)}, } func TestUDPSinglePacketConnWithMultipleGroupListeners(t testing.T) { switch runtime.GOOS { case "fuchsia", "hurd", "js", "nacl", "plan9", "wasip1", "windows", "zos": t.Skipf("not supported on %s", runtime.GOOS) } if testing.Short() { t.Skip("to avoid external network") } for _, gaddr := range udpMultipleGroupListenerTests { c, err := net.ListenPacket("udp4", "0.0.0.0:0") // wildcard address with no reusable port if err != nil { t.Fatal(err) } defer c.Close() p := ipv4.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("ip4", &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 testing.Short() { t.Skip("to avoid external network") } for _, gaddr := range udpMultipleGroupListenerTests { c1, err := net.ListenPacket("udp4", "224.0.0.0: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("udp4", net.JoinHostPort("224.0.0.0", port)) // wildcard address with reusable port if err != nil { t.Fatal(err) } defer c2.Close() var ps [2]ipv4.PacketConn ps[0] = ipv4.NewPacketConn(c1) ps[1] = ipv4.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("ip4", &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", "zos": t.Skipf("not supported on %s", runtime.GOOS) } if testing.Short() { t.Skip("to avoid external network") } gaddr := net.IPAddr{IP: net.IPv4(224, 0, 0, 254)} // see RFC 4727 type ml struct { c ipv4.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("ip4", &ifi) if err != nil { continue } c, err := net.ListenPacket("udp4", net.JoinHostPort(ip.String(), 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 := ipv4.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 TestIPSingleRawConnWithSingleGroupListener(t testing.T) { if testing.Short() { t.Skip("to avoid external network") } if !nettest.SupportsRawSocket() { t.Skipf("not supported on %s/%s", runtime.GOOS, runtime.GOARCH) } c, err := net.ListenPacket("ip4:icmp", "0.0.0.0") // wildcard address if err != nil { t.Fatal(err) } defer c.Close() r, err := ipv4.NewRawConn(c) if err != nil { t.Fatal(err) } gaddr := net.IPAddr{IP: net.IPv4(224, 0, 0, 254)} // 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("ip4", &ifi); err != nil { continue } if err := r.JoinGroup(&ifi, &gaddr); err != nil { t.Fatal(err) } mift = append(mift, &ift[i]) } for _, ifi := range mift { if err := r.LeaveGroup(ifi, &gaddr); err != nil { t.Fatal(err) } } } func TestIPPerInterfaceSingleRawConnWithSingleGroupListener(t testing.T) { if testing.Short() { t.Skip("to avoid external network") } if !nettest.SupportsRawSocket() { t.Skipf("not supported on %s/%s", runtime.GOOS, runtime.GOARCH) } gaddr := net.IPAddr{IP: net.IPv4(224, 0, 0, 254)} // see RFC 4727 type ml struct { c ipv4.RawConn 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("ip4", &ifi) if err != nil { continue } c, err := net.ListenPacket("ip4:253", ip.String()) // unicast address if err != nil { t.Fatal(err) } defer c.Close() r, err := ipv4.NewRawConn(c) if err != nil { t.Fatal(err) } if err := r.JoinGroup(&ifi, &gaddr); err != nil { t.Fatal(err) } mlt = append(mlt, &ml{r, &ift[i]}) } for _, m := range mlt { if err := m.c.LeaveGroup(m.ifi, &gaddr); err != nil { t.Fatal(err) } } }	5.91 KB	2025-05-25 12:27
📄 multicastsockopt_test.go // Copyright 2012 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 ipv4_test import ( "net" "runtime" "testing" "golang.org/x/net/ipv4" "golang.org/x/net/nettest" ) var packetConnMulticastSocketOptionTests = []struct { net, proto, addr string grp, src net.Addr }{ {"udp4", "", "224.0.0.0:0", &net.UDPAddr{IP: net.IPv4(224, 0, 0, 249)}, nil}, // see RFC 4727 {"ip4", ":icmp", "0.0.0.0", &net.IPAddr{IP: net.IPv4(224, 0, 0, 250)}, nil}, // see RFC 4727 {"udp4", "", "232.0.0.0:0", &net.UDPAddr{IP: net.IPv4(232, 0, 1, 249)}, &net.UDPAddr{IP: net.IPv4(127, 0, 0, 1)}}, // see RFC 5771 {"ip4", ":icmp", "0.0.0.0", &net.IPAddr{IP: net.IPv4(232, 0, 1, 250)}, &net.UDPAddr{IP: net.IPv4(127, 0, 0, 1)}}, // see RFC 5771 } func TestPacketConnMulticastSocketOptions(t testing.T) { switch runtime.GOOS { case "fuchsia", "hurd", "js", "nacl", "plan9", "wasip1", "zos": t.Skipf("not supported on %s", runtime.GOOS) } ifi, err := nettest.RoutedInterface("ip4", 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 == "ip4" && !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 := ipv4.NewPacketConn(c) defer p.Close() if tt.src == nil { testMulticastSocketOptions(t, p, ifi, tt.grp) } else { testSourceSpecificMulticastSocketOptions(t, p, ifi, tt.grp, tt.src) } } } var rawConnMulticastSocketOptionTests = []struct { grp, src net.Addr }{ {&net.IPAddr{IP: net.IPv4(224, 0, 0, 250)}, nil}, // see RFC 4727 {&net.IPAddr{IP: net.IPv4(232, 0, 1, 250)}, &net.IPAddr{IP: net.IPv4(127, 0, 0, 1)}}, // see RFC 5771 } func TestRawConnMulticastSocketOptions(t testing.T) { if !nettest.SupportsRawSocket() { t.Skipf("not supported on %s/%s", runtime.GOOS, runtime.GOARCH) } ifi, err := nettest.RoutedInterface("ip4", net.FlagUp\|net.FlagMulticast\|net.FlagLoopback) if err != nil { t.Skipf("not available on %s", runtime.GOOS) } for _, tt := range rawConnMulticastSocketOptionTests { c, err := net.ListenPacket("ip4:icmp", "0.0.0.0") if err != nil { t.Fatal(err) } defer c.Close() r, err := ipv4.NewRawConn(c) if err != nil { t.Fatal(err) } defer r.Close() if tt.src == nil { testMulticastSocketOptions(t, r, ifi, tt.grp) } else { testSourceSpecificMulticastSocketOptions(t, r, ifi, tt.grp, tt.src) } } } type testIPv4MulticastConn interface { MulticastTTL() (int, error) SetMulticastTTL(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 testIPv4MulticastConn, ifi net.Interface, grp net.Addr) { t.Helper() const ttl = 255 if err := c.SetMulticastTTL(ttl); err != nil { t.Error(err) return } if v, err := c.MulticastTTL(); err != nil { t.Error(err) return } else if v != ttl { t.Errorf("got %v; want %v", v, ttl) 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 testIPv4MulticastConn, 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 IGMPv2/3 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 } }	5.12 KB	2025-05-25 12:27
📄 packet.go // Copyright 2012 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 ipv4 import ( "net" "golang.org/x/net/internal/socket" ) // BUG(mikio): On Windows, the ReadFrom and WriteTo methods of RawConn // are not implemented. // A packetHandler represents the IPv4 datagram handler. type packetHandler struct { net.IPConn socket.Conn rawOpt } func (c packetHandler) ok() bool { return c != nil && c.IPConn != nil && c.Conn != nil } // ReadFrom reads an IPv4 datagram from the endpoint c, copying the // datagram into b. It returns the received datagram as the IPv4 // header h, the payload p and the control message cm. func (c packetHandler) ReadFrom(b []byte) (h Header, p []byte, cm ControlMessage, err error) { if !c.ok() { return nil, nil, nil, errInvalidConn } c.rawOpt.RLock() m := socket.Message{ Buffers: [][]byte{b}, OOB: NewControlMessage(c.rawOpt.cflags), } c.rawOpt.RUnlock() if err := c.RecvMsg(&m, 0); err != nil { return nil, nil, nil, &net.OpError{Op: "read", Net: c.IPConn.LocalAddr().Network(), Source: c.IPConn.LocalAddr(), Err: err} } var hs []byte if hs, p, err = slicePacket(b[:m.N]); err != nil { return nil, nil, nil, &net.OpError{Op: "read", Net: c.IPConn.LocalAddr().Network(), Source: c.IPConn.LocalAddr(), Err: err} } if h, err = ParseHeader(hs); err != nil { return nil, nil, nil, &net.OpError{Op: "read", Net: c.IPConn.LocalAddr().Network(), Source: c.IPConn.LocalAddr(), Err: err} } if m.NN > 0 { if compatFreeBSD32 { adjustFreeBSD32(&m) } cm = new(ControlMessage) if err := cm.Parse(m.OOB[:m.NN]); err != nil { return nil, nil, nil, &net.OpError{Op: "read", Net: c.IPConn.LocalAddr().Network(), Source: c.IPConn.LocalAddr(), Err: err} } } if src, ok := m.Addr.(net.IPAddr); ok && cm != nil { cm.Src = src.IP } return } func slicePacket(b []byte) (h, p []byte, err error) { if len(b) < HeaderLen { return nil, nil, errHeaderTooShort } hdrlen := int(b[0]&0x0f) << 2 return b[:hdrlen], b[hdrlen:], nil } // WriteTo writes an IPv4 datagram through the endpoint c, copying the // datagram from the IPv4 header h and the payload p. The control // message cm allows the datagram path and the outgoing interface to be // specified. Currently only Darwin and Linux support this. The cm // may be nil if control of the outgoing datagram is not required. // // The IPv4 header h must contain appropriate fields that include: // // Version = <must be specified> // Len = <must be specified> // TOS = <must be specified> // TotalLen = <must be specified> // ID = platform sets an appropriate value if ID is zero // FragOff = <must be specified> // TTL = <must be specified> // Protocol = <must be specified> // Checksum = platform sets an appropriate value if Checksum is zero // Src = platform sets an appropriate value if Src is nil // Dst = <must be specified> // Options = optional func (c packetHandler) WriteTo(h Header, p []byte, cm ControlMessage) error { if !c.ok() { return errInvalidConn } m := socket.Message{ OOB: cm.Marshal(), } wh, err := h.Marshal() if err != nil { return err } m.Buffers = [][]byte{wh, p} dst := new(net.IPAddr) if cm != nil { if ip := cm.Dst.To4(); ip != nil { dst.IP = ip } } if dst.IP == nil { dst.IP = h.Dst } m.Addr = dst if err := c.SendMsg(&m, 0); err != nil { return &net.OpError{Op: "write", Net: c.IPConn.LocalAddr().Network(), Source: c.IPConn.LocalAddr(), Addr: opAddr(dst), Err: err} } return nil }	3.58 KB	2025-05-25 12:27
📄 payload.go // Copyright 2012 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 ipv4 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 IPv4 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 2012 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 ipv4 import ( "net" "golang.org/x/net/internal/socket" ) // ReadFrom reads a payload of the received IPv4 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{ OOB: NewControlMessage(c.rawOpt.cflags), } c.rawOpt.RUnlock() switch c.PacketConn.(type) { case net.UDPConn: m.Buffers = [][]byte{b} 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: h := make([]byte, HeaderLen) m.Buffers = [][]byte{h, b} 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} } hdrlen := int(h[0]&0x0f) << 2 if hdrlen > len(h) { d := hdrlen - len(h) copy(b, b[d:]) m.N -= d } else { m.N -= hdrlen } default: return 0, nil, nil, &net.OpError{Op: "read", Net: c.PacketConn.LocalAddr().Network(), Source: c.PacketConn.LocalAddr(), Err: errInvalidConnType} } if m.NN > 0 { if compatFreeBSD32 { adjustFreeBSD32(&m) } 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 = netAddrToIP4(m.Addr) } return m.N, cm, m.Addr, nil } // WriteTo writes a payload of the IPv4 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 datagram path and the outgoing interface to be specified. // Currently only Darwin and Linux support this. 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.75 KB	2025-05-25 12:27
📄 payload_nocmsg.go // Copyright 2012 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 ipv4 import "net" // ReadFrom reads a payload of the received IPv4 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 IPv4 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 datagram path and the outgoing interface to be specified. // Currently only Darwin and Linux support this. 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.38 KB	2025-05-25 12:27
📄 readwrite_test.go // Copyright 2012 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 ipv4_test import ( "bytes" "fmt" "net" "runtime" "strings" "sync" "testing" "time" "golang.org/x/net/internal/iana" "golang.org/x/net/ipv4" "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("udp4") 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("IPv4UDP", func(b testing.B) { p := ipv4.NewPacketConn(c) cf := ipv4.FlagTTL \| ipv4.FlagInterface if err := p.SetControlMessage(cf, true); err != nil { b.Fatal(err) } cm := ipv4.ControlMessage{TTL: 1} ifi, _ := nettest.RoutedInterface("ip4", 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, err := (&ipv4.Header{ Version: ipv4.Version, Len: ipv4.HeaderLen, TotalLen: ipv4.HeaderLen + len(payload), TTL: 1, Protocol: iana.ProtocolReserved, Src: net.IPv4(192, 0, 2, 1), Dst: net.IPv4(192, 0, 2, 254), }).Marshal() if err != nil { b.Fatal(err) } greh := []byte{0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00} datagram := append(greh, append(iph, payload...)...) bb := make([]byte, 128) cm := ipv4.ControlMessage{ Src: net.IPv4(127, 0, 0, 1), } ifi, _ := nettest.RoutedInterface("ip4", net.FlagUp\|net.FlagLoopback) if ifi != nil { cm.IfIndex = ifi.Index } b.Run("UDP", func(b testing.B) { c, err := nettest.NewLocalPacketListener("udp4") if err != nil { b.Skipf("not supported on %s/%s: %v", runtime.GOOS, runtime.GOARCH, err) } defer c.Close() p := ipv4.NewPacketConn(c) dst := c.LocalAddr() cf := ipv4.FlagTTL \| ipv4.FlagInterface if err := p.SetControlMessage(cf, true); err != nil { b.Fatal(err) } wms := []ipv4.Message{ { Buffers: [][]byte{payload}, Addr: dst, OOB: cm.Marshal(), }, } rms := []ipv4.Message{ { Buffers: [][]byte{bb}, OOB: ipv4.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("ip4:%d", iana.ProtocolGRE), "127.0.0.1") if err != nil { b.Skipf("not supported on %s/%s: %v", runtime.GOOS, runtime.GOARCH, err) } defer c.Close() p := ipv4.NewPacketConn(c) dst := c.LocalAddr() cf := ipv4.FlagTTL \| ipv4.FlagInterface if err := p.SetControlMessage(cf, true); err != nil { b.Fatal(err) } wms := []ipv4.Message{ { Buffers: [][]byte{datagram}, Addr: dst, OOB: cm.Marshal(), }, } rms := []ipv4.Message{ { Buffers: [][]byte{bb}, OOB: ipv4.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) } c, err := nettest.NewLocalPacketListener("udp4") if err != nil { t.Fatal(err) } defer c.Close() p := ipv4.NewPacketConn(c) defer p.Close() dst := c.LocalAddr() ifi, _ := nettest.RoutedInterface("ip4", net.FlagUp\|net.FlagLoopback) cf := ipv4.FlagTTL \| ipv4.FlagSrc \| ipv4.FlagDst \| ipv4.FlagInterface 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 := ipv4.ControlMessage{ Src: net.IPv4(127, 0, 0, 1), } 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, err := (&ipv4.Header{ Version: ipv4.Version, Len: ipv4.HeaderLen, TotalLen: ipv4.HeaderLen + len(payload), TTL: 1, Protocol: iana.ProtocolReserved, Src: net.IPv4(192, 0, 2, 1), Dst: net.IPv4(192, 0, 2, 254), }).Marshal() if err != nil { t.Fatal(err) } greh := []byte{0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00} datagram := append(greh, append(iph, payload...)...) t.Run("UDP", func(t testing.T) { c, err := nettest.NewLocalPacketListener("udp4") if err != nil { t.Skipf("not supported on %s/%s: %v", runtime.GOOS, runtime.GOARCH, err) } defer c.Close() p := ipv4.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("ip4:%d", iana.ProtocolGRE), "127.0.0.1") if err != nil { t.Skipf("not supported on %s/%s: %v", runtime.GOOS, runtime.GOARCH, err) } defer c.Close() p := ipv4.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 ipv4.PacketConn, data []byte, dst net.Addr, batch bool) { t.Helper() ifi, _ := nettest.RoutedInterface("ip4", net.FlagUp\|net.FlagLoopback) cf := ipv4.FlagTTL \| ipv4.FlagSrc \| ipv4.FlagDst \| ipv4.FlagInterface 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 := []ipv4.Message{ { Buffers: [][]byte{make([]byte, 128)}, OOB: ipv4.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 ipv4.ControlMessage if err := cm.Parse(ms[0].OOB[:ms[0].NN]); err != nil { fatalf("%v", err) } var b []byte if _, ok := dst.(net.IPAddr); ok { var h ipv4.Header if err := h.Parse(ms[0].Buffers[0][:ms[0].N]); err != nil { fatalf("%v", err) } b = ms[0].Buffers[0][h.Len:ms[0].N] } else { 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 := ipv4.ControlMessage{ Src: net.IPv4(127, 0, 0, 1), } 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 := ipv4.ControlMessage{ Src: net.IPv4(127, 0, 0, 1), } if ifi != nil { cm.IfIndex = ifi.Index } if err := p.SetControlMessage(cf, toggle); err != nil { fatalf("%v", err) } ms := []ipv4.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() }	12.72 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 ipv4 import "golang.org/x/net/internal/socket" // Sticky socket options const ( ssoTOS = iota // header field for unicast packet ssoTTL // header field for unicast packet ssoMulticastTTL // header field for multicast packet ssoMulticastInterface // outbound interface for multicast packet ssoMulticastLoopback // loopback for multicast packet ssoReceiveTTL // header field on received packet ssoReceiveDst // header field on received packet ssoReceiveInterface // inbound interface on received packet ssoPacketInfo // incbound or outbound packet path ssoHeaderPrepend // ipv4 header prepend ssoStripHeader // strip ipv4 header ssoICMPFilter // icmp filter ssoJoinGroup // any-source multicast ssoLeaveGroup // any-source multicast 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 ssoTypeIPMreqn 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.68 KB	2025-05-25 12:27
📄 sockopt_posix.go // Copyright 2012 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 ipv4 import ( "net" "unsafe" "golang.org/x/net/bpf" "golang.org/x/net/internal/socket" ) func (so sockOpt) getMulticastInterface(c socket.Conn) (net.Interface, error) { switch so.typ { case ssoTypeIPMreqn: return so.getIPMreqn(c) default: return so.getMulticastIf(c) } } func (so sockOpt) setMulticastInterface(c socket.Conn, ifi net.Interface) error { switch so.typ { case ssoTypeIPMreqn: return so.setIPMreqn(c, ifi, nil) default: return so.setMulticastIf(c, ifi) } } 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 != sizeofICMPFilter { return nil, errNotImplemented } return (ICMPFilter)(unsafe.Pointer(&b[0])), nil } func (so sockOpt) setICMPFilter(c socket.Conn, f ICMPFilter) error { b := ([sizeofICMPFilter]byte)(unsafe.Pointer(f))[:sizeofICMPFilter] return so.Set(c, b) } 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 ssoTypeIPMreqn: return so.setIPMreqn(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) }	1.75 KB	2025-05-25 12:27
📄 sockopt_stub.go // Copyright 2012 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 ipv4 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) 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.12 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 ipv4 import ( "net" "syscall" "golang.org/x/net/internal/iana" "golang.org/x/net/internal/socket" "golang.org/x/sys/unix" ) // IP_RECVIF is defined on AIX but doesn't work. IP_RECVINTERFACE must be used instead. const sockoptReceiveInterface = unix.IP_RECVINTERFACE var ( ctlOpts = [ctlMax]ctlOpt{ ctlTTL: {unix.IP_RECVTTL, 1, marshalTTL, parseTTL}, ctlDst: {unix.IP_RECVDSTADDR, net.IPv4len, marshalDst, parseDst}, ctlInterface: {unix.IP_RECVINTERFACE, syscall.SizeofSockaddrDatalink, marshalInterface, parseInterface}, } sockOpts = map[int]*sockOpt{ ssoTOS: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_TOS, Len: 4}}, ssoTTL: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_TTL, Len: 4}}, ssoMulticastTTL: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_MULTICAST_TTL, Len: 1}}, ssoMulticastInterface: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_MULTICAST_IF, Len: 4}}, ssoMulticastLoopback: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_MULTICAST_LOOP, Len: 1}}, ssoReceiveTTL: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_RECVTTL, Len: 4}}, ssoReceiveDst: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_RECVDSTADDR, Len: 4}}, ssoReceiveInterface: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_RECVINTERFACE, Len: 4}}, ssoHeaderPrepend: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_HDRINCL, Len: 4}}, ssoJoinGroup: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_ADD_MEMBERSHIP, Len: sizeofIPMreq}, typ: ssoTypeIPMreq}, ssoLeaveGroup: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_DROP_MEMBERSHIP, Len: sizeofIPMreq}, typ: ssoTypeIPMreq}, } )	2.01 KB	2025-05-25 12:27
📄 sys_asmreq.go // Copyright 2012 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 \|\| solaris \|\| windows package ipv4 import ( "errors" "net" "unsafe" "golang.org/x/net/internal/socket" ) var errNoSuchInterface = errors.New("no such interface") func (so sockOpt) setIPMreq(c socket.Conn, ifi net.Interface, grp net.IP) error { mreq := ipMreq{Multiaddr: [4]byte{grp[0], grp[1], grp[2], grp[3]}} if err := setIPMreqInterface(&mreq, ifi); err != nil { return err } b := ([sizeofIPMreq]byte)(unsafe.Pointer(&mreq))[:sizeofIPMreq] return so.Set(c, b) } func (so sockOpt) getMulticastIf(c socket.Conn) (net.Interface, error) { var b [4]byte if _, err := so.Get(c, b[:]); err != nil { return nil, err } ifi, err := netIP4ToInterface(net.IPv4(b[0], b[1], b[2], b[3])) if err != nil { return nil, err } return ifi, nil } func (so sockOpt) setMulticastIf(c socket.Conn, ifi net.Interface) error { ip, err := netInterfaceToIP4(ifi) if err != nil { return err } var b [4]byte copy(b[:], ip) return so.Set(c, b[:]) } func setIPMreqInterface(mreq ipMreq, ifi net.Interface) error { if ifi == nil { return nil } ifat, err := ifi.Addrs() if err != nil { return err } for _, ifa := range ifat { switch ifa := ifa.(type) { case net.IPAddr: if ip := ifa.IP.To4(); ip != nil { copy(mreq.Interface[:], ip) return nil } case net.IPNet: if ip := ifa.IP.To4(); ip != nil { copy(mreq.Interface[:], ip) return nil } } } return errNoSuchInterface } func netIP4ToInterface(ip net.IP) (net.Interface, error) { ift, err := net.Interfaces() if err != nil { return nil, err } for _, ifi := range ift { ifat, err := ifi.Addrs() if err != nil { return nil, err } for _, ifa := range ifat { switch ifa := ifa.(type) { case net.IPAddr: if ip.Equal(ifa.IP) { return &ifi, nil } case net.IPNet: if ip.Equal(ifa.IP) { return &ifi, nil } } } } return nil, errNoSuchInterface } func netInterfaceToIP4(ifi net.Interface) (net.IP, error) { if ifi == nil { return net.IPv4zero.To4(), nil } ifat, err := ifi.Addrs() if err != nil { return nil, err } for _, ifa := range ifat { switch ifa := ifa.(type) { case net.IPAddr: if ip := ifa.IP.To4(); ip != nil { return ip, nil } case net.IPNet: if ip := ifa.IP.To4(); ip != nil { return ip, nil } } } return nil, errNoSuchInterface }	2.53 KB	2025-05-25 12:27
📄 sys_asmreq_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 !aix && !darwin && !dragonfly && !freebsd && !netbsd && !openbsd && !solaris && !windows package ipv4 import ( "net" "golang.org/x/net/internal/socket" ) func (so sockOpt) setIPMreq(c socket.Conn, ifi net.Interface, grp net.IP) error { return errNotImplemented } func (so sockOpt) getMulticastIf(c socket.Conn) (net.Interface, error) { return nil, errNotImplemented } func (so sockOpt) setMulticastIf(c socket.Conn, ifi *net.Interface) error { return errNotImplemented }	661 B	2025-05-25 12:27
📄 sys_asmreqn.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 darwin \|\| freebsd \|\| linux package ipv4 import ( "net" "unsafe" "golang.org/x/net/internal/socket" "golang.org/x/sys/unix" ) func (so sockOpt) getIPMreqn(c socket.Conn) (net.Interface, error) { b := make([]byte, so.Len) if _, err := so.Get(c, b); err != nil { return nil, err } mreqn := (unix.IPMreqn)(unsafe.Pointer(&b[0])) if mreqn.Ifindex == 0 { return nil, nil } ifi, err := net.InterfaceByIndex(int(mreqn.Ifindex)) if err != nil { return nil, err } return ifi, nil } func (so sockOpt) setIPMreqn(c socket.Conn, ifi net.Interface, grp net.IP) error { var mreqn unix.IPMreqn if ifi != nil { mreqn.Ifindex = int32(ifi.Index) } if grp != nil { mreqn.Multiaddr = [4]byte{grp[0], grp[1], grp[2], grp[3]} } b := ([unix.SizeofIPMreqn]byte)(unsafe.Pointer(&mreqn))[:unix.SizeofIPMreqn] return so.Set(c, b) }	1020 B	2025-05-25 12:27
📄 sys_asmreqn_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 !darwin && !freebsd && !linux package ipv4 import ( "net" "golang.org/x/net/internal/socket" ) func (so sockOpt) getIPMreqn(c socket.Conn) (net.Interface, error) { return nil, errNotImplemented } func (so sockOpt) setIPMreqn(c socket.Conn, ifi net.Interface, grp net.IP) error { return errNotImplemented }	492 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 ipv4 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 ipv4 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 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 netbsd \|\| openbsd package ipv4 import ( "net" "syscall" "golang.org/x/net/internal/iana" "golang.org/x/net/internal/socket" "golang.org/x/sys/unix" ) const sockoptReceiveInterface = unix.IP_RECVIF var ( ctlOpts = [ctlMax]ctlOpt{ ctlTTL: {unix.IP_RECVTTL, 1, marshalTTL, parseTTL}, ctlDst: {unix.IP_RECVDSTADDR, net.IPv4len, marshalDst, parseDst}, ctlInterface: {unix.IP_RECVIF, syscall.SizeofSockaddrDatalink, marshalInterface, parseInterface}, } sockOpts = map[int]*sockOpt{ ssoTOS: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_TOS, Len: 4}}, ssoTTL: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_TTL, Len: 4}}, ssoMulticastTTL: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_MULTICAST_TTL, Len: 1}}, ssoMulticastInterface: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_MULTICAST_IF, Len: 4}}, ssoMulticastLoopback: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_MULTICAST_LOOP, Len: 1}}, ssoReceiveTTL: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_RECVTTL, Len: 4}}, ssoReceiveDst: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_RECVDSTADDR, Len: 4}}, ssoReceiveInterface: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_RECVIF, Len: 4}}, ssoHeaderPrepend: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_HDRINCL, Len: 4}}, ssoJoinGroup: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_ADD_MEMBERSHIP, Len: sizeofIPMreq}, typ: ssoTypeIPMreq}, ssoLeaveGroup: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_DROP_MEMBERSHIP, Len: sizeofIPMreq}, typ: ssoTypeIPMreq}, } )	1.88 KB	2025-05-25 12:27
📄 sys_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. package ipv4 import ( "net" "syscall" "unsafe" "golang.org/x/net/internal/iana" "golang.org/x/net/internal/socket" "golang.org/x/sys/unix" ) const sockoptReceiveInterface = unix.IP_RECVIF var ( ctlOpts = [ctlMax]ctlOpt{ ctlTTL: {unix.IP_RECVTTL, 1, marshalTTL, parseTTL}, ctlDst: {unix.IP_RECVDSTADDR, net.IPv4len, marshalDst, parseDst}, ctlInterface: {unix.IP_RECVIF, syscall.SizeofSockaddrDatalink, marshalInterface, parseInterface}, ctlPacketInfo: {unix.IP_PKTINFO, sizeofInetPktinfo, marshalPacketInfo, parsePacketInfo}, } sockOpts = map[int]sockOpt{ ssoTOS: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_TOS, Len: 4}}, ssoTTL: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_TTL, Len: 4}}, ssoMulticastTTL: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_MULTICAST_TTL, Len: 1}}, ssoMulticastInterface: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_MULTICAST_IF, Len: unix.SizeofIPMreqn}, typ: ssoTypeIPMreqn}, ssoMulticastLoopback: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_MULTICAST_LOOP, Len: 4}}, ssoReceiveTTL: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_RECVTTL, Len: 4}}, ssoReceiveDst: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_RECVDSTADDR, Len: 4}}, ssoReceiveInterface: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_RECVIF, Len: 4}}, ssoHeaderPrepend: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_HDRINCL, Len: 4}}, ssoStripHeader: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_STRIPHDR, Len: 4}}, ssoJoinGroup: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.MCAST_JOIN_GROUP, Len: sizeofGroupReq}, typ: ssoTypeGroupReq}, ssoLeaveGroup: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.MCAST_LEAVE_GROUP, Len: sizeofGroupReq}, typ: ssoTypeGroupReq}, ssoJoinSourceGroup: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.MCAST_JOIN_SOURCE_GROUP, Len: sizeofGroupSourceReq}, typ: ssoTypeGroupSourceReq}, ssoLeaveSourceGroup: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.MCAST_LEAVE_SOURCE_GROUP, Len: sizeofGroupSourceReq}, typ: ssoTypeGroupSourceReq}, ssoBlockSourceGroup: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.MCAST_BLOCK_SOURCE, Len: sizeofGroupSourceReq}, typ: ssoTypeGroupSourceReq}, ssoUnblockSourceGroup: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.MCAST_UNBLOCK_SOURCE, Len: sizeofGroupSourceReq}, typ: ssoTypeGroupSourceReq}, ssoPacketInfo: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_RECVPKTINFO, Len: 4}}, } ) func (pi inetPktinfo) setIfindex(i int) { pi.Ifindex = uint32(i) } func (gr groupReq) setGroup(grp net.IP) { sa := (sockaddrInet)(unsafe.Pointer(uintptr(unsafe.Pointer(gr)) + 4)) sa.Len = sizeofSockaddrInet sa.Family = syscall.AF_INET copy(sa.Addr[:], grp) } func (gsr groupSourceReq) setSourceGroup(grp, src net.IP) { sa := (sockaddrInet)(unsafe.Pointer(uintptr(unsafe.Pointer(gsr)) + 4)) sa.Len = sizeofSockaddrInet sa.Family = syscall.AF_INET copy(sa.Addr[:], grp) sa = (*sockaddrInet)(unsafe.Pointer(uintptr(unsafe.Pointer(gsr)) + 132)) sa.Len = sizeofSockaddrInet sa.Family = syscall.AF_INET copy(sa.Addr[:], src) }	3.47 KB	2025-05-25 12:27
📄 sys_dragonfly.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 ipv4 import ( "net" "syscall" "golang.org/x/net/internal/iana" "golang.org/x/net/internal/socket" "golang.org/x/sys/unix" ) const sockoptReceiveInterface = unix.IP_RECVIF var ( ctlOpts = [ctlMax]ctlOpt{ ctlTTL: {unix.IP_RECVTTL, 1, marshalTTL, parseTTL}, ctlDst: {unix.IP_RECVDSTADDR, net.IPv4len, marshalDst, parseDst}, ctlInterface: {unix.IP_RECVIF, syscall.SizeofSockaddrDatalink, marshalInterface, parseInterface}, } sockOpts = map[int]*sockOpt{ ssoTOS: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_TOS, Len: 4}}, ssoTTL: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_TTL, Len: 4}}, ssoMulticastTTL: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_MULTICAST_TTL, Len: 1}}, ssoMulticastInterface: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_MULTICAST_IF, Len: 4}}, ssoMulticastLoopback: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_MULTICAST_LOOP, Len: 4}}, ssoReceiveTTL: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_RECVTTL, Len: 4}}, ssoReceiveDst: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_RECVDSTADDR, Len: 4}}, ssoReceiveInterface: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_RECVIF, Len: 4}}, ssoHeaderPrepend: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_HDRINCL, Len: 4}}, ssoJoinGroup: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_ADD_MEMBERSHIP, Len: sizeofIPMreq}, typ: ssoTypeIPMreq}, ssoLeaveGroup: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_DROP_MEMBERSHIP, Len: sizeofIPMreq}, typ: ssoTypeIPMreq}, } )	1.86 KB	2025-05-25 12:27
📄 sys_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. package ipv4 import ( "net" "runtime" "strings" "syscall" "unsafe" "golang.org/x/net/internal/iana" "golang.org/x/net/internal/socket" "golang.org/x/sys/unix" ) const sockoptReceiveInterface = unix.IP_RECVIF var ( ctlOpts = [ctlMax]ctlOpt{ ctlTTL: {unix.IP_RECVTTL, 1, marshalTTL, parseTTL}, ctlDst: {unix.IP_RECVDSTADDR, net.IPv4len, marshalDst, parseDst}, ctlInterface: {unix.IP_RECVIF, syscall.SizeofSockaddrDatalink, marshalInterface, parseInterface}, } sockOpts = map[int]sockOpt{ ssoTOS: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_TOS, Len: 4}}, ssoTTL: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_TTL, Len: 4}}, ssoMulticastTTL: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_MULTICAST_TTL, Len: 1}}, ssoMulticastInterface: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_MULTICAST_IF, Len: 4}}, ssoMulticastLoopback: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_MULTICAST_LOOP, Len: 4}}, ssoReceiveTTL: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_RECVTTL, Len: 4}}, ssoReceiveDst: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_RECVDSTADDR, Len: 4}}, ssoReceiveInterface: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_RECVIF, Len: 4}}, ssoHeaderPrepend: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_HDRINCL, Len: 4}}, ssoJoinGroup: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.MCAST_JOIN_GROUP, Len: sizeofGroupReq}, typ: ssoTypeGroupReq}, ssoLeaveGroup: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.MCAST_LEAVE_GROUP, Len: sizeofGroupReq}, typ: ssoTypeGroupReq}, ssoJoinSourceGroup: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.MCAST_JOIN_SOURCE_GROUP, Len: sizeofGroupSourceReq}, typ: ssoTypeGroupSourceReq}, ssoLeaveSourceGroup: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.MCAST_LEAVE_SOURCE_GROUP, Len: sizeofGroupSourceReq}, typ: ssoTypeGroupSourceReq}, ssoBlockSourceGroup: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.MCAST_BLOCK_SOURCE, Len: sizeofGroupSourceReq}, typ: ssoTypeGroupSourceReq}, ssoUnblockSourceGroup: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.MCAST_UNBLOCK_SOURCE, Len: sizeofGroupSourceReq}, typ: ssoTypeGroupSourceReq}, } ) func init() { freebsdVersion, _ = syscall.SysctlUint32("kern.osreldate") if freebsdVersion >= 1000000 { sockOpts[ssoMulticastInterface] = &sockOpt{Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_MULTICAST_IF, Len: unix.SizeofIPMreqn}, typ: ssoTypeIPMreqn} } 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 (gr groupReq) setGroup(grp net.IP) { sa := (sockaddrInet)(unsafe.Pointer(&gr.Group)) sa.Len = sizeofSockaddrInet sa.Family = syscall.AF_INET copy(sa.Addr[:], grp) } func (gsr groupSourceReq) setSourceGroup(grp, src net.IP) { sa := (sockaddrInet)(unsafe.Pointer(&gsr.Group)) sa.Len = sizeofSockaddrInet sa.Family = syscall.AF_INET copy(sa.Addr[:], grp) sa = (sockaddrInet)(unsafe.Pointer(&gsr.Source)) sa.Len = sizeofSockaddrInet sa.Family = syscall.AF_INET copy(sa.Addr[:], src) }	3.52 KB	2025-05-25 12:27
📄 sys_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. package ipv4 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{ ctlTTL: {unix.IP_TTL, 1, marshalTTL, parseTTL}, ctlPacketInfo: {unix.IP_PKTINFO, sizeofInetPktinfo, marshalPacketInfo, parsePacketInfo}, } sockOpts = map[int]sockOpt{ ssoTOS: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_TOS, Len: 4}}, ssoTTL: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_TTL, Len: 4}}, ssoMulticastTTL: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_MULTICAST_TTL, Len: 4}}, ssoMulticastInterface: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_MULTICAST_IF, Len: unix.SizeofIPMreqn}, typ: ssoTypeIPMreqn}, ssoMulticastLoopback: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_MULTICAST_LOOP, Len: 4}}, ssoReceiveTTL: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_RECVTTL, Len: 4}}, ssoPacketInfo: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_PKTINFO, Len: 4}}, ssoHeaderPrepend: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_HDRINCL, Len: 4}}, ssoICMPFilter: {Option: socket.Option{Level: iana.ProtocolReserved, Name: unix.ICMP_FILTER, Len: sizeofICMPFilter}}, ssoJoinGroup: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.MCAST_JOIN_GROUP, Len: sizeofGroupReq}, typ: ssoTypeGroupReq}, ssoLeaveGroup: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.MCAST_LEAVE_GROUP, Len: sizeofGroupReq}, typ: ssoTypeGroupReq}, ssoJoinSourceGroup: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.MCAST_JOIN_SOURCE_GROUP, Len: sizeofGroupSourceReq}, typ: ssoTypeGroupSourceReq}, ssoLeaveSourceGroup: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.MCAST_LEAVE_SOURCE_GROUP, Len: sizeofGroupSourceReq}, typ: ssoTypeGroupSourceReq}, ssoBlockSourceGroup: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.MCAST_BLOCK_SOURCE, Len: sizeofGroupSourceReq}, typ: ssoTypeGroupSourceReq}, ssoUnblockSourceGroup: {Option: socket.Option{Level: iana.ProtocolIP, 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 (pi inetPktinfo) setIfindex(i int) { pi.Ifindex = int32(i) } func (gr groupReq) setGroup(grp net.IP) { sa := (sockaddrInet)(unsafe.Pointer(&gr.Group)) sa.Family = syscall.AF_INET copy(sa.Addr[:], grp) } func (gsr groupSourceReq) setSourceGroup(grp, src net.IP) { sa := (sockaddrInet)(unsafe.Pointer(&gsr.Group)) sa.Family = syscall.AF_INET copy(sa.Addr[:], grp) sa = (*sockaddrInet)(unsafe.Pointer(&gsr.Source)) sa.Family = syscall.AF_INET copy(sa.Addr[:], src) }	3.04 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 ipv4 import ( "net" "syscall" "unsafe" "golang.org/x/net/internal/iana" "golang.org/x/net/internal/socket" "golang.org/x/sys/unix" ) const sockoptReceiveInterface = unix.IP_RECVIF var ( ctlOpts = [ctlMax]ctlOpt{ ctlTTL: {unix.IP_RECVTTL, 4, marshalTTL, parseTTL}, ctlPacketInfo: {unix.IP_PKTINFO, sizeofInetPktinfo, marshalPacketInfo, parsePacketInfo}, } sockOpts = map[int]sockOpt{ ssoTOS: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_TOS, Len: 4}}, ssoTTL: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_TTL, Len: 4}}, ssoMulticastTTL: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_MULTICAST_TTL, Len: 1}}, ssoMulticastInterface: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_MULTICAST_IF, Len: 4}}, ssoMulticastLoopback: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_MULTICAST_LOOP, Len: 1}}, ssoReceiveTTL: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_RECVTTL, Len: 4}}, ssoPacketInfo: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_RECVPKTINFO, Len: 4}}, ssoHeaderPrepend: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_HDRINCL, Len: 4}}, ssoJoinGroup: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.MCAST_JOIN_GROUP, Len: sizeofGroupReq}, typ: ssoTypeGroupReq}, ssoLeaveGroup: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.MCAST_LEAVE_GROUP, Len: sizeofGroupReq}, typ: ssoTypeGroupReq}, ssoJoinSourceGroup: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.MCAST_JOIN_SOURCE_GROUP, Len: sizeofGroupSourceReq}, typ: ssoTypeGroupSourceReq}, ssoLeaveSourceGroup: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.MCAST_LEAVE_SOURCE_GROUP, Len: sizeofGroupSourceReq}, typ: ssoTypeGroupSourceReq}, ssoBlockSourceGroup: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.MCAST_BLOCK_SOURCE, Len: sizeofGroupSourceReq}, typ: ssoTypeGroupSourceReq}, ssoUnblockSourceGroup: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.MCAST_UNBLOCK_SOURCE, Len: sizeofGroupSourceReq}, typ: ssoTypeGroupSourceReq}, } ) func (pi inetPktinfo) setIfindex(i int) { pi.Ifindex = uint32(i) } func (gr groupReq) setGroup(grp net.IP) { sa := (sockaddrInet)(unsafe.Pointer(uintptr(unsafe.Pointer(gr)) + 4)) sa.Family = syscall.AF_INET copy(sa.Addr[:], grp) } func (gsr groupSourceReq) setSourceGroup(grp, src net.IP) { sa := (sockaddrInet)(unsafe.Pointer(uintptr(unsafe.Pointer(gsr)) + 4)) sa.Family = syscall.AF_INET copy(sa.Addr[:], grp) sa = (sockaddrInet)(unsafe.Pointer(uintptr(unsafe.Pointer(gsr)) + 260)) sa.Family = syscall.AF_INET copy(sa.Addr[:], src) }	2.87 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 darwin \|\| freebsd \|\| linux \|\| solaris package ipv4 import ( "net" "unsafe" "golang.org/x/net/internal/socket" ) 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.23 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 !darwin && !freebsd && !linux && !solaris package ipv4 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 }	526 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 ipv4 var ( ctlOpts = [ctlMax]ctlOpt{} sockOpts = map[int]*sockOpt{} )	361 B	2025-05-25 12:27
📄 sys_windows.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 ipv4 import ( "golang.org/x/net/internal/iana" "golang.org/x/net/internal/socket" "golang.org/x/sys/windows" ) const ( sizeofIPMreq = 0x8 sizeofIPMreqSource = 0xc ) type ipMreq struct { Multiaddr [4]byte Interface [4]byte } type ipMreqSource struct { Multiaddr [4]byte Sourceaddr [4]byte Interface [4]byte } // See http://msdn.microsoft.com/en-us/library/windows/desktop/ms738586(v=vs.85).aspx var ( ctlOpts = [ctlMax]ctlOpt{} sockOpts = map[int]*sockOpt{ ssoTOS: {Option: socket.Option{Level: iana.ProtocolIP, Name: windows.IP_TOS, Len: 4}}, ssoTTL: {Option: socket.Option{Level: iana.ProtocolIP, Name: windows.IP_TTL, Len: 4}}, ssoMulticastTTL: {Option: socket.Option{Level: iana.ProtocolIP, Name: windows.IP_MULTICAST_TTL, Len: 4}}, ssoMulticastInterface: {Option: socket.Option{Level: iana.ProtocolIP, Name: windows.IP_MULTICAST_IF, Len: 4}}, ssoMulticastLoopback: {Option: socket.Option{Level: iana.ProtocolIP, Name: windows.IP_MULTICAST_LOOP, Len: 4}}, ssoHeaderPrepend: {Option: socket.Option{Level: iana.ProtocolIP, Name: windows.IP_HDRINCL, Len: 4}}, ssoJoinGroup: {Option: socket.Option{Level: iana.ProtocolIP, Name: windows.IP_ADD_MEMBERSHIP, Len: sizeofIPMreq}, typ: ssoTypeIPMreq}, ssoLeaveGroup: {Option: socket.Option{Level: iana.ProtocolIP, Name: windows.IP_DROP_MEMBERSHIP, Len: sizeofIPMreq}, typ: ssoTypeIPMreq}, } )	1.57 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 ipv4 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{ ctlPacketInfo: {unix.IP_PKTINFO, sizeofInetPktinfo, marshalPacketInfo, parsePacketInfo}, } sockOpts = map[int]sockOpt{ ssoMulticastTTL: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_MULTICAST_TTL, Len: 1}}, ssoMulticastInterface: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_MULTICAST_IF, Len: 4}}, ssoMulticastLoopback: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_MULTICAST_LOOP, Len: 1}}, ssoPacketInfo: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.IP_RECVPKTINFO, Len: 4}}, ssoJoinGroup: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.MCAST_JOIN_GROUP, Len: sizeofGroupReq}, typ: ssoTypeGroupReq}, ssoLeaveGroup: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.MCAST_LEAVE_GROUP, Len: sizeofGroupReq}, typ: ssoTypeGroupReq}, ssoJoinSourceGroup: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.MCAST_JOIN_SOURCE_GROUP, Len: sizeofGroupSourceReq}, typ: ssoTypeGroupSourceReq}, ssoLeaveSourceGroup: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.MCAST_LEAVE_SOURCE_GROUP, Len: sizeofGroupSourceReq}, typ: ssoTypeGroupSourceReq}, ssoBlockSourceGroup: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.MCAST_BLOCK_SOURCE, Len: sizeofGroupSourceReq}, typ: ssoTypeGroupSourceReq}, ssoUnblockSourceGroup: {Option: socket.Option{Level: iana.ProtocolIP, Name: unix.MCAST_UNBLOCK_SOURCE, Len: sizeofGroupSourceReq}, typ: ssoTypeGroupSourceReq}, } ) func (pi inetPktinfo) setIfindex(i int) { pi.Ifindex = uint32(i) } func (gr groupReq) setGroup(grp net.IP) { sa := (sockaddrInet4)(unsafe.Pointer(&gr.Group)) sa.Family = syscall.AF_INET sa.Len = sizeofSockaddrInet4 copy(sa.Addr[:], grp) } func (gsr groupSourceReq) setSourceGroup(grp, src net.IP) { sa := (sockaddrInet4)(unsafe.Pointer(&gsr.Group)) sa.Family = syscall.AF_INET sa.Len = sizeofSockaddrInet4 copy(sa.Addr[:], grp) sa = (*sockaddrInet4)(unsafe.Pointer(&gsr.Source)) sa.Family = syscall.AF_INET sa.Len = sizeofSockaddrInet4 copy(sa.Addr[:], src) }	2.39 KB	2025-05-25 12:27
📄 unicast_test.go // Copyright 2012 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 ipv4_test import ( "bytes" "net" "os" "runtime" "testing" "time" "golang.org/x/net/icmp" "golang.org/x/net/internal/iana" "golang.org/x/net/ipv4" "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) } // Skip this check on z/OS since net.Interfaces() does not return loopback, however // this does not affect the test and it will still pass. if _, err := nettest.RoutedInterface("ip4", net.FlagUp\|net.FlagLoopback); err != nil && runtime.GOOS != "zos" { t.Skipf("not available on %s", runtime.GOOS) } c, err := nettest.NewLocalPacketListener("udp4") if err != nil { t.Fatal(err) } defer c.Close() p := ipv4.NewPacketConn(c) defer p.Close() dst := c.LocalAddr() cf := ipv4.FlagTTL \| ipv4.FlagDst \| ipv4.FlagInterface 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) } p.SetTTL(i + 1) backoff := time.Millisecond for { n, err := p.WriteTo(wb, nil, 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.SupportsRawSocket() { t.Skipf("not supported on %s/%s", runtime.GOOS, runtime.GOARCH) } // Skip this check on z/OS since net.Interfaces() does not return loopback, however // this does not affect the test and it will still pass. if _, err := nettest.RoutedInterface("ip4", net.FlagUp\|net.FlagLoopback); err != nil && runtime.GOOS != "zos" { t.Skipf("not available on %s", runtime.GOOS) } c, err := net.ListenPacket("ip4:icmp", "0.0.0.0") if err != nil { t.Fatal(err) } defer c.Close() dst, err := net.ResolveIPAddr("ip4", "127.0.0.1") if err != nil { t.Fatal(err) } p := ipv4.NewPacketConn(c) defer p.Close() cf := ipv4.FlagDst \| ipv4.FlagInterface if runtime.GOOS != "illumos" && runtime.GOOS != "solaris" { // Illumos and Solaris never allow modification of ICMP properties. cf \|= ipv4.FlagTTL } for i, toggle := range []bool{true, false, true} { wb, err := (&icmp.Message{ Type: ipv4.ICMPTypeEcho, Code: 0, Body: &icmp.Echo{ ID: os.Getpid() & 0xffff, Seq: i + 1, Data: []byte("HELLO-R-U-THERE"), }, }).Marshal(nil) 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) } p.SetTTL(i + 1) backoff := time.Millisecond for { n, err := p.WriteTo(wb, nil, 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) loop: if n, _, _, err := p.ReadFrom(rb); err != nil { t.Fatal(err) } else { m, err := icmp.ParseMessage(iana.ProtocolICMP, rb[:n]) if err != nil { t.Fatal(err) } if runtime.GOOS == "linux" && m.Type == ipv4.ICMPTypeEcho { // On Linux we must handle own sent packets. goto loop } if m.Type != ipv4.ICMPTypeEchoReply \|\| m.Code != 0 { t.Fatalf("got type=%v, code=%v; want type=%v, code=%v", m.Type, m.Code, ipv4.ICMPTypeEchoReply, 0) } } } } func TestRawConnReadWriteUnicastICMP(t *testing.T) { if !nettest.SupportsRawSocket() { t.Skipf("not supported on %s/%s", runtime.GOOS, runtime.GOARCH) } if _, err := nettest.RoutedInterface("ip4", net.FlagUp\|net.FlagLoopback); err != nil { t.Skipf("not available on %s", runtime.GOOS) } c, err := net.ListenPacket("ip4:icmp", "0.0.0.0") if err != nil { t.Fatal(err) } defer c.Close() dst, err := net.ResolveIPAddr("ip4", "127.0.0.1") if err != nil { t.Fatal(err) } r, err := ipv4.NewRawConn(c) if err != nil { t.Fatal(err) } defer r.Close() cf := ipv4.FlagTTL \| ipv4.FlagDst \| ipv4.FlagInterface for i, toggle := range []bool{true, false, true} { wb, err := (&icmp.Message{ Type: ipv4.ICMPTypeEcho, Code: 0, Body: &icmp.Echo{ ID: os.Getpid() & 0xffff, Seq: i + 1, Data: []byte("HELLO-R-U-THERE"), }, }).Marshal(nil) if err != nil { t.Fatal(err) } wh := &ipv4.Header{ Version: ipv4.Version, Len: ipv4.HeaderLen, TOS: i + 1, TotalLen: ipv4.HeaderLen + len(wb), TTL: i + 1, Protocol: 1, Dst: dst.IP, } if err := r.SetControlMessage(cf, toggle); err != nil { if protocolNotSupported(err) { t.Logf("not supported on %s", runtime.GOOS) continue } t.Fatal(err) } if err := r.WriteTo(wh, wb, nil); err != nil { t.Fatal(err) } rb := make([]byte, ipv4.HeaderLen+128) loop: if _, b, _, err := r.ReadFrom(rb); err != nil { t.Fatal(err) } else { m, err := icmp.ParseMessage(iana.ProtocolICMP, b) if err != nil { t.Fatal(err) } if runtime.GOOS == "linux" && m.Type == ipv4.ICMPTypeEcho { // On Linux we must handle own sent packets. goto loop } if m.Type != ipv4.ICMPTypeEchoReply \|\| m.Code != 0 { t.Fatalf("got type=%v, code=%v; want type=%v, code=%v", m.Type, m.Code, ipv4.ICMPTypeEchoReply, 0) } } } }	5.77 KB	2025-05-25 12:27
📄 unicastsockopt_test.go // Copyright 2012 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 ipv4_test import ( "net" "runtime" "testing" "golang.org/x/net/internal/iana" "golang.org/x/net/ipv4" "golang.org/x/net/nettest" ) func TestConnUnicastSocketOptions(t testing.T) { switch runtime.GOOS { case "fuchsia", "hurd", "js", "nacl", "plan9", "wasip1", "windows", "zos": t.Skipf("not supported on %s", runtime.GOOS) } if _, err := nettest.RoutedInterface("ip4", net.FlagUp\|net.FlagLoopback); err != nil { t.Skipf("not available on %s", runtime.GOOS) } ln, err := net.Listen("tcp4", "127.0.0.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("tcp4", ln.Addr().String()) if err != nil { t.Fatal(err) } defer c.Close() testUnicastSocketOptions(t, ipv4.NewConn(c)) if err := <-errc; err != nil { t.Errorf("server: %v", err) } } var packetConnUnicastSocketOptionTests = []struct { net, proto, addr string }{ {"udp4", "", "127.0.0.1:0"}, {"ip4", ":icmp", "127.0.0.1"}, } func TestPacketConnUnicastSocketOptions(t testing.T) { switch runtime.GOOS { case "fuchsia", "hurd", "js", "nacl", "plan9", "wasip1", "windows", "zos": t.Skipf("not supported on %s", runtime.GOOS) } if _, err := nettest.RoutedInterface("ip4", net.FlagUp\|net.FlagLoopback); err != nil { t.Skipf("not available on %s", runtime.GOOS) } ok := nettest.SupportsRawSocket() for _, tt := range packetConnUnicastSocketOptionTests { if tt.net == "ip4" && !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, ipv4.NewPacketConn(c)) } } func TestRawConnUnicastSocketOptions(t testing.T) { if !nettest.SupportsRawSocket() { t.Skipf("not supported on %s/%s", runtime.GOOS, runtime.GOARCH) } if _, err := nettest.RoutedInterface("ip4", net.FlagUp\|net.FlagLoopback); err != nil { t.Skipf("not available on %s", runtime.GOOS) } c, err := net.ListenPacket("ip4:icmp", "127.0.0.1") if err != nil { t.Fatal(err) } defer c.Close() r, err := ipv4.NewRawConn(c) if err != nil { t.Fatal(err) } testUnicastSocketOptions(t, r) } type testIPv4UnicastConn interface { TOS() (int, error) SetTOS(int) error TTL() (int, error) SetTTL(int) error } func testUnicastSocketOptions(t testing.T, c testIPv4UnicastConn) { t.Helper() tos := iana.DiffServCS0 \| iana.NotECNTransport switch runtime.GOOS { case "windows": // IP_TOS option is supported on Windows 8 and beyond. t.Skipf("not supported on %s", runtime.GOOS) } if err := c.SetTOS(tos); err != nil { t.Fatal(err) } if v, err := c.TOS(); err != nil { t.Fatal(err) } else if v != tos { t.Fatalf("got %v; want %v", v, tos) } const ttl = 255 if err := c.SetTTL(ttl); err != nil { t.Fatal(err) } if v, err := c.TTL(); err != nil { t.Fatal(err) } else if v != ttl { t.Fatalf("got %v; want %v", v, ttl) } }	3.15 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 ipv4 const ( sizeofIPMreq = 0x8 ) type ipMreq struct { Multiaddr [4]byte /* in_addr / Interface [4]byte / in_addr */ }	263 B	2025-05-25 12:27
📄 zsys_darwin.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_darwin.go package ipv4 const ( sizeofSockaddrStorage = 0x80 sizeofSockaddrInet = 0x10 sizeofInetPktinfo = 0xc sizeofIPMreq = 0x8 sizeofIPMreqSource = 0xc sizeofGroupReq = 0x84 sizeofGroupSourceReq = 0x104 ) type sockaddrStorage struct { Len uint8 Family uint8 X__ss_pad1 [6]int8 X__ss_align int64 X__ss_pad2 [112]int8 } type sockaddrInet struct { Len uint8 Family uint8 Port uint16 Addr [4]byte /* in_addr / Zero [8]int8 } type inetPktinfo struct { Ifindex uint32 Spec_dst [4]byte / in_addr / Addr [4]byte / in_addr / } type ipMreq struct { Multiaddr [4]byte / in_addr / Interface [4]byte / in_addr / } type ipMreqSource struct { Multiaddr [4]byte / in_addr / Sourceaddr [4]byte / in_addr / Interface [4]byte / in_addr */ } 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.03 KB	2025-05-25 12:27
📄 zsys_dragonfly.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_dragonfly.go package ipv4 const ( sizeofIPMreq = 0x8 ) type ipMreq struct { Multiaddr [4]byte /* in_addr / Interface [4]byte / in_addr */ }	219 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 ipv4 const ( sizeofSockaddrStorage = 0x80 sizeofSockaddrInet = 0x10 sizeofIPMreq = 0x8 sizeofIPMreqSource = 0xc sizeofGroupReq = 0x84 sizeofGroupSourceReq = 0x104 ) type sockaddrStorage struct { Len uint8 Family uint8 X__ss_pad1 [6]int8 X__ss_align int64 X__ss_pad2 [112]int8 } type sockaddrInet struct { Len uint8 Family uint8 Port uint16 Addr [4]byte /* in_addr / Zero [8]int8 } type ipMreq struct { Multiaddr [4]byte / in_addr / Interface [4]byte / in_addr / } type ipMreqSource struct { Multiaddr [4]byte / in_addr / Sourceaddr [4]byte / in_addr / Interface [4]byte / in_addr */ } type groupReq struct { Interface uint32 Group sockaddrStorage } type groupSourceReq struct { Interface uint32 Group sockaddrStorage Source sockaddrStorage }	933 B	2025-05-25 12:27
📄 zsys_freebsd_amd64.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_freebsd.go package ipv4 const ( sizeofSockaddrStorage = 0x80 sizeofSockaddrInet = 0x10 sizeofIPMreq = 0x8 sizeofIPMreqSource = 0xc sizeofGroupReq = 0x88 sizeofGroupSourceReq = 0x108 ) type sockaddrStorage struct { Len uint8 Family uint8 X__ss_pad1 [6]int8 X__ss_align int64 X__ss_pad2 [112]int8 } type sockaddrInet struct { Len uint8 Family uint8 Port uint16 Addr [4]byte /* in_addr / Zero [8]int8 } type ipMreq struct { Multiaddr [4]byte / in_addr / Interface [4]byte / in_addr / } type ipMreqSource struct { Multiaddr [4]byte / in_addr / Sourceaddr [4]byte / in_addr / Interface [4]byte / in_addr */ } 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 }	971 B	2025-05-25 12:27
📄 zsys_freebsd_arm.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_freebsd.go package ipv4 const ( sizeofSockaddrStorage = 0x80 sizeofSockaddrInet = 0x10 sizeofIPMreq = 0x8 sizeofIPMreqSource = 0xc sizeofGroupReq = 0x88 sizeofGroupSourceReq = 0x108 ) type sockaddrStorage struct { Len uint8 Family uint8 X__ss_pad1 [6]int8 X__ss_align int64 X__ss_pad2 [112]int8 } type sockaddrInet struct { Len uint8 Family uint8 Port uint16 Addr [4]byte /* in_addr / Zero [8]int8 } type ipMreq struct { Multiaddr [4]byte / in_addr / Interface [4]byte / in_addr / } type ipMreqSource struct { Multiaddr [4]byte / in_addr / Sourceaddr [4]byte / in_addr / Interface [4]byte / in_addr */ } 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 }	971 B	2025-05-25 12:27
📄 zsys_freebsd_arm64.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_freebsd.go package ipv4 const ( sizeofSockaddrStorage = 0x80 sizeofSockaddrInet = 0x10 sizeofIPMreq = 0x8 sizeofIPMreqSource = 0xc sizeofGroupReq = 0x88 sizeofGroupSourceReq = 0x108 ) type sockaddrStorage struct { Len uint8 Family uint8 X__ss_pad1 [6]uint8 X__ss_align int64 X__ss_pad2 [112]uint8 } type sockaddrInet struct { Len uint8 Family uint8 Port uint16 Addr [4]byte /* in_addr / Zero [8]uint8 } type ipMreq struct { Multiaddr [4]byte / in_addr / Interface [4]byte / in_addr / } type ipMreqSource struct { Multiaddr [4]byte / in_addr / Sourceaddr [4]byte / in_addr / Interface [4]byte / in_addr */ } type groupReq struct { Interface uint32 Group sockaddrStorage } type groupSourceReq struct { Interface uint32 Group sockaddrStorage Source sockaddrStorage }	936 B	2025-05-25 12:27
📄 zsys_freebsd_riscv64.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_freebsd.go package ipv4 const ( sizeofSockaddrStorage = 0x80 sizeofSockaddrInet = 0x10 sizeofIPMreq = 0x8 sizeofIPMreqSource = 0xc sizeofGroupReq = 0x88 sizeofGroupSourceReq = 0x108 ) type sockaddrStorage struct { Len uint8 Family uint8 X__ss_pad1 [6]uint8 X__ss_align int64 X__ss_pad2 [112]uint8 } type sockaddrInet struct { Len uint8 Family uint8 Port uint16 Addr [4]byte /* in_addr / Zero [8]uint8 } type ipMreq struct { Multiaddr [4]byte / in_addr / Interface [4]byte / in_addr / } type ipMreqSource struct { Multiaddr [4]byte / in_addr / Sourceaddr [4]byte / in_addr / Interface [4]byte / in_addr */ } type groupReq struct { Interface uint32 Group sockaddrStorage } type groupSourceReq struct { Interface uint32 Group sockaddrStorage Source sockaddrStorage }	936 B	2025-05-25 12:27
📄 zsys_linux_386.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_linux.go package ipv4 const ( sizeofKernelSockaddrStorage = 0x80 sizeofSockaddrInet = 0x10 sizeofInetPktinfo = 0xc sizeofSockExtendedErr = 0x10 sizeofIPMreq = 0x8 sizeofIPMreqSource = 0xc sizeofGroupReq = 0x84 sizeofGroupSourceReq = 0x104 sizeofICMPFilter = 0x4 ) type kernelSockaddrStorage struct { Family uint16 X__data [126]int8 } type sockaddrInet struct { Family uint16 Port uint16 Addr [4]byte /* in_addr / X__pad [8]uint8 } type inetPktinfo struct { Ifindex int32 Spec_dst [4]byte / in_addr / Addr [4]byte / in_addr / } type sockExtendedErr struct { Errno uint32 Origin uint8 Type uint8 Code uint8 Pad uint8 Info uint32 Data uint32 } type ipMreq struct { Multiaddr [4]byte / in_addr / Interface [4]byte / in_addr */ } type ipMreqSource struct { Multiaddr uint32 Interface uint32 Sourceaddr uint32 } type groupReq struct { Interface uint32 Group kernelSockaddrStorage } type groupSourceReq struct { Interface uint32 Group kernelSockaddrStorage Source kernelSockaddrStorage } type icmpFilter struct { Data uint32 }	1.2 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 ipv4 const ( sizeofKernelSockaddrStorage = 0x80 sizeofSockaddrInet = 0x10 sizeofInetPktinfo = 0xc sizeofSockExtendedErr = 0x10 sizeofIPMreq = 0x8 sizeofIPMreqSource = 0xc sizeofGroupReq = 0x88 sizeofGroupSourceReq = 0x108 sizeofICMPFilter = 0x4 ) type kernelSockaddrStorage struct { Family uint16 X__data [126]int8 } type sockaddrInet struct { Family uint16 Port uint16 Addr [4]byte /* in_addr / X__pad [8]uint8 } type inetPktinfo struct { Ifindex int32 Spec_dst [4]byte / in_addr / Addr [4]byte / in_addr / } type sockExtendedErr struct { Errno uint32 Origin uint8 Type uint8 Code uint8 Pad uint8 Info uint32 Data uint32 } type ipMreq struct { Multiaddr [4]byte / in_addr / Interface [4]byte / in_addr */ } type ipMreqSource struct { Multiaddr uint32 Interface uint32 Sourceaddr uint32 } 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 icmpFilter struct { Data uint32 }	1.23 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 ipv4 const ( sizeofKernelSockaddrStorage = 0x80 sizeofSockaddrInet = 0x10 sizeofInetPktinfo = 0xc sizeofSockExtendedErr = 0x10 sizeofIPMreq = 0x8 sizeofIPMreqSource = 0xc sizeofGroupReq = 0x84 sizeofGroupSourceReq = 0x104 sizeofICMPFilter = 0x4 ) type kernelSockaddrStorage struct { Family uint16 X__data [126]int8 } type sockaddrInet struct { Family uint16 Port uint16 Addr [4]byte /* in_addr / X__pad [8]uint8 } type inetPktinfo struct { Ifindex int32 Spec_dst [4]byte / in_addr / Addr [4]byte / in_addr / } type sockExtendedErr struct { Errno uint32 Origin uint8 Type uint8 Code uint8 Pad uint8 Info uint32 Data uint32 } type ipMreq struct { Multiaddr [4]byte / in_addr / Interface [4]byte / in_addr */ } type ipMreqSource struct { Multiaddr uint32 Interface uint32 Sourceaddr uint32 } type groupReq struct { Interface uint32 Group kernelSockaddrStorage } type groupSourceReq struct { Interface uint32 Group kernelSockaddrStorage Source kernelSockaddrStorage } type icmpFilter struct { Data uint32 }	1.2 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 ipv4 const ( sizeofKernelSockaddrStorage = 0x80 sizeofSockaddrInet = 0x10 sizeofInetPktinfo = 0xc sizeofSockExtendedErr = 0x10 sizeofIPMreq = 0x8 sizeofIPMreqSource = 0xc sizeofGroupReq = 0x88 sizeofGroupSourceReq = 0x108 sizeofICMPFilter = 0x4 ) type kernelSockaddrStorage struct { Family uint16 X__data [126]int8 } type sockaddrInet struct { Family uint16 Port uint16 Addr [4]byte /* in_addr / X__pad [8]uint8 } type inetPktinfo struct { Ifindex int32 Spec_dst [4]byte / in_addr / Addr [4]byte / in_addr / } type sockExtendedErr struct { Errno uint32 Origin uint8 Type uint8 Code uint8 Pad uint8 Info uint32 Data uint32 } type ipMreq struct { Multiaddr [4]byte / in_addr / Interface [4]byte / in_addr */ } type ipMreqSource struct { Multiaddr uint32 Interface uint32 Sourceaddr uint32 } 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 icmpFilter struct { Data uint32 }	1.23 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 ipv4 const ( sizeofKernelSockaddrStorage = 0x80 sizeofSockaddrInet = 0x10 sizeofInetPktinfo = 0xc sizeofSockExtendedErr = 0x10 sizeofIPMreq = 0x8 sizeofIPMreqSource = 0xc sizeofGroupReq = 0x88 sizeofGroupSourceReq = 0x108 sizeofICMPFilter = 0x4 ) type kernelSockaddrStorage struct { Family uint16 X__data [126]int8 } type sockaddrInet struct { Family uint16 Port uint16 Addr [4]byte /* in_addr / X__pad [8]uint8 } type inetPktinfo struct { Ifindex int32 Spec_dst [4]byte / in_addr / Addr [4]byte / in_addr / } type sockExtendedErr struct { Errno uint32 Origin uint8 Type uint8 Code uint8 Pad uint8 Info uint32 Data uint32 } type ipMreq struct { Multiaddr [4]byte / in_addr / Interface [4]byte / in_addr */ } type ipMreqSource struct { Multiaddr uint32 Interface uint32 Sourceaddr uint32 } 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 icmpFilter struct { Data uint32 }	1.25 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 ipv4 const ( sizeofKernelSockaddrStorage = 0x80 sizeofSockaddrInet = 0x10 sizeofInetPktinfo = 0xc sizeofSockExtendedErr = 0x10 sizeofIPMreq = 0x8 sizeofIPMreqSource = 0xc sizeofGroupReq = 0x84 sizeofGroupSourceReq = 0x104 sizeofICMPFilter = 0x4 ) type kernelSockaddrStorage struct { Family uint16 X__data [126]int8 } type sockaddrInet struct { Family uint16 Port uint16 Addr [4]byte /* in_addr / X__pad [8]uint8 } type inetPktinfo struct { Ifindex int32 Spec_dst [4]byte / in_addr / Addr [4]byte / in_addr / } type sockExtendedErr struct { Errno uint32 Origin uint8 Type uint8 Code uint8 Pad uint8 Info uint32 Data uint32 } type ipMreq struct { Multiaddr [4]byte / in_addr / Interface [4]byte / in_addr */ } type ipMreqSource struct { Multiaddr uint32 Interface uint32 Sourceaddr uint32 } type groupReq struct { Interface uint32 Group kernelSockaddrStorage } type groupSourceReq struct { Interface uint32 Group kernelSockaddrStorage Source kernelSockaddrStorage } type icmpFilter struct { Data uint32 }	1.2 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 ipv4 const ( sizeofKernelSockaddrStorage = 0x80 sizeofSockaddrInet = 0x10 sizeofInetPktinfo = 0xc sizeofSockExtendedErr = 0x10 sizeofIPMreq = 0x8 sizeofIPMreqSource = 0xc sizeofGroupReq = 0x88 sizeofGroupSourceReq = 0x108 sizeofICMPFilter = 0x4 ) type kernelSockaddrStorage struct { Family uint16 X__data [126]int8 } type sockaddrInet struct { Family uint16 Port uint16 Addr [4]byte /* in_addr / X__pad [8]uint8 } type inetPktinfo struct { Ifindex int32 Spec_dst [4]byte / in_addr / Addr [4]byte / in_addr / } type sockExtendedErr struct { Errno uint32 Origin uint8 Type uint8 Code uint8 Pad uint8 Info uint32 Data uint32 } type ipMreq struct { Multiaddr [4]byte / in_addr / Interface [4]byte / in_addr */ } type ipMreqSource struct { Multiaddr uint32 Interface uint32 Sourceaddr uint32 } 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 icmpFilter struct { Data uint32 }	1.23 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 ipv4 const ( sizeofKernelSockaddrStorage = 0x80 sizeofSockaddrInet = 0x10 sizeofInetPktinfo = 0xc sizeofSockExtendedErr = 0x10 sizeofIPMreq = 0x8 sizeofIPMreqSource = 0xc sizeofGroupReq = 0x88 sizeofGroupSourceReq = 0x108 sizeofICMPFilter = 0x4 ) type kernelSockaddrStorage struct { Family uint16 X__data [126]int8 } type sockaddrInet struct { Family uint16 Port uint16 Addr [4]byte /* in_addr / X__pad [8]uint8 } type inetPktinfo struct { Ifindex int32 Spec_dst [4]byte / in_addr / Addr [4]byte / in_addr / } type sockExtendedErr struct { Errno uint32 Origin uint8 Type uint8 Code uint8 Pad uint8 Info uint32 Data uint32 } type ipMreq struct { Multiaddr [4]byte / in_addr / Interface [4]byte / in_addr */ } type ipMreqSource struct { Multiaddr uint32 Interface uint32 Sourceaddr uint32 } 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 icmpFilter struct { Data uint32 }	1.23 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 ipv4 const ( sizeofKernelSockaddrStorage = 0x80 sizeofSockaddrInet = 0x10 sizeofInetPktinfo = 0xc sizeofSockExtendedErr = 0x10 sizeofIPMreq = 0x8 sizeofIPMreqSource = 0xc sizeofGroupReq = 0x84 sizeofGroupSourceReq = 0x104 sizeofICMPFilter = 0x4 ) type kernelSockaddrStorage struct { Family uint16 X__data [126]int8 } type sockaddrInet struct { Family uint16 Port uint16 Addr [4]byte /* in_addr / X__pad [8]uint8 } type inetPktinfo struct { Ifindex int32 Spec_dst [4]byte / in_addr / Addr [4]byte / in_addr / } type sockExtendedErr struct { Errno uint32 Origin uint8 Type uint8 Code uint8 Pad uint8 Info uint32 Data uint32 } type ipMreq struct { Multiaddr [4]byte / in_addr / Interface [4]byte / in_addr */ } type ipMreqSource struct { Multiaddr uint32 Interface uint32 Sourceaddr uint32 } type groupReq struct { Interface uint32 Group kernelSockaddrStorage } type groupSourceReq struct { Interface uint32 Group kernelSockaddrStorage Source kernelSockaddrStorage } type icmpFilter struct { Data uint32 }	1.2 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 ipv4 const ( sizeofKernelSockaddrStorage = 0x80 sizeofSockaddrInet = 0x10 sizeofInetPktinfo = 0xc sizeofSockExtendedErr = 0x10 sizeofIPMreq = 0x8 sizeofIPMreqSource = 0xc sizeofGroupReq = 0x84 sizeofGroupSourceReq = 0x104 sizeofICMPFilter = 0x4 ) type kernelSockaddrStorage struct { Family uint16 X__data [126]uint8 } type sockaddrInet struct { Family uint16 Port uint16 Addr [4]byte /* in_addr / X__pad [8]uint8 } type inetPktinfo struct { Ifindex int32 Spec_dst [4]byte / in_addr / Addr [4]byte / in_addr / } type sockExtendedErr struct { Errno uint32 Origin uint8 Type uint8 Code uint8 Pad uint8 Info uint32 Data uint32 } type ipMreq struct { Multiaddr [4]byte / in_addr / Interface [4]byte / in_addr */ } type ipMreqSource struct { Multiaddr uint32 Interface uint32 Sourceaddr uint32 } type groupReq struct { Interface uint32 Group kernelSockaddrStorage } type groupSourceReq struct { Interface uint32 Group kernelSockaddrStorage Source kernelSockaddrStorage } type icmpFilter struct { Data uint32 }	1.2 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 ipv4 const ( sizeofKernelSockaddrStorage = 0x80 sizeofSockaddrInet = 0x10 sizeofInetPktinfo = 0xc sizeofSockExtendedErr = 0x10 sizeofIPMreq = 0x8 sizeofIPMreqSource = 0xc sizeofGroupReq = 0x88 sizeofGroupSourceReq = 0x108 sizeofICMPFilter = 0x4 ) type kernelSockaddrStorage struct { Family uint16 X__data [126]int8 } type sockaddrInet struct { Family uint16 Port uint16 Addr [4]byte /* in_addr / X__pad [8]uint8 } type inetPktinfo struct { Ifindex int32 Spec_dst [4]byte / in_addr / Addr [4]byte / in_addr / } type sockExtendedErr struct { Errno uint32 Origin uint8 Type uint8 Code uint8 Pad uint8 Info uint32 Data uint32 } type ipMreq struct { Multiaddr [4]byte / in_addr / Interface [4]byte / in_addr */ } type ipMreqSource struct { Multiaddr uint32 Interface uint32 Sourceaddr uint32 } 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 icmpFilter struct { Data uint32 }	1.23 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 ipv4 const ( sizeofKernelSockaddrStorage = 0x80 sizeofSockaddrInet = 0x10 sizeofInetPktinfo = 0xc sizeofSockExtendedErr = 0x10 sizeofIPMreq = 0x8 sizeofIPMreqSource = 0xc sizeofGroupReq = 0x88 sizeofGroupSourceReq = 0x108 sizeofICMPFilter = 0x4 ) type kernelSockaddrStorage struct { Family uint16 X__data [126]int8 } type sockaddrInet struct { Family uint16 Port uint16 Addr [4]byte /* in_addr / X__pad [8]uint8 } type inetPktinfo struct { Ifindex int32 Spec_dst [4]byte / in_addr / Addr [4]byte / in_addr / } type sockExtendedErr struct { Errno uint32 Origin uint8 Type uint8 Code uint8 Pad uint8 Info uint32 Data uint32 } type ipMreq struct { Multiaddr [4]byte / in_addr / Interface [4]byte / in_addr */ } type ipMreqSource struct { Multiaddr uint32 Interface uint32 Sourceaddr uint32 } 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 icmpFilter struct { Data uint32 }	1.23 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 ipv4 const ( sizeofKernelSockaddrStorage = 0x80 sizeofSockaddrInet = 0x10 sizeofInetPktinfo = 0xc sizeofSockExtendedErr = 0x10 sizeofIPMreq = 0x8 sizeofIPMreqSource = 0xc sizeofGroupReq = 0x88 sizeofGroupSourceReq = 0x108 sizeofICMPFilter = 0x4 ) type kernelSockaddrStorage struct { Family uint16 X__data [126]int8 } type sockaddrInet struct { Family uint16 Port uint16 Addr [4]byte /* in_addr / X__pad [8]uint8 } type inetPktinfo struct { Ifindex int32 Spec_dst [4]byte / in_addr / Addr [4]byte / in_addr / } type sockExtendedErr struct { Errno uint32 Origin uint8 Type uint8 Code uint8 Pad uint8 Info uint32 Data uint32 } type ipMreq struct { Multiaddr [4]byte / in_addr / Interface [4]byte / in_addr */ } type ipMreqSource struct { Multiaddr uint32 Interface uint32 Sourceaddr uint32 } 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 icmpFilter struct { Data uint32 }	1.25 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 ipv4 const ( sizeofKernelSockaddrStorage = 0x80 sizeofSockaddrInet = 0x10 sizeofInetPktinfo = 0xc sizeofSockExtendedErr = 0x10 sizeofIPMreq = 0x8 sizeofIPMreqSource = 0xc sizeofGroupReq = 0x88 sizeofGroupSourceReq = 0x108 sizeofICMPFilter = 0x4 ) type kernelSockaddrStorage struct { Family uint16 X__data [126]int8 } type sockaddrInet struct { Family uint16 Port uint16 Addr [4]byte /* in_addr / X__pad [8]uint8 } type inetPktinfo struct { Ifindex int32 Spec_dst [4]byte / in_addr / Addr [4]byte / in_addr / } type sockExtendedErr struct { Errno uint32 Origin uint8 Type uint8 Code uint8 Pad uint8 Info uint32 Data uint32 } type ipMreq struct { Multiaddr [4]byte / in_addr / Interface [4]byte / in_addr */ } type ipMreqSource struct { Multiaddr uint32 Interface uint32 Sourceaddr uint32 } 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 icmpFilter struct { Data uint32 }	1.23 KB	2025-05-25 12:27
📄 zsys_netbsd.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_netbsd.go package ipv4 const ( sizeofIPMreq = 0x8 ) type ipMreq struct { Multiaddr [4]byte /* in_addr / Interface [4]byte / in_addr */ }	216 B	2025-05-25 12:27
📄 zsys_openbsd.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_openbsd.go package ipv4 const ( sizeofIPMreq = 0x8 ) type ipMreq struct { Multiaddr [4]byte /* in_addr / Interface [4]byte / in_addr */ }	217 B	2025-05-25 12:27
📄 zsys_solaris.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_solaris.go package ipv4 const ( sizeofSockaddrStorage = 0x100 sizeofSockaddrInet = 0x10 sizeofInetPktinfo = 0xc sizeofIPMreq = 0x8 sizeofIPMreqSource = 0xc sizeofGroupReq = 0x104 sizeofGroupSourceReq = 0x204 ) type sockaddrStorage struct { Family uint16 X_ss_pad1 [6]int8 X_ss_align float64 X_ss_pad2 [240]int8 } type sockaddrInet struct { Family uint16 Port uint16 Addr [4]byte /* in_addr / Zero [8]int8 } type inetPktinfo struct { Ifindex uint32 Spec_dst [4]byte / in_addr / Addr [4]byte / in_addr / } type ipMreq struct { Multiaddr [4]byte / in_addr / Interface [4]byte / in_addr / } type ipMreqSource struct { Multiaddr [4]byte / in_addr / Sourceaddr [4]byte / in_addr / Interface [4]byte / in_addr */ } 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 }	1023 B	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 ipv4 const ( sizeofIPMreq = 8 sizeofSockaddrInet4 = 16 sizeofSockaddrStorage = 128 sizeofGroupReq = 136 sizeofGroupSourceReq = 264 sizeofInetPktinfo = 8 ) type sockaddrInet4 struct { Len uint8 Family uint8 Port uint16 Addr [4]byte Zero [8]uint8 } type inetPktinfo struct { Addr [4]byte Ifindex uint32 } type sockaddrStorage struct { Len uint8 Family byte ss_pad1 [6]byte ss_align int64 ss_pad2 [112]byte } type groupReq struct { Interface uint32 reserved uint32 Group sockaddrStorage } type groupSourceReq struct { Interface uint32 reserved uint32 Group sockaddrStorage Source sockaddrStorage } type ipMreq struct { Multiaddr [4]byte /* in_addr / Interface [4]byte / in_addr */ }	1 KB	2025-05-25 12:27

Edit File:

Terminal