package ipv4

Import Path
	golang.org/x/net/ipv4 (on go.dev)

Dependency Relation
	imports 13 packages, and imported by 6 packages

Involved Source Files

	    batch.go
	    control.go
	    control_pktinfo.go
	    control_unix.go
	    dgramopt.go
	  d doc.go
		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.

	    endpoint.go
	    genericopt.go
	    header.go
	    helper.go
	    iana.go
	    icmp.go
	    icmp_linux.go
	    packet.go
	    payload.go
	    payload_cmsg.go
	    sockopt.go
	    sockopt_posix.go
	    sys_asmreq_stub.go
	    sys_asmreqn.go
	    sys_bpf.go
	    sys_linux.go
	    sys_ssmreq.go
	    zsys_linux_amd64.go
Code Examples

	Conn_markingTCP
		package main
		
		import (
			"log"
			"net"
		
			"golang.org/x/net/ipv4"
		)
		
		func main() {
			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)
			}
		}

	PacketConn_servingOneShotMulticastDNS
		package main
		
		import (
			"log"
			"net"
		
			"golang.org/x/net/ipv4"
		)
		
		func main() {
			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)
				}
			}
		}

	PacketConn_tracingIPPacketRoute
		package main
		
		import (
			"fmt"
			"log"
			"net"
			"os"
			"time"
		
			"golang.org/x/net/icmp"
			"golang.org/x/net/ipv4"
		)
		
		func main() {
			// 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)
				}
			}
		}

	RawConn_advertisingOSPFHello
		package main
		
		import (
			"log"
			"net"
			"runtime"
		
			"golang.org/x/net/ipv4"
		)
		
		func main() {
			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)
			}
		}


