import (

"bytes"

"encoding/binary"

mathrand "math/rand"

"sync/atomic"

"time"

DefaultTOS = 0

)

type transportProtocolState struct {

proto TransportProtocol

defaultHandler func(r *Route, id TransportEndpointID, pkt *PacketBuffer) bool

// was started.

MeasureTime time.Time

// this measure began.

CopiedBytes int

networkProtocols map[tcpip.NetworkProtocolNumber]NetworkProtocol

linkAddrResolvers map[tcpip.NetworkProtocolNumber]LinkAddressResolver

// rawFactory creates raw endpoints. If nil, raw endpoints are

// disabled. It is set during Stack creation and is immutable.

rawFactory RawFactory

mu sync.RWMutex

nics map[tcpip.NICID]*NIC

// route is the route table passed in by the user via SetRouteTable(),

// it is used by FindRoute() to build a route for a specific

// If not nil, then any new endpoints will have this probe function

// invoked everytime they receive a TCP segment.

// clock is used to generate user-visible times.

clock tcpip.Clock

// nudConfigs is the default NUD configurations used by interfaces.

nudConfigs NUDConfigurations

// autoGenIPv6LinkLocal determines whether or not the stack will attempt

// to auto-generate an IPv6 link-local address for newly enabled non-loopback

// NICs. See the AutoGenIPv6LinkLocal field of Options for more details.

// NUDConfigs is the default NUD configurations used by interfaces.

NUDConfigs NUDConfigurations

// AutoGenIPv6LinkLocal determines whether or not the stack will attempt to

// auto-generate an IPv6 link-local address for newly enabled non-loopback

// NICs.

seed: generateRandUint32(),

ndpConfigs: opts.NDPConfigs,

nudConfigs: opts.NUDConfigs,

autoGenIPv6LinkLocal: opts.AutoGenIPv6LinkLocal,

uniqueIDGenerator: opts.UniqueID,

ndpDisp: opts.NDPDisp,

Max: DefaultMaxBufferSize,

},

}

// Add specified network protocols.

for _, netProto := range opts.NetworkProtocols {

// options. This method returns an error if the protocol is not supported or

// option is not supported by the protocol implementation or the provided value

// is incorrect.

netProto, ok := s.networkProtocols[network]

if !ok {

return tcpip.ErrUnknownProtocol

// if err != nil {

// ...

// }

netProto, ok := s.networkProtocols[network]

if !ok {

return tcpip.ErrUnknownProtocol

// options. This method returns an error if the protocol is not supported or

// option is not supported by the protocol implementation or the provided value

// is incorrect.

transProtoState, ok := s.transportProtocols[transport]

if !ok {

return tcpip.ErrUnknownProtocol

// if err := s.TransportProtocolOption(tcpip.TCPProtocolNumber, &v); err != nil {

// ...

// }

transProtoState, ok := s.transportProtocols[transport]

if !ok {

return tcpip.ErrUnknownProtocol

return

}

// If the forwarding value for this protocol hasn't changed then do

// nothing.

return

}

if protocol == header.IPv6ProtocolNumber {

if enable {

for _, nic := range s.nics {

func (s *Stack) Forwarding(protocol tcpip.NetworkProtocolNumber) bool {

s.forwarding.RLock()

defer s.forwarding.RUnlock()

}

// SetRouteTable assigns the route table to be used by this stack. It

s.mu.RLock()

defer s.mu.RUnlock()

return tcpip.ErrUnknownNICID

}

}

r := makeRoute(netProto, ref.address(), remoteAddr, nic.linkEP.LinkAddress(), ref, s.handleLocal && !nic.isLoopback(), multicastLoop && !nic.isLoopback())

if len(route.Gateway) > 0 {

if needRoute {

r.NextHop = route.Gateway

}

r.RemoteLinkAddress = header.EthernetBroadcastAddress

}

// If a NIC is specified, we try to find the address there only.

if nicID != 0 {

return 0

}

s.mu.RLock()

defer s.mu.RUnlock()

return tcpip.ErrUnknownNICID

}

s.mu.RLock()

defer s.mu.RUnlock()

return tcpip.ErrUnknownNICID

}

return s.linkAddrCache.get(fullAddr, linkRes, localAddr, nic.linkEP, waker)

}

func (s *Stack) RemoveWaker(nicID tcpip.NICID, addr tcpip.Address, waker *sleep.Waker) {

s.mu.RLock()

defer s.mu.RUnlock()

}

}

// RegisterTransportEndpoint registers the given endpoint with the stack

// transport dispatcher. Received packets that match the provided id will be

// delivered to the given endpoint; specifying a nic is optional, but

// StartTransportEndpointCleanup removes the endpoint with the given id from

// the stack transport dispatcher. It also transitions it to the cleanup stage.

func (s *Stack) StartTransportEndpointCleanup(nicID tcpip.NICID, netProtos []tcpip.NetworkProtocolNumber, protocol tcpip.TransportProtocolNumber, id TransportEndpointID, ep TransportEndpoint, flags ports.Flags, bindToDevice tcpip.NICID) {

s.cleanupEndpoints[ep] = struct{}{}

s.demux.unregisterEndpoint(netProtos, protocol, id, ep, flags, bindToDevice)

}

// CompleteTransportEndpointCleanup removes the endpoint from the cleanup

// stage.

func (s *Stack) CompleteTransportEndpointCleanup(ep TransportEndpoint) {

delete(s.cleanupEndpoints, ep)

}

// FindTransportEndpoint finds an endpoint that most closely matches the provided

// CleanupEndpoints returns endpoints currently in the cleanup state.

func (s *Stack) CleanupEndpoints() []TransportEndpoint {

es := make([]TransportEndpoint, 0, len(s.cleanupEndpoints))

for e := range s.cleanupEndpoints {

es = append(es, e)

}

return es

}

// RestoreCleanupEndpoints adds endpoints to cleanup tracking. This is useful

// for restoring a stack after a save.

func (s *Stack) RestoreCleanupEndpoints(es []TransportEndpoint) {

for _, e := range es {

s.cleanupEndpoints[e] = struct{}{}

}

}

// Close closes all currently registered transport endpoints.

// guarantee provided on which probe will be invoked. Ideally this should only

// be called once per stack.

func (s *Stack) AddTCPProbe(probe TCPProbeFunc) {

}

// GetTCPProbe returns the TCPProbeFunc if installed with AddTCPProbe, nil

// otherwise.

func (s *Stack) GetTCPProbe() TCPProbeFunc {

}

// RemoveTCPProbe removes an installed TCP probe.

// have a probe attached. Endpoints already created will continue to invoke

// TCP probe.

func (s *Stack) RemoveTCPProbe() {

}

// JoinGroup joins the given multicast group on the given NIC.

return nil, tcpip.ErrBadAddress

}

func (s *Stack) FindNICNameFromID(id tcpip.NICID) string {

s.mu.RLock()

defer s.mu.RUnlock()