func (e *endpoint) HandleControlPacket(id stack.TransportEndpointID, typ stack.ControlType, extra uint32, pkt tcpip.PacketBuffer) {
}
HandleControlPacket implements stack.TransportEndpoint.HandleControlPacket.
package icmp
import (
	"sync"
	"github.com/google/netstack/tcpip"
	"github.com/google/netstack/tcpip/buffer"
	"github.com/google/netstack/tcpip/header"
	"github.com/google/netstack/tcpip/iptables"
	"github.com/google/netstack/tcpip/stack"
	"github.com/google/netstack/waiter"
)
type icmpPacket struct {
	icmpPacketEntry
	senderAddress tcpip.FullAddress
	data          buffer.VectorisedView
	timestamp     int64
}
type endpointState int
const (
	stateInitial endpointState = iota
	stateBound
	stateConnected
	stateClosed
)
type endpoint struct {
	stack.TransportEndpointInfo
	stack       *stack.Stack
	waiterQueue *waiter.Queue
	uniqueID    uint64
	rcvMu         sync.Mutex
	rcvReady      bool
	rcvList       icmpPacketList
	rcvBufSizeMax int
	rcvBufSize    int
	rcvClosed     bool
	mu         sync.RWMutex
	sndBufSize int
	shutdownFlags tcpip.ShutdownFlags
	state         endpointState
	route         stack.Route
	ttl           uint8
	stats         tcpip.TransportEndpointStats
}
func newEndpoint(s *stack.Stack, netProto tcpip.NetworkProtocolNumber, transProto tcpip.TransportProtocolNumber, waiterQueue *waiter.Queue) (tcpip.Endpoint, *tcpip.Error) {
	return &endpoint{
		stack: s,
		TransportEndpointInfo: stack.TransportEndpointInfo{
			NetProto:   netProto,
			TransProto: transProto,
		},
		waiterQueue:   waiterQueue,
		rcvBufSizeMax: 32 * 1024,
		sndBufSize:    32 * 1024,
		state:         stateInitial,
		uniqueID:      s.UniqueID(),
	}, nil
}
func (e *endpoint) UniqueID() uint64 {
	return e.uniqueID
}
func (e *endpoint) Close() {
	e.mu.Lock()
	e.shutdownFlags = tcpip.ShutdownRead | tcpip.ShutdownWrite
	switch e.state {
	case stateBound, stateConnected:
		e.stack.UnregisterTransportEndpoint(e.RegisterNICID, []tcpip.NetworkProtocolNumber{e.NetProto}, e.TransProto, e.ID, e, 0  )
	}
	e.rcvMu.Lock()
	e.rcvClosed = true
	e.rcvBufSize = 0
	for !e.rcvList.Empty() {
		p := e.rcvList.Front()
		e.rcvList.Remove(p)
	}
	e.rcvMu.Unlock()
	e.route.Release()
	e.state = stateClosed
	e.mu.Unlock()
	e.waiterQueue.Notify(waiter.EventHUp | waiter.EventErr | waiter.EventIn | waiter.EventOut)
}
func (e *endpoint) ModerateRecvBuf(copied int) {}
func (e *endpoint) IPTables() (iptables.IPTables, error) {
	return e.stack.IPTables(), nil
}
func (e *endpoint) Read(addr *tcpip.FullAddress) (buffer.View, tcpip.ControlMessages, *tcpip.Error) {
	e.rcvMu.Lock()
	if e.rcvList.Empty() {
		err := tcpip.ErrWouldBlock
		if e.rcvClosed {
			e.stats.ReadErrors.ReadClosed.Increment()
			err = tcpip.ErrClosedForReceive
		}
		e.rcvMu.Unlock()
		return buffer.View{}, tcpip.ControlMessages{}, err
	}
	p := e.rcvList.Front()
	e.rcvList.Remove(p)
	e.rcvBufSize -= p.data.Size()
	e.rcvMu.Unlock()
	if addr != nil {
		*addr = p.senderAddress
	}
	return p.data.ToView(), tcpip.ControlMessages{HasTimestamp: true, Timestamp: p.timestamp}, nil
}
func (e *endpoint) prepareForWrite(to *tcpip.FullAddress) (retry bool, err *tcpip.Error) {
	switch e.state {
	case stateInitial:
	case stateConnected:
		return false, nil
	case stateBound:
		if to == nil {
			return false, tcpip.ErrDestinationRequired
		}
		return false, nil
	default:
		return false, tcpip.ErrInvalidEndpointState
	}
	e.mu.RUnlock()
	defer e.mu.RLock()
	e.mu.Lock()
	defer e.mu.Unlock()
	if e.state != stateInitial {
		return true, nil
	}
	if err := e.bindLocked(tcpip.FullAddress{}); err != nil {
		return false, err
	}
	return true, nil
}
func (e *endpoint) Write(p tcpip.Payloader, opts tcpip.WriteOptions) (int64, <-chan struct{}, *tcpip.Error) {
	n, ch, err := e.write(p, opts)
	switch err {
	case nil:
		e.stats.PacketsSent.Increment()
	case tcpip.ErrMessageTooLong, tcpip.ErrInvalidOptionValue:
		e.stats.WriteErrors.InvalidArgs.Increment()
	case tcpip.ErrClosedForSend:
		e.stats.WriteErrors.WriteClosed.Increment()
	case tcpip.ErrInvalidEndpointState:
		e.stats.WriteErrors.InvalidEndpointState.Increment()
	case tcpip.ErrNoLinkAddress:
		e.stats.SendErrors.NoLinkAddr.Increment()
	case tcpip.ErrNoRoute, tcpip.ErrBroadcastDisabled, tcpip.ErrNetworkUnreachable:
		e.stats.SendErrors.NoRoute.Increment()
	default:
		e.stats.SendErrors.SendToNetworkFailed.Increment()
	}
	return n, ch, err
}
func (e *endpoint) write(p tcpip.Payloader, opts tcpip.WriteOptions) (int64, <-chan struct{}, *tcpip.Error) {
	if opts.More {
		return 0, nil, tcpip.ErrInvalidOptionValue
	}
	to := opts.To
	e.mu.RLock()
	defer e.mu.RUnlock()
	if e.shutdownFlags&tcpip.ShutdownWrite != 0 {
		return 0, nil, tcpip.ErrClosedForSend
	}
	for {
		retry, err := e.prepareForWrite(to)
		if err != nil {
			return 0, nil, err
		}
		if !retry {
			break
		}
	}
	var route *stack.Route
	if to == nil {
		route = &e.route
		if route.IsResolutionRequired() {
			e.mu.RUnlock()
			defer e.mu.RLock()
			e.mu.Lock()
			defer e.mu.Unlock()
			if e.state != stateConnected {
				return 0, nil, tcpip.ErrInvalidEndpointState
			}
		}
	} else {
		nicID := to.NIC
		if e.BindNICID != 0 {
			if nicID != 0 && nicID != e.BindNICID {
				return 0, nil, tcpip.ErrNoRoute
			}
			nicID = e.BindNICID
		}
		toCopy := *to
		to = &toCopy
		netProto, err := e.checkV4Mapped(to, true)
		if err != nil {
			return 0, nil, err
		}
		r, err := e.stack.FindRoute(nicID, e.BindAddr, to.Addr, netProto, false  )
		if err != nil {
			return 0, nil, err
		}
		defer r.Release()
		route = &r
	}
	if route.IsResolutionRequired() {
		if ch, err := route.Resolve(nil); err != nil {
			if err == tcpip.ErrWouldBlock {
				return 0, ch, tcpip.ErrNoLinkAddress
			}
			return 0, nil, err
		}
	}
	v, err := p.FullPayload()
	if err != nil {
		return 0, nil, err
	}
	switch e.NetProto {
	case header.IPv4ProtocolNumber:
		err = send4(route, e.ID.LocalPort, v, e.ttl)
	case header.IPv6ProtocolNumber:
		err = send6(route, e.ID.LocalPort, v, e.ttl)
	}
	if err != nil {
		return 0, nil, err
	}
	return int64(len(v)), nil, nil
}
func (e *endpoint) Peek([][]byte) (int64, tcpip.ControlMessages, *tcpip.Error) {
	return 0, tcpip.ControlMessages{}, nil
}
func (e *endpoint) SetSockOpt(opt interface{}) *tcpip.Error {
	switch o := opt.(type) {
	case tcpip.TTLOption:
		e.mu.Lock()
		e.ttl = uint8(o)
		e.mu.Unlock()
	}
	return nil
}
func (e *endpoint) SetSockOptInt(opt tcpip.SockOpt, v int) *tcpip.Error {
	return nil
}
func (e *endpoint) GetSockOptInt(opt tcpip.SockOpt) (int, *tcpip.Error) {
	switch opt {
	case tcpip.ReceiveQueueSizeOption:
		v := 0
		e.rcvMu.Lock()
		if !e.rcvList.Empty() {
			p := e.rcvList.Front()
			v = p.data.Size()
		}
		e.rcvMu.Unlock()
		return v, nil
	case tcpip.SendBufferSizeOption:
		e.mu.Lock()
		v := e.sndBufSize
		e.mu.Unlock()
		return v, nil
	case tcpip.ReceiveBufferSizeOption:
		e.rcvMu.Lock()
		v := e.rcvBufSizeMax
		e.rcvMu.Unlock()
		return v, nil
	}
	return -1, tcpip.ErrUnknownProtocolOption
}
func (e *endpoint) GetSockOpt(opt interface{}) *tcpip.Error {
	switch o := opt.(type) {
	case tcpip.ErrorOption:
		return nil
	case *tcpip.KeepaliveEnabledOption:
		*o = 0
		return nil
	case *tcpip.TTLOption:
		e.rcvMu.Lock()
		*o = tcpip.TTLOption(e.ttl)
		e.rcvMu.Unlock()
		return nil
	default:
		return tcpip.ErrUnknownProtocolOption
	}
}
func send4(r *stack.Route, ident uint16, data buffer.View, ttl uint8) *tcpip.Error {
	if len(data) < header.ICMPv4MinimumSize {
		return tcpip.ErrInvalidEndpointState
	}
	hdr := buffer.NewPrependable(header.ICMPv4MinimumSize + int(r.MaxHeaderLength()))
	icmpv4 := header.ICMPv4(hdr.Prepend(header.ICMPv4MinimumSize))
	copy(icmpv4, data)
	icmpv4.SetIdent(ident)
	data = data[header.ICMPv4MinimumSize:]
	if icmpv4.Type() != header.ICMPv4Echo || icmpv4.Code() != 0 {
		return tcpip.ErrInvalidEndpointState
	}
	icmpv4.SetChecksum(0)
	icmpv4.SetChecksum(^header.Checksum(icmpv4, header.Checksum(data, 0)))
	if ttl == 0 {
		ttl = r.DefaultTTL()
	}
	return r.WritePacket(nil  , stack.NetworkHeaderParams{Protocol: header.ICMPv4ProtocolNumber, TTL: ttl, TOS: stack.DefaultTOS}, tcpip.PacketBuffer{
		Header:          hdr,
		Data:            data.ToVectorisedView(),
		TransportHeader: buffer.View(icmpv4),
	})
}
func send6(r *stack.Route, ident uint16, data buffer.View, ttl uint8) *tcpip.Error {
	if len(data) < header.ICMPv6EchoMinimumSize {
		return tcpip.ErrInvalidEndpointState
	}
	hdr := buffer.NewPrependable(header.ICMPv6MinimumSize + int(r.MaxHeaderLength()))
	icmpv6 := header.ICMPv6(hdr.Prepend(header.ICMPv6MinimumSize))
	copy(icmpv6, data)
	icmpv6.SetIdent(ident)
	data = data[header.ICMPv6MinimumSize:]
	if icmpv6.Type() != header.ICMPv6EchoRequest || icmpv6.Code() != 0 {
		return tcpip.ErrInvalidEndpointState
	}
	dataVV := data.ToVectorisedView()
	icmpv6.SetChecksum(header.ICMPv6Checksum(icmpv6, r.LocalAddress, r.RemoteAddress, dataVV))
	if ttl == 0 {
		ttl = r.DefaultTTL()
	}
	return r.WritePacket(nil  , stack.NetworkHeaderParams{Protocol: header.ICMPv6ProtocolNumber, TTL: ttl, TOS: stack.DefaultTOS}, tcpip.PacketBuffer{
		Header:          hdr,
		Data:            dataVV,
		TransportHeader: buffer.View(icmpv6),
	})
}
func (e *endpoint) checkV4Mapped(addr *tcpip.FullAddress, allowMismatch bool) (tcpip.NetworkProtocolNumber, *tcpip.Error) {
	netProto := e.NetProto
	if header.IsV4MappedAddress(addr.Addr) {
		return 0, tcpip.ErrNoRoute
	}
	if l := len(e.ID.LocalAddress); !allowMismatch && l != 0 && l != len(addr.Addr) {
		return 0, tcpip.ErrInvalidEndpointState
	}
	return netProto, nil
}
func (*endpoint) Disconnect() *tcpip.Error {
	return tcpip.ErrNotSupported
}
func (e *endpoint) Connect(addr tcpip.FullAddress) *tcpip.Error {
	e.mu.Lock()
	defer e.mu.Unlock()
	nicID := addr.NIC
	localPort := uint16(0)
	switch e.state {
	case stateBound, stateConnected:
		localPort = e.ID.LocalPort
		if e.BindNICID == 0 {
			break
		}
		if nicID != 0 && nicID != e.BindNICID {
			return tcpip.ErrInvalidEndpointState
		}
		nicID = e.BindNICID
	default:
		return tcpip.ErrInvalidEndpointState
	}
	netProto, err := e.checkV4Mapped(&addr, false)
	if err != nil {
		return err
	}
	r, err := e.stack.FindRoute(nicID, e.BindAddr, addr.Addr, netProto, false  )
	if err != nil {
		return err
	}
	defer r.Release()
	id := stack.TransportEndpointID{
		LocalAddress:  r.LocalAddress,
		LocalPort:     localPort,
		RemoteAddress: r.RemoteAddress,
	}
	netProtos := []tcpip.NetworkProtocolNumber{netProto}
	id, err = e.registerWithStack(nicID, netProtos, id)
	if err != nil {
		return err
	}
	e.ID = id
	e.route = r.Clone()
	e.RegisterNICID = nicID
	e.state = stateConnected
	e.rcvMu.Lock()
	e.rcvReady = true
	e.rcvMu.Unlock()
	return nil
}
func (*endpoint) ConnectEndpoint(tcpip.Endpoint) *tcpip.Error {
	return tcpip.ErrInvalidEndpointState
}
func (e *endpoint) Shutdown(flags tcpip.ShutdownFlags) *tcpip.Error {
	e.mu.Lock()
	defer e.mu.Unlock()
	e.shutdownFlags |= flags
	if e.state != stateConnected {
		return tcpip.ErrNotConnected
	}
	if flags&tcpip.ShutdownRead != 0 {
		e.rcvMu.Lock()
		wasClosed := e.rcvClosed
		e.rcvClosed = true
		e.rcvMu.Unlock()
		if !wasClosed {
			e.waiterQueue.Notify(waiter.EventIn)
		}
	}
	return nil
}
func (*endpoint) Listen(int) *tcpip.Error {
	return tcpip.ErrNotSupported
}
func (*endpoint) Accept() (tcpip.Endpoint, *waiter.Queue, *tcpip.Error) {
	return nil, nil, tcpip.ErrNotSupported
}
func (e *endpoint) registerWithStack(nicID tcpip.NICID, netProtos []tcpip.NetworkProtocolNumber, id stack.TransportEndpointID) (stack.TransportEndpointID, *tcpip.Error) {
	if id.LocalPort != 0 {
		err := e.stack.RegisterTransportEndpoint(nicID, netProtos, e.TransProto, id, e, false  , 0  )
		return id, err
	}
	_, err := e.stack.PickEphemeralPort(func(p uint16) (bool, *tcpip.Error) {
		id.LocalPort = p
		err := e.stack.RegisterTransportEndpoint(nicID, netProtos, e.TransProto, id, e, false  , 0  )
		switch err {
		case nil:
			return true, nil
		case tcpip.ErrPortInUse:
			return false, nil
		default:
			return false, err
		}
	})
	return id, err
}
func (e *endpoint) bindLocked(addr tcpip.FullAddress) *tcpip.Error {
	if e.state != stateInitial {
		return tcpip.ErrInvalidEndpointState
	}
	netProto, err := e.checkV4Mapped(&addr, false)
	if err != nil {
		return err
	}
	netProtos := []tcpip.NetworkProtocolNumber{netProto}
	if len(addr.Addr) != 0 {
		if e.stack.CheckLocalAddress(addr.NIC, netProto, addr.Addr) == 0 {
			return tcpip.ErrBadLocalAddress
		}
	}
	id := stack.TransportEndpointID{
		LocalPort:    addr.Port,
		LocalAddress: addr.Addr,
	}
	id, err = e.registerWithStack(addr.NIC, netProtos, id)
	if err != nil {
		return err
	}
	e.ID = id
	e.RegisterNICID = addr.NIC
	e.state = stateBound
	e.rcvMu.Lock()
	e.rcvReady = true
	e.rcvMu.Unlock()
	return nil
}
func (e *endpoint) Bind(addr tcpip.FullAddress) *tcpip.Error {
	e.mu.Lock()
	defer e.mu.Unlock()
	err := e.bindLocked(addr)
	if err != nil {
		return err
	}
	e.BindNICID = addr.NIC
	e.BindAddr = addr.Addr
	return nil
}
func (e *endpoint) GetLocalAddress() (tcpip.FullAddress, *tcpip.Error) {
	e.mu.RLock()
	defer e.mu.RUnlock()
	return tcpip.FullAddress{
		NIC:  e.RegisterNICID,
		Addr: e.ID.LocalAddress,
		Port: e.ID.LocalPort,
	}, nil
}
func (e *endpoint) GetRemoteAddress() (tcpip.FullAddress, *tcpip.Error) {
	e.mu.RLock()
	defer e.mu.RUnlock()
	if e.state != stateConnected {
		return tcpip.FullAddress{}, tcpip.ErrNotConnected
	}
	return tcpip.FullAddress{
		NIC:  e.RegisterNICID,
		Addr: e.ID.RemoteAddress,
		Port: e.ID.RemotePort,
	}, nil
}
func (e *endpoint) Readiness(mask waiter.EventMask) waiter.EventMask {
	result := waiter.EventOut & mask
	if (mask & waiter.EventIn) != 0 {
		e.rcvMu.Lock()
		if !e.rcvList.Empty() || e.rcvClosed {
			result |= waiter.EventIn
		}
		e.rcvMu.Unlock()
	}
	return result
}
func (e *endpoint) HandlePacket(r *stack.Route, id stack.TransportEndpointID, pkt tcpip.PacketBuffer) {
	switch e.NetProto {
	case header.IPv4ProtocolNumber:
		h := header.ICMPv4(pkt.Data.First())
		if h.Type() != header.ICMPv4EchoReply {
			e.stack.Stats().DroppedPackets.Increment()
			e.stats.ReceiveErrors.MalformedPacketsReceived.Increment()
			return
		}
	case header.IPv6ProtocolNumber:
		h := header.ICMPv6(pkt.Data.First())
		if h.Type() != header.ICMPv6EchoReply {
			e.stack.Stats().DroppedPackets.Increment()
			e.stats.ReceiveErrors.MalformedPacketsReceived.Increment()
			return
		}
	}
	e.rcvMu.Lock()
	if !e.rcvReady || e.rcvClosed {
		e.rcvMu.Unlock()
		e.stack.Stats().DroppedPackets.Increment()
		e.stats.ReceiveErrors.ClosedReceiver.Increment()
		return
	}
	if e.rcvBufSize >= e.rcvBufSizeMax {
		e.rcvMu.Unlock()
		e.stack.Stats().DroppedPackets.Increment()
		e.stats.ReceiveErrors.ReceiveBufferOverflow.Increment()
		return
	}
	wasEmpty := e.rcvBufSize == 0
	packet := &icmpPacket{
		senderAddress: tcpip.FullAddress{
			NIC:  r.NICID(),
			Addr: id.RemoteAddress,
		},
	}
	packet.data = pkt.Data
	e.rcvList.PushBack(packet)
	e.rcvBufSize += packet.data.Size()
	packet.timestamp = e.stack.NowNanoseconds()
	e.rcvMu.Unlock()
	e.stats.PacketsReceived.Increment()
	if wasEmpty {
		e.waiterQueue.Notify(waiter.EventIn)
	}
}