Package-Level Type Names (total 10)

	/* sort by: alphabet | popularity */
	 type Conn (struct)
		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.

		Fields (only one)
			genericOpt.Conn *socket.Conn
		Methods (total 8)
			( Conn) RecvMsg(m *socket.Message, flags int) error
				RecvMsg wraps recvmsg system call.
				
				The provided flags is a set of platform-dependent flags, such as
				syscall.MSG_PEEK.

			( Conn) RecvMsgs(ms []socket.Message, flags int) (int, error)
				RecvMsgs wraps recvmmsg system call.
				
				It returns the number of processed messages.
				
				The provided flags is a set of platform-dependent flags, such as
				syscall.MSG_PEEK.
				
				Only Linux supports this.

			( Conn) SendMsg(m *socket.Message, flags int) error
				SendMsg wraps sendmsg system call.
				
				The provided flags is a set of platform-dependent flags, such as
				syscall.MSG_DONTROUTE.

			( Conn) SendMsgs(ms []socket.Message, flags int) (int, error)
				SendMsgs wraps sendmmsg system call.
				
				It returns the number of processed messages.
				
				The provided flags is a set of platform-dependent flags, such as
				syscall.MSG_DONTROUTE.
				
				Only Linux supports this.

			(*Conn) SetTOS(tos int) error
				SetTOS sets the type-of-service field value for future outgoing
				packets.

			(*Conn) SetTTL(ttl int) error
				SetTTL sets the time-to-live field value for future outgoing
				packets.

			(*Conn) TOS() (int, error)
				TOS returns the type-of-service field value for outgoing packets.

			(*Conn) TTL() (int, error)
				TTL returns the time-to-live field value for outgoing packets.

		As Outputs Of (at least one exported)
			func NewConn(c net.Conn) *Conn

	 type ControlFlags uint (basic type)

		As Inputs Of (at least 3)
			func NewControlMessage(cf ControlFlags) []byte
			func (*PacketConn).SetControlMessage(cf ControlFlags, on bool) error
			func (*RawConn).SetControlMessage(cf ControlFlags, on bool) error
		As Types Of (total 4)
			const FlagDst
			const FlagInterface
			const FlagSrc
			const FlagTTL

	 type ControlMessage (struct)
		A ControlMessage represents per packet basis IP-level socket options.

		Fields (total 4)
			Dst net.IP
				// destination address, receiving only

			IfIndex int
				// interface index, must be 1 <= value when specifying

			Src net.IP
				// source address, specifying only

			TTL int
				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.
				// time-to-live, receiving only

		Methods (total 3)
			(*ControlMessage) Marshal() []byte
				Marshal returns the binary encoding of cm.

			(*ControlMessage) Parse(b []byte) error
				Parse parses b as a control message and stores the result in cm.

			(*ControlMessage) String() string
		Implements (at least 2)
			*ControlMessage : expvar.Var
			*ControlMessage : fmt.Stringer

	 type Header (struct)
		A Header represents an IPv4 header.

		Fields (total 13)
			Checksum int
				// checksum

			Dst net.IP
				// destination address

			Flags HeaderFlags
				// flags

			FragOff int
				// fragment offset

			ID int
				// identification

			Len int
				// header length

			Options []byte
				// options, extension headers

			Protocol int
				// next protocol

			Src net.IP
				// source address

			TOS int
				// type-of-service

			TTL int
				// time-to-live

			TotalLen int
				// packet total length

			Version int
				// protocol version

		Methods (total 3)
			(*Header) Marshal() ([]byte, error)
				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.

			(*Header) Parse(b []byte) error
				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.

			(*Header) String() string
		Implements (at least 4)
			*Header : expvar.Var
			*Header : fmt.Stringer
			*Header : github.com/gogo/protobuf/proto.Marshaler
			*Header : github.com/golang/protobuf/proto.Marshaler
		As Outputs Of (at least one exported)
			func ParseHeader(b []byte) (*Header, error)

	 type HeaderFlags int (basic type)

		As Types Of (total 2)
			const DontFragment
			const MoreFragments

	 type ICMPFilter (struct)
		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.

		Fields (only one)
			icmpFilter.Data uint32
		Methods (total 4)
			(*ICMPFilter) Accept(typ ICMPType)
				Accept accepts incoming ICMP packets including the type field value
				typ.

			(*ICMPFilter) Block(typ ICMPType)
				Block blocks incoming ICMP packets including the type field value
				typ.

			(*ICMPFilter) SetAll(block bool)
				SetAll sets the filter action to the filter.

			(*ICMPFilter) WillBlock(typ ICMPType) bool
				WillBlock reports whether the ICMP type will be blocked.


	 type ICMPType int (basic type)
		An ICMPType represents a type of ICMP message.

		Methods (total 2)
			( ICMPType) Protocol() int
				Protocol returns the ICMPv4 protocol number.

			( ICMPType) String() string
		Implements (at least 2)
			 ICMPType : expvar.Var
			 ICMPType : fmt.Stringer
		As Inputs Of (at least 3)
			func (*ICMPFilter).Accept(typ ICMPType)
			func (*ICMPFilter).Block(typ ICMPType)
			func (*ICMPFilter).WillBlock(typ ICMPType) bool
		As Types Of (total 13)
			const ICMPTypeDestinationUnreachable
			const ICMPTypeEcho
			const ICMPTypeEchoReply
			const ICMPTypeExtendedEchoReply
			const ICMPTypeExtendedEchoRequest
			const ICMPTypeParameterProblem
			const ICMPTypePhoturis
			const ICMPTypeRedirect
			const ICMPTypeRouterAdvertisement
			const ICMPTypeRouterSolicitation
			const ICMPTypeTimeExceeded
			const ICMPTypeTimestamp
			const ICMPTypeTimestampReply

	 type Message = socket.Message (struct)
		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 PacketConn (struct)
		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.

		Fields (total 2)
			payloadHandler.PacketConn net.PacketConn
			payloadHandler.rawOpt.RWMutex sync.RWMutex
		Methods (total 36)
			(*PacketConn) Close() error
				Close closes the endpoint.

			(*PacketConn) ExcludeSourceSpecificGroup(ifi *net.Interface, group, source net.Addr) error
				ExcludeSourceSpecificGroup excludes the source-specific group from
				the already joined any-source groups by JoinGroup on the interface
				ifi.

			(*PacketConn) ICMPFilter() (*ICMPFilter, error)
				ICMPFilter returns an ICMP filter.
				Currently only Linux supports this.

			(*PacketConn) IncludeSourceSpecificGroup(ifi *net.Interface, group, source net.Addr) error
				IncludeSourceSpecificGroup includes the excluded source-specific
				group by ExcludeSourceSpecificGroup again on the interface ifi.

			(*PacketConn) JoinGroup(ifi *net.Interface, group net.Addr) error
				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.

			(*PacketConn) JoinSourceSpecificGroup(ifi *net.Interface, group, source net.Addr) error
				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.

			(*PacketConn) LeaveGroup(ifi *net.Interface, group net.Addr) error
				LeaveGroup leaves the group address group on the interface ifi
				regardless of whether the group is any-source group or
				source-specific group.

			(*PacketConn) LeaveSourceSpecificGroup(ifi *net.Interface, group, source net.Addr) error
				LeaveSourceSpecificGroup leaves the source-specific group on the
				interface ifi.

			( PacketConn) LocalAddr() net.Addr
				LocalAddr returns the local network address, if known.

			(*PacketConn) Lock()
				Lock locks rw for writing.
				If the lock is already locked for reading or writing,
				Lock blocks until the lock is available.

			(*PacketConn) MulticastInterface() (*net.Interface, error)
				MulticastInterface returns the default interface for multicast
				packet transmissions.

			(*PacketConn) MulticastLoopback() (bool, error)
				MulticastLoopback reports whether transmitted multicast packets
				should be copied and send back to the originator.

			(*PacketConn) MulticastTTL() (int, error)
				MulticastTTL returns the time-to-live field value for outgoing
				multicast packets.

			(*PacketConn) RLock()
				RLock locks rw for reading.
				
				It should not be used for recursive read locking; a blocked Lock
				call excludes new readers from acquiring the lock. See the
				documentation on the [RWMutex] type.

			(*PacketConn) RLocker() sync.Locker
				RLocker returns a [Locker] interface that implements
				the [Locker.Lock] and [Locker.Unlock] methods by calling rw.RLock and rw.RUnlock.

			(*PacketConn) RUnlock()
				RUnlock undoes a single [RWMutex.RLock] call;
				it does not affect other simultaneous readers.
				It is a run-time error if rw is not locked for reading
				on entry to RUnlock.

			(*PacketConn) ReadBatch(ms []Message, flags int) (int, error)
				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.

			(*PacketConn) ReadFrom(b []byte) (n int, cm *ControlMessage, src net.Addr, err error)
				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.

			(*PacketConn) SetBPF(filter []bpf.RawInstruction) error
				SetBPF attaches a BPF program to the connection.
				
				Only supported on Linux.

			(*PacketConn) SetControlMessage(cf ControlFlags, on bool) error
				SetControlMessage sets the per packet IP-level socket options.

			(*PacketConn) SetDeadline(t time.Time) error
				SetDeadline sets the read and write deadlines associated with the
				endpoint.

			(*PacketConn) SetICMPFilter(f *ICMPFilter) error
				SetICMPFilter deploys the ICMP filter.
				Currently only Linux supports this.

			(*PacketConn) SetMulticastInterface(ifi *net.Interface) error
				SetMulticastInterface sets the default interface for future
				multicast packet transmissions.

			(*PacketConn) SetMulticastLoopback(on bool) error
				SetMulticastLoopback sets whether transmitted multicast packets
				should be copied and send back to the originator.

			(*PacketConn) SetMulticastTTL(ttl int) error
				SetMulticastTTL sets the time-to-live field value for future
				outgoing multicast packets.

			(*PacketConn) SetReadDeadline(t time.Time) error
				SetReadDeadline sets the read deadline associated with the
				endpoint.

			(*PacketConn) SetTOS(tos int) error
				SetTOS sets the type-of-service field value for future outgoing
				packets.

			(*PacketConn) SetTTL(ttl int) error
				SetTTL sets the time-to-live field value for future outgoing
				packets.

			(*PacketConn) SetWriteDeadline(t time.Time) error
				SetWriteDeadline sets the write deadline associated with the
				endpoint.

			(*PacketConn) TOS() (int, error)
				TOS returns the type-of-service field value for outgoing packets.

			(*PacketConn) TTL() (int, error)
				TTL returns the time-to-live field value for outgoing packets.

			(*PacketConn) TryLock() bool
				TryLock tries to lock rw for writing and reports whether it succeeded.
				
				Note that while correct uses of TryLock do exist, they are rare,
				and use of TryLock is often a sign of a deeper problem
				in a particular use of mutexes.

			(*PacketConn) TryRLock() bool
				TryRLock tries to lock rw for reading and reports whether it succeeded.
				
				Note that while correct uses of TryRLock do exist, they are rare,
				and use of TryRLock is often a sign of a deeper problem
				in a particular use of mutexes.

			(*PacketConn) Unlock()
				Unlock unlocks rw for writing. It is a run-time error if rw is
				not locked for writing on entry to Unlock.
				
				As with Mutexes, a locked [RWMutex] is not associated with a particular
				goroutine. One goroutine may [RWMutex.RLock] ([RWMutex.Lock]) a RWMutex and then
				arrange for another goroutine to [RWMutex.RUnlock] ([RWMutex.Unlock]) it.

			(*PacketConn) WriteBatch(ms []Message, flags int) (int, error)
				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.

			(*PacketConn) WriteTo(b []byte, cm *ControlMessage, dst net.Addr) (n int, err error)
				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.

		Implements (at least 9)
			*PacketConn : golang.org/x/net/bpf.Setter
			*PacketConn : github.com/pion/datachannel.ReadDeadliner
			*PacketConn : github.com/pion/datachannel.WriteDeadliner
			*PacketConn : github.com/pion/transport/v2/udp.BatchPacketConn
			*PacketConn : github.com/pion/transport/v2/udp.BatchReader
			*PacketConn : github.com/pion/transport/v2/udp.BatchWriter
			*PacketConn : github.com/prometheus/common/expfmt.Closer
			*PacketConn : io.Closer
			*PacketConn : sync.Locker
		As Outputs Of (at least one exported)
			func NewPacketConn(c net.PacketConn) *PacketConn
		As Inputs Of (at least one exported)
			func github.com/pion/mdns/v2.Server(multicastPktConnV4 *PacketConn, multicastPktConnV6 *ipv6.PacketConn, config *mdns.Config) (*mdns.Conn, error)

	 type RawConn (struct)
		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.

		Fields (total 2)
			packetHandler.IPConn *net.IPConn
			packetHandler.rawOpt.RWMutex sync.RWMutex
		Methods (total 47)
			(*RawConn) Close() error
				Close closes the endpoint.

			(*RawConn) ExcludeSourceSpecificGroup(ifi *net.Interface, group, source net.Addr) error
				ExcludeSourceSpecificGroup excludes the source-specific group from
				the already joined any-source groups by JoinGroup on the interface
				ifi.

			( RawConn) File() (f *os.File, err error)
				File returns a copy of the underlying [os.File].
				It is the caller's responsibility to close f when finished.
				Closing c does not affect f, and closing f does not affect c.
				
				The returned os.File's file descriptor is different from the connection's.
				Attempting to change properties of the original using this duplicate
				may or may not have the desired effect.
				
				On Windows, the returned os.File's file descriptor is not usable
				on other processes.

			(*RawConn) ICMPFilter() (*ICMPFilter, error)
				ICMPFilter returns an ICMP filter.
				Currently only Linux supports this.

			(*RawConn) IncludeSourceSpecificGroup(ifi *net.Interface, group, source net.Addr) error
				IncludeSourceSpecificGroup includes the excluded source-specific
				group by ExcludeSourceSpecificGroup again on the interface ifi.

			(*RawConn) JoinGroup(ifi *net.Interface, group net.Addr) error
				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.

			(*RawConn) JoinSourceSpecificGroup(ifi *net.Interface, group, source net.Addr) error
				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.

			(*RawConn) LeaveGroup(ifi *net.Interface, group net.Addr) error
				LeaveGroup leaves the group address group on the interface ifi
				regardless of whether the group is any-source group or
				source-specific group.

			(*RawConn) LeaveSourceSpecificGroup(ifi *net.Interface, group, source net.Addr) error
				LeaveSourceSpecificGroup leaves the source-specific group on the
				interface ifi.

			( RawConn) LocalAddr() net.Addr
				LocalAddr returns the local network address.
				The Addr returned is shared by all invocations of LocalAddr, so
				do not modify it.

			(*RawConn) Lock()
				Lock locks rw for writing.
				If the lock is already locked for reading or writing,
				Lock blocks until the lock is available.

			(*RawConn) MulticastInterface() (*net.Interface, error)
				MulticastInterface returns the default interface for multicast
				packet transmissions.

			(*RawConn) MulticastLoopback() (bool, error)
				MulticastLoopback reports whether transmitted multicast packets
				should be copied and send back to the originator.

			(*RawConn) MulticastTTL() (int, error)
				MulticastTTL returns the time-to-live field value for outgoing
				multicast packets.

			(*RawConn) RLock()
				RLock locks rw for reading.
				
				It should not be used for recursive read locking; a blocked Lock
				call excludes new readers from acquiring the lock. See the
				documentation on the [RWMutex] type.

			(*RawConn) RLocker() sync.Locker
				RLocker returns a [Locker] interface that implements
				the [Locker.Lock] and [Locker.Unlock] methods by calling rw.RLock and rw.RUnlock.

			(*RawConn) RUnlock()
				RUnlock undoes a single [RWMutex.RLock] call;
				it does not affect other simultaneous readers.
				It is a run-time error if rw is not locked for reading
				on entry to RUnlock.

			( RawConn) Read(b []byte) (int, error)
				Read implements the Conn Read method.

			(*RawConn) ReadBatch(ms []Message, flags int) (int, error)
				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.

			(*RawConn) ReadFrom(b []byte) (h *Header, p []byte, cm *ControlMessage, err error)
				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.

			( RawConn) ReadFromIP(b []byte) (int, *net.IPAddr, error)
				ReadFromIP acts like ReadFrom but returns an IPAddr.

			( RawConn) ReadMsgIP(b, oob []byte) (n, oobn, flags int, addr *net.IPAddr, err error)
				ReadMsgIP reads a message from c, copying the payload into b and
				the associated out-of-band data into oob. It returns the number of
				bytes copied into b, the number of bytes copied into oob, the flags
				that were set on the message and the source address of the message.
				
				The packages golang.org/x/net/ipv4 and golang.org/x/net/ipv6 can be
				used to manipulate IP-level socket options in oob.

			( RawConn) RemoteAddr() net.Addr
				RemoteAddr returns the remote network address.
				The Addr returned is shared by all invocations of RemoteAddr, so
				do not modify it.

			(*RawConn) SetBPF(filter []bpf.RawInstruction) error
				SetBPF attaches a BPF program to the connection.
				
				Only supported on Linux.

			(*RawConn) SetControlMessage(cf ControlFlags, on bool) error
				SetControlMessage sets the per packet IP-level socket options.

			(*RawConn) SetDeadline(t time.Time) error
				SetDeadline sets the read and write deadlines associated with the
				endpoint.

			(*RawConn) SetICMPFilter(f *ICMPFilter) error
				SetICMPFilter deploys the ICMP filter.
				Currently only Linux supports this.

			(*RawConn) SetMulticastInterface(ifi *net.Interface) error
				SetMulticastInterface sets the default interface for future
				multicast packet transmissions.

			(*RawConn) SetMulticastLoopback(on bool) error
				SetMulticastLoopback sets whether transmitted multicast packets
				should be copied and send back to the originator.

			(*RawConn) SetMulticastTTL(ttl int) error
				SetMulticastTTL sets the time-to-live field value for future
				outgoing multicast packets.

			( RawConn) SetReadBuffer(bytes int) error
				SetReadBuffer sets the size of the operating system's
				receive buffer associated with the connection.

			(*RawConn) SetReadDeadline(t time.Time) error
				SetReadDeadline sets the read deadline associated with the
				endpoint.

			(*RawConn) SetTOS(tos int) error
				SetTOS sets the type-of-service field value for future outgoing
				packets.

			(*RawConn) SetTTL(ttl int) error
				SetTTL sets the time-to-live field value for future outgoing
				packets.

			( RawConn) SetWriteBuffer(bytes int) error
				SetWriteBuffer sets the size of the operating system's
				transmit buffer associated with the connection.

			(*RawConn) SetWriteDeadline(t time.Time) error
				SetWriteDeadline sets the write deadline associated with the
				endpoint.

			( RawConn) SyscallConn() (syscall.RawConn, error)
				SyscallConn returns a raw network connection.
				This implements the [syscall.Conn] interface.

			(*RawConn) TOS() (int, error)
				TOS returns the type-of-service field value for outgoing packets.

			(*RawConn) TTL() (int, error)
				TTL returns the time-to-live field value for outgoing packets.

			(*RawConn) TryLock() bool
				TryLock tries to lock rw for writing and reports whether it succeeded.
				
				Note that while correct uses of TryLock do exist, they are rare,
				and use of TryLock is often a sign of a deeper problem
				in a particular use of mutexes.

			(*RawConn) TryRLock() bool
				TryRLock tries to lock rw for reading and reports whether it succeeded.
				
				Note that while correct uses of TryRLock do exist, they are rare,
				and use of TryRLock is often a sign of a deeper problem
				in a particular use of mutexes.

			(*RawConn) Unlock()
				Unlock unlocks rw for writing. It is a run-time error if rw is
				not locked for writing on entry to Unlock.
				
				As with Mutexes, a locked [RWMutex] is not associated with a particular
				goroutine. One goroutine may [RWMutex.RLock] ([RWMutex.Lock]) a RWMutex and then
				arrange for another goroutine to [RWMutex.RUnlock] ([RWMutex.Unlock]) it.

			( RawConn) Write(b []byte) (int, error)
				Write implements the Conn Write method.

			(*RawConn) WriteBatch(ms []Message, flags int) (int, error)
				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.

			( RawConn) WriteMsgIP(b, oob []byte, addr *net.IPAddr) (n, oobn int, err error)
				WriteMsgIP writes a message to addr via c, copying the payload from
				b and the associated out-of-band data from oob. It returns the
				number of payload and out-of-band bytes written.
				
				The packages golang.org/x/net/ipv4 and golang.org/x/net/ipv6 can be
				used to manipulate IP-level socket options in oob.

			(*RawConn) WriteTo(h *Header, p []byte, cm *ControlMessage) error
				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

			( RawConn) WriteToIP(b []byte, addr *net.IPAddr) (int, error)
				WriteToIP acts like [IPConn.WriteTo] but takes an [IPAddr].

		Implements (at least 21)
			*RawConn : golang.org/x/net/bpf.Setter
			 RawConn : github.com/miekg/dns.Writer
			*RawConn : github.com/pion/datachannel.ReadDeadliner
			*RawConn : github.com/pion/datachannel.WriteDeadliner
			*RawConn : github.com/pion/stun.Connection
			*RawConn : github.com/pion/stun/v3.Connection
			*RawConn : github.com/pion/transport/v2/udp.BatchPacketConn
			*RawConn : github.com/pion/transport/v2/udp.BatchReader
			*RawConn : github.com/pion/transport/v2/udp.BatchWriter
			*RawConn : github.com/prometheus/common/expfmt.Closer
			 RawConn : internal/bisect.Writer
			*RawConn : io.Closer
			*RawConn : io.ReadCloser
			 RawConn : io.Reader
			*RawConn : io.ReadWriteCloser
			 RawConn : io.ReadWriter
			*RawConn : io.WriteCloser
			 RawConn : io.Writer
			*RawConn : net.Conn
			*RawConn : sync.Locker
			 RawConn : syscall.Conn
		As Outputs Of (at least one exported)
			func NewRawConn(c net.PacketConn) (*RawConn, error)


