Documentation

Overview

    Package icmp provides basic functions for the manipulation of messages used in the Internet Control Message Protocols, ICMPv4 and ICMPv6.

    ICMPv4 and ICMPv6 are defined in RFC 792 and RFC 4443. Multi-part message support for ICMP is defined in RFC 4884. ICMP extensions for MPLS are defined in RFC 4950. ICMP extensions for interface and next-hop identification are defined in RFC 5837. PROBE: A utility for probing interfaces is defined in RFC 8335.

    Index

    Examples

    Constants

    This section is empty.

    Variables

    This section is empty.

    Functions

    func IPv6PseudoHeader

    func IPv6PseudoHeader(src, dst net.IP) []byte

      IPv6PseudoHeader returns an IPv6 pseudo header for checksum calculation.

      func ParseIPv4Header

      func ParseIPv4Header(b []byte) (*ipv4.Header, error)

        ParseIPv4Header returns the IPv4 header of the IPv4 packet that triggered an ICMP error message. This is found in the Data field of the ICMP error message body.

        The provided b must be in the format used by a raw ICMP socket on the local system. This may differ from the wire format, and the format used by a raw IP socket, depending on the system.

        To parse an IPv6 header, use ipv6.ParseHeader.

        Types

        type DefaultMessageBody

        type DefaultMessageBody = RawBody

          A DefaultMessageBody represents the default message body.

          Deprecated: Use RawBody instead.

          type DstUnreach

          type DstUnreach struct {
          	Data       []byte      // data, known as original datagram field
          	Extensions []Extension // extensions
          }

            A DstUnreach represents an ICMP destination unreachable message body.

            func (*DstUnreach) Len

            func (p *DstUnreach) Len(proto int) int

              Len implements the Len method of MessageBody interface.

              func (*DstUnreach) Marshal

              func (p *DstUnreach) Marshal(proto int) ([]byte, error)

                Marshal implements the Marshal method of MessageBody interface.

                type Echo

                type Echo struct {
                	ID   int    // identifier
                	Seq  int    // sequence number
                	Data []byte // data
                }

                  An Echo represents an ICMP echo request or reply message body.

                  func (*Echo) Len

                  func (p *Echo) Len(proto int) int

                    Len implements the Len method of MessageBody interface.

                    func (*Echo) Marshal

                    func (p *Echo) Marshal(proto int) ([]byte, error)

                      Marshal implements the Marshal method of MessageBody interface.

                      type ExtendedEchoReply

                      type ExtendedEchoReply struct {
                      	ID     int  // identifier
                      	Seq    int  // sequence number
                      	State  int  // 3-bit state working together with Message.Code
                      	Active bool // probed interface is active
                      	IPv4   bool // probed interface runs IPv4
                      	IPv6   bool // probed interface runs IPv6
                      }

                        An ExtendedEchoReply represents an ICMP extended echo reply message body.

                        func (*ExtendedEchoReply) Len

                        func (p *ExtendedEchoReply) Len(proto int) int

                          Len implements the Len method of MessageBody interface.

                          func (*ExtendedEchoReply) Marshal

                          func (p *ExtendedEchoReply) Marshal(proto int) ([]byte, error)

                            Marshal implements the Marshal method of MessageBody interface.

                            type ExtendedEchoRequest

                            type ExtendedEchoRequest struct {
                            	ID         int         // identifier
                            	Seq        int         // sequence number
                            	Local      bool        // must be true when identifying by name or index
                            	Extensions []Extension // extensions
                            }

                              An ExtendedEchoRequest represents an ICMP extended echo request message body.

                              func (*ExtendedEchoRequest) Len

                              func (p *ExtendedEchoRequest) Len(proto int) int

                                Len implements the Len method of MessageBody interface.

                                func (*ExtendedEchoRequest) Marshal

                                func (p *ExtendedEchoRequest) Marshal(proto int) ([]byte, error)

                                  Marshal implements the Marshal method of MessageBody interface.

                                  type Extension

                                  type Extension interface {
                                  	// Len returns the length of ICMP extension.
                                  	// The provided proto must be either the ICMPv4 or ICMPv6
                                  	// protocol number.
                                  	Len(proto int) int
                                  
                                  	// Marshal returns the binary encoding of ICMP extension.
                                  	// The provided proto must be either the ICMPv4 or ICMPv6
                                  	// protocol number.
                                  	Marshal(proto int) ([]byte, error)
                                  }

                                    An Extension represents an ICMP extension.

                                    type InterfaceIdent

                                    type InterfaceIdent struct {
                                    	Class int    // extension object class number
                                    	Type  int    // extension object sub-type
                                    	Name  string // interface name
                                    	Index int    // interface index
                                    	AFI   int    // address family identifier; see address family numbers in IANA registry
                                    	Addr  []byte // address
                                    }

                                      An InterfaceIdent represents interface identification.

                                      func (*InterfaceIdent) Len

                                      func (ifi *InterfaceIdent) Len(_ int) int

                                        Len implements the Len method of Extension interface.

                                        func (*InterfaceIdent) Marshal

                                        func (ifi *InterfaceIdent) Marshal(proto int) ([]byte, error)

                                          Marshal implements the Marshal method of Extension interface.

                                          type InterfaceInfo

                                          type InterfaceInfo struct {
                                          	Class     int // extension object class number
                                          	Type      int // extension object sub-type
                                          	Interface *net.Interface
                                          	Addr      *net.IPAddr
                                          }

                                            An InterfaceInfo represents interface and next-hop identification.

                                            func (*InterfaceInfo) Len

                                            func (ifi *InterfaceInfo) Len(proto int) int

                                              Len implements the Len method of Extension interface.

                                              func (*InterfaceInfo) Marshal

                                              func (ifi *InterfaceInfo) Marshal(proto int) ([]byte, error)

                                                Marshal implements the Marshal method of Extension interface.

                                                type MPLSLabel

                                                type MPLSLabel struct {
                                                	Label int  // label value
                                                	TC    int  // traffic class; formerly experimental use
                                                	S     bool // bottom of stack
                                                	TTL   int  // time to live
                                                }

                                                  MPLSLabel represents an MPLS label stack entry.

                                                  type MPLSLabelStack

                                                  type MPLSLabelStack struct {
                                                  	Class  int // extension object class number
                                                  	Type   int // extension object sub-type
                                                  	Labels []MPLSLabel
                                                  }

                                                    MPLSLabelStack represents an MPLS label stack.

                                                    func (*MPLSLabelStack) Len

                                                    func (ls *MPLSLabelStack) Len(proto int) int

                                                      Len implements the Len method of Extension interface.

                                                      func (*MPLSLabelStack) Marshal

                                                      func (ls *MPLSLabelStack) Marshal(proto int) ([]byte, error)

                                                        Marshal implements the Marshal method of Extension interface.

                                                        type Message

                                                        type Message struct {
                                                        	Type     Type        // type, either ipv4.ICMPType or ipv6.ICMPType
                                                        	Code     int         // code
                                                        	Checksum int         // checksum
                                                        	Body     MessageBody // body
                                                        }

                                                          A Message represents an ICMP message.

                                                          func ParseMessage

                                                          func ParseMessage(proto int, b []byte) (*Message, error)

                                                            ParseMessage parses b as an ICMP message. The provided proto must be either the ICMPv4 or ICMPv6 protocol number.

                                                            func (*Message) Marshal

                                                            func (m *Message) Marshal(psh []byte) ([]byte, error)

                                                              Marshal returns the binary encoding of the ICMP message m.

                                                              For an ICMPv4 message, the returned message always contains the calculated checksum field.

                                                              For an ICMPv6 message, the returned message contains the calculated checksum field when psh is not nil, otherwise the kernel will compute the checksum field during the message transmission. When psh is not nil, it must be the pseudo header for IPv6.

                                                              type MessageBody

                                                              type MessageBody interface {
                                                              	// Len returns the length of ICMP message body.
                                                              	// The provided proto must be either the ICMPv4 or ICMPv6
                                                              	// protocol number.
                                                              	Len(proto int) int
                                                              
                                                              	// Marshal returns the binary encoding of ICMP message body.
                                                              	// The provided proto must be either the ICMPv4 or ICMPv6
                                                              	// protocol number.
                                                              	Marshal(proto int) ([]byte, error)
                                                              }

                                                                A MessageBody represents an ICMP message body.

                                                                type PacketConn

                                                                type PacketConn struct {
                                                                	// contains filtered or unexported fields
                                                                }

                                                                  A PacketConn represents a packet network endpoint that uses either ICMPv4 or ICMPv6.

                                                                  Example (NonPrivilegedPing)
                                                                  Output:
                                                                  
                                                                  

                                                                  func ListenPacket

                                                                  func ListenPacket(network, address string) (*PacketConn, error)

                                                                    ListenPacket listens for incoming ICMP packets addressed to address. See net.Dial for the syntax of address.

                                                                    For non-privileged datagram-oriented ICMP endpoints, network must be "udp4" or "udp6". The endpoint allows to read, write a few limited ICMP messages such as echo request and echo reply. Currently only Darwin and Linux support this.

                                                                    Examples:

                                                                    ListenPacket("udp4", "192.168.0.1")
                                                                    ListenPacket("udp4", "0.0.0.0")
                                                                    ListenPacket("udp6", "fe80::1%en0")
                                                                    ListenPacket("udp6", "::")
                                                                    

                                                                    For privileged raw ICMP endpoints, network must be "ip4" or "ip6" followed by a colon and an ICMP protocol number or name.

                                                                    Examples:

                                                                    ListenPacket("ip4:icmp", "192.168.0.1")
                                                                    ListenPacket("ip4:1", "0.0.0.0")
                                                                    ListenPacket("ip6:ipv6-icmp", "fe80::1%en0")
                                                                    ListenPacket("ip6:58", "::")
                                                                    

                                                                    func (*PacketConn) Close

                                                                    func (c *PacketConn) Close() error

                                                                      Close closes the endpoint.

                                                                      func (*PacketConn) IPv4PacketConn

                                                                      func (c *PacketConn) IPv4PacketConn() *ipv4.PacketConn

                                                                        IPv4PacketConn returns the ipv4.PacketConn of c. It returns nil when c is not created as the endpoint for ICMPv4.

                                                                        func (*PacketConn) IPv6PacketConn

                                                                        func (c *PacketConn) IPv6PacketConn() *ipv6.PacketConn

                                                                          IPv6PacketConn returns the ipv6.PacketConn of c. It returns nil when c is not created as the endpoint for ICMPv6.

                                                                          func (*PacketConn) LocalAddr

                                                                          func (c *PacketConn) LocalAddr() net.Addr

                                                                            LocalAddr returns the local network address.

                                                                            func (*PacketConn) ReadFrom

                                                                            func (c *PacketConn) ReadFrom(b []byte) (int, net.Addr, error)

                                                                              ReadFrom reads an ICMP message from the connection.

                                                                              func (*PacketConn) SetDeadline

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

                                                                                SetDeadline sets the read and write deadlines associated with the endpoint.

                                                                                func (*PacketConn) SetReadDeadline

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

                                                                                  SetReadDeadline sets the read deadline associated with the endpoint.

                                                                                  func (*PacketConn) SetWriteDeadline

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

                                                                                    SetWriteDeadline sets the write deadline associated with the endpoint.

                                                                                    func (*PacketConn) WriteTo

                                                                                    func (c *PacketConn) WriteTo(b []byte, dst net.Addr) (int, error)

                                                                                      WriteTo writes the ICMP message b to dst. The provided dst must be net.UDPAddr when c is a non-privileged datagram-oriented ICMP endpoint. Otherwise it must be net.IPAddr.

                                                                                      type PacketTooBig

                                                                                      type PacketTooBig struct {
                                                                                      	MTU  int    // maximum transmission unit of the nexthop link
                                                                                      	Data []byte // data, known as original datagram field
                                                                                      }

                                                                                        A PacketTooBig represents an ICMP packet too big message body.

                                                                                        func (*PacketTooBig) Len

                                                                                        func (p *PacketTooBig) Len(proto int) int

                                                                                          Len implements the Len method of MessageBody interface.

                                                                                          func (*PacketTooBig) Marshal

                                                                                          func (p *PacketTooBig) Marshal(proto int) ([]byte, error)

                                                                                            Marshal implements the Marshal method of MessageBody interface.

                                                                                            type ParamProb

                                                                                            type ParamProb struct {
                                                                                            	Pointer    uintptr     // offset within the data where the error was detected
                                                                                            	Data       []byte      // data, known as original datagram field
                                                                                            	Extensions []Extension // extensions
                                                                                            }

                                                                                              A ParamProb represents an ICMP parameter problem message body.

                                                                                              func (*ParamProb) Len

                                                                                              func (p *ParamProb) Len(proto int) int

                                                                                                Len implements the Len method of MessageBody interface.

                                                                                                func (*ParamProb) Marshal

                                                                                                func (p *ParamProb) Marshal(proto int) ([]byte, error)

                                                                                                  Marshal implements the Marshal method of MessageBody interface.

                                                                                                  type RawBody

                                                                                                  type RawBody struct {
                                                                                                  	Data []byte // data
                                                                                                  }

                                                                                                    A RawBody represents a raw message body.

                                                                                                    A raw message body is excluded from message processing and can be used to construct applications such as protocol conformance testing.

                                                                                                    func (*RawBody) Len

                                                                                                    func (p *RawBody) Len(proto int) int

                                                                                                      Len implements the Len method of MessageBody interface.

                                                                                                      func (*RawBody) Marshal

                                                                                                      func (p *RawBody) Marshal(proto int) ([]byte, error)

                                                                                                        Marshal implements the Marshal method of MessageBody interface.

                                                                                                        type RawExtension

                                                                                                        type RawExtension struct {
                                                                                                        	Data []byte // data
                                                                                                        }

                                                                                                          A RawExtension represents a raw extension.

                                                                                                          A raw extension is excluded from message processing and can be used to construct applications such as protocol conformance testing.

                                                                                                          func (*RawExtension) Len

                                                                                                          func (p *RawExtension) Len(proto int) int

                                                                                                            Len implements the Len method of Extension interface.

                                                                                                            func (*RawExtension) Marshal

                                                                                                            func (p *RawExtension) Marshal(proto int) ([]byte, error)

                                                                                                              Marshal implements the Marshal method of Extension interface.

                                                                                                              type TimeExceeded

                                                                                                              type TimeExceeded struct {
                                                                                                              	Data       []byte      // data, known as original datagram field
                                                                                                              	Extensions []Extension // extensions
                                                                                                              }

                                                                                                                A TimeExceeded represents an ICMP time exceeded message body.

                                                                                                                func (*TimeExceeded) Len

                                                                                                                func (p *TimeExceeded) Len(proto int) int

                                                                                                                  Len implements the Len method of MessageBody interface.

                                                                                                                  func (*TimeExceeded) Marshal

                                                                                                                  func (p *TimeExceeded) Marshal(proto int) ([]byte, error)

                                                                                                                    Marshal implements the Marshal method of MessageBody interface.

                                                                                                                    type Type

                                                                                                                    type Type interface {
                                                                                                                    	Protocol() int
                                                                                                                    }

                                                                                                                      A Type represents an ICMP message type.

                                                                                                                      Notes

                                                                                                                      Bugs

                                                                                                                        • This package is not implemented on JS, NaCl and Plan 9.

                                                                                                                        GOOS=linux, GOARCH=amd64