Package-Level Functions (total 5)

	 func NewConn(c net.Conn) *Conn
		NewConn returns a new Conn.

	 func NewControlMessage(cf ControlFlags) []byte
		NewControlMessage returns a new control message.
		
		The returned message is large enough for options specified by cf.

	 func NewPacketConn(c net.PacketConn) *PacketConn
		NewPacketConn returns a new PacketConn using c as its underlying
		transport.

	 func NewRawConn(c net.PacketConn) (*RawConn, error)
		NewRawConn returns a new RawConn using c as its underlying
		transport.

	 func ParseHeader(b []byte) (*Header, error)
		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.


Package-Level Constants (total 21)

	const DontFragment HeaderFlags = 2 // don't fragment flag
	const FlagDst ControlFlags = 4 // pass the destination address on the received packet
	const FlagInterface ControlFlags = 8 // pass the interface index on the received packet
	const FlagSrc ControlFlags = 2 // pass the source address on the received packet
	const FlagTTL ControlFlags = 1 // pass the TTL on the received packet
	const HeaderLen = 20 // header length without extension headers
	const ICMPTypeDestinationUnreachable ICMPType = 3 // Destination Unreachable
		Internet Control Message Protocol (ICMP) Parameters, Updated: 2018-02-26

	const ICMPTypeEcho ICMPType = 8 // Echo
		Internet Control Message Protocol (ICMP) Parameters, Updated: 2018-02-26

	const ICMPTypeEchoReply ICMPType = 0 // Echo Reply
		Internet Control Message Protocol (ICMP) Parameters, Updated: 2018-02-26

	const ICMPTypeExtendedEchoReply ICMPType = 43 // Extended Echo Reply
		Internet Control Message Protocol (ICMP) Parameters, Updated: 2018-02-26

	const ICMPTypeExtendedEchoRequest ICMPType = 42 // Extended Echo Request
		Internet Control Message Protocol (ICMP) Parameters, Updated: 2018-02-26

	const ICMPTypeParameterProblem ICMPType = 12 // Parameter Problem
		Internet Control Message Protocol (ICMP) Parameters, Updated: 2018-02-26

	const ICMPTypePhoturis ICMPType = 40 // Photuris
		Internet Control Message Protocol (ICMP) Parameters, Updated: 2018-02-26

	const ICMPTypeRedirect ICMPType = 5 // Redirect
		Internet Control Message Protocol (ICMP) Parameters, Updated: 2018-02-26

	const ICMPTypeRouterAdvertisement ICMPType = 9 // Router Advertisement
		Internet Control Message Protocol (ICMP) Parameters, Updated: 2018-02-26

	const ICMPTypeRouterSolicitation ICMPType = 10 // Router Solicitation
		Internet Control Message Protocol (ICMP) Parameters, Updated: 2018-02-26

	const ICMPTypeTimeExceeded ICMPType = 11 // Time Exceeded
		Internet Control Message Protocol (ICMP) Parameters, Updated: 2018-02-26

	const ICMPTypeTimestamp ICMPType = 13 // Timestamp
		Internet Control Message Protocol (ICMP) Parameters, Updated: 2018-02-26

	const ICMPTypeTimestampReply ICMPType = 14 // Timestamp Reply
		Internet Control Message Protocol (ICMP) Parameters, Updated: 2018-02-26

	const MoreFragments HeaderFlags = 1 // more fragments flag
	const Version = 4 // protocol version

The pages are generated with Golds v0.8.2. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds.