tcp

package
v0.0.0-...-a5542f1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 21, 2024 License: Apache-2.0, MIT Imports: 34 Imported by: 237

Documentation

Overview

Package tcp contains the implementation of the TCP transport protocol.

Index

Constants

View Source 
const (
	// ProtocolNumber is the tcp protocol number.
	ProtocolNumber = header.TCPProtocolNumber

	// MinBufferSize is the smallest size of a receive or send buffer.
	MinBufferSize = 4 << 10 // 4096 bytes.

	// DefaultSendBufferSize is the default size of the send buffer for
	// an endpoint.
	DefaultSendBufferSize = 1 << 20 // 1MB

	// DefaultReceiveBufferSize is the default size of the receive buffer
	// for an endpoint.
	DefaultReceiveBufferSize = 1 << 20 // 1MB

	// MaxBufferSize is the largest size a receive/send buffer can grow to.
	MaxBufferSize = 4 << 20 // 4MB

	// DefaultTCPLingerTimeout is the amount of time that sockets linger in
	// FIN_WAIT_2 state before being marked closed.
	DefaultTCPLingerTimeout = 60 * time.Second

	// MaxTCPLingerTimeout is the maximum amount of time that sockets
	// linger in FIN_WAIT_2 state before being marked closed.
	MaxTCPLingerTimeout = 120 * time.Second

	// DefaultTCPTimeWaitTimeout is the amount of time that sockets linger
	// in TIME_WAIT state before being marked closed.
	DefaultTCPTimeWaitTimeout = 60 * time.Second

	// DefaultSynRetries is the default value for the number of SYN retransmits
	// before a connect is aborted.
	DefaultSynRetries = 6

	// DefaultKeepaliveIdle is the idle time for a connection before keep-alive
	// probes are sent.
	DefaultKeepaliveIdle = 2 * time.Hour

	// DefaultKeepaliveInterval is the time between two successive keep-alive
	// probes.
	DefaultKeepaliveInterval = 75 * time.Second

	// DefaultKeepaliveCount is the number of keep-alive probes that are sent
	// before declaring the connection dead.
	DefaultKeepaliveCount = 9
)
View Source 
const (
	// MinRTO is the minimum allowed value for the retransmit timeout.
	MinRTO = 200 * time.Millisecond

	// MaxRTO is the maximum allowed value for the retransmit timeout.
	MaxRTO = 120 * time.Second

	// MinSRTT is the minimum allowed value for smoothed RTT.
	MinSRTT = 1 * time.Millisecond

	// InitialCwnd is the initial congestion window.
	InitialCwnd = 10

	// MaxRetries is the maximum number of probe retries sender does
	// before timing out the connection.
	// Linux default TCP_RETR2, net.ipv4.tcp_retries2.
	MaxRetries = 15

	// InitialSsthresh is the the maximum int value, which depends on the
	// platform.
	InitialSsthresh = math.MaxInt
)
View Source 
const (

	// InitialRTO is the initial retransmission timeout.
	// https://github.com/torvalds/linux/blob/7c636d4d20f/include/net/tcp.h#L142
	InitialRTO = time.Second
)
View Source 
const (
	// MaxSACKBlocks is the maximum number of SACK blocks stored
	// at receiver side.
	MaxSACKBlocks = 6
)
View Source 
const (

	// SegOverheadFactor is used to multiply the value provided by the
	// user on a SetSockOpt for setting the socket send/receive buffer sizes.
	SegOverheadFactor = 2
)
View Source 
const (
	// SegOverheadSize is the size of an empty seg in memory including packet
	// buffer overhead. It is advised to use SegOverheadSize instead of segSize
	// in all cases where accounting for segment memory overhead is important.
	SegOverheadSize = segSize + stack.PacketBufferStructSize + header.IPv4MaximumHeaderSize
)

Variables

This section is empty.

Functions

func FindWndScale 

func FindWndScale(wnd seqnum.Size) int

FindWndScale determines the window scale to use for the given maximum window size.

func GetTCPReceiveBufferLimits 

func GetTCPReceiveBufferLimits(s tcpip.StackHandler) tcpip.ReceiveBufferSizeOption

GetTCPReceiveBufferLimits is used to get send buffer size limits for TCP.

func GetTCPSendBufferLimits 

func GetTCPSendBufferLimits(sh tcpip.StackHandler) tcpip.SendBufferSizeOption

GetTCPSendBufferLimits is used to get send buffer size limits for TCP.

func NewProtocol 

func NewProtocol(s *stack.Stack) stack.TransportProtocol

NewProtocol returns a TCP transport protocol with Reno congestion control.

func NewProtocolCUBIC 

func NewProtocolCUBIC(s *stack.Stack) stack.TransportProtocol

NewProtocolCUBIC returns a TCP transport protocol with CUBIC congestion control.

TODO(b/345835636): Remove this and make CUBIC the default across the board.

func TrimSACKBlockList 

func TrimSACKBlockList(sack *SACKInfo, rcvNxt seqnum.Value)

TrimSACKBlockList updates the sack block list by removing/modifying any block where start is < rcvNxt.

func UpdateSACKBlocks 

func UpdateSACKBlocks(sack *SACKInfo, segStart seqnum.Value, segEnd seqnum.Value, rcvNxt seqnum.Value)

UpdateSACKBlocks updates the list of SACK blocks to include the segment specified by segStart->segEnd. If the segment happens to be an out of order delivery then the first block in the sack.blocks always includes the segment identified by segStart->segEnd.

Types

type Endpoint 

type Endpoint struct {
	stack.TCPEndpointStateInner
	stack.TransportEndpointInfo
	tcpip.DefaultSocketOptionsHandler

	// +checklocks:rcvQueueMu
	stack.TCPRcvBufState
	// contains filtered or unexported fields
}

Endpoint represents a TCP endpoint. This struct serves as the interface between users of the endpoint and the protocol implementation; it is legal to have concurrent goroutines make calls into the endpoint, they are properly synchronized. The protocol implementation, however, runs in a single goroutine.

Each endpoint has a few mutexes:

e.mu -> Primary mutex for an endpoint must be held for all operations except in e.Readiness where acquiring it will result in a deadlock in epoll implementation.

The following three mutexes can be acquired independent of e.mu but if acquired with e.mu then e.mu must be acquired first.

e.acceptMu -> Protects e.acceptQueue. e.rcvQueueMu -> Protects e.rcvQueue's associated fields but not e.rcvQueue itself. e.sndQueueMu -> Protects the e.sndQueue and associated fields. e.lastErrorMu -> Protects the lastError field.

LOCKING/UNLOCKING of the endpoint. The locking of an endpoint is different based on the context in which the lock is acquired. In the syscall context e.LockUser/e.UnlockUser should be used and when doing background processing e.mu.Lock/e.mu.Unlock should be used. The distinction is described below in brief.

The reason for this locking behaviour is to avoid wakeups to handle packets. In cases where the endpoint is already locked the background processor can queue the packet up and go its merry way and the lock owner will eventually process the backlog when releasing the lock. Similarly when acquiring the lock from say a syscall goroutine we can implement a bit of spinning if we know that the lock is not held by another syscall goroutine. Background processors should never hold the lock for long and we can avoid an expensive sleep/wakeup by spinning for a shortwhile.

For more details please see the detailed documentation on e.LockUser/e.UnlockUser methods.

+stateify savable

func (*Endpoint) Abort 

func (e *Endpoint) Abort()

Abort implements stack.TransportEndpoint.Abort.

func (*Endpoint) Accept 

func (e *Endpoint) Accept(peerAddr *tcpip.FullAddress) (tcpip.Endpoint, *waiter.Queue, tcpip.Error)

Accept returns a new endpoint if a peer has established a connection to an endpoint previously set to listen mode.

addr if not-nil will contain the peer address of the returned endpoint.

func (*Endpoint) AssertLockHeld 

func (e *Endpoint) AssertLockHeld(locked *Endpoint)

AssertLockHeld forces the checklocks analyzer to consider e.mu held. This is used in places where we know that e.mu is held, but checklocks does not, which can happen when creating new locked objects. You must pass the known locked endpoint to this function and it must be the same as the caller endpoint. TODO(b/226403629): Remove this function once checklocks understands local variable locks. +checklocks:locked.mu +checklocksacquire:e.mu

func (*Endpoint) Bind 

func (e *Endpoint) Bind(addr tcpip.FullAddress) (err tcpip.Error)

Bind binds the endpoint to a specific local port and optionally address.

func (*Endpoint) Close 

func (e *Endpoint) Close()

Close puts the endpoint in a closed state and frees all resources associated with it. It must be called only once and with no other concurrent calls to the endpoint.

func (*Endpoint) Connect 

func (e *Endpoint) Connect(addr tcpip.FullAddress) tcpip.Error

Connect connects the endpoint to its peer.

func (*Endpoint) ConnectEndpoint 

func (*Endpoint) ConnectEndpoint(tcpip.Endpoint) tcpip.Error

ConnectEndpoint is not supported.

func (*Endpoint) Disconnect 

func (*Endpoint) Disconnect() tcpip.Error

Disconnect implements tcpip.Endpoint.Disconnect.

func (*Endpoint) EndpointState 

func (e *Endpoint) EndpointState() EndpointState

EndpointState returns the current state of the endpoint.

func (*Endpoint) GetAcceptConn 

func (e *Endpoint) GetAcceptConn() bool

GetAcceptConn implements tcpip.SocketOptionsHandler.

func (*Endpoint) GetLocalAddress 

func (e *Endpoint) GetLocalAddress() (tcpip.FullAddress, tcpip.Error)

GetLocalAddress returns the address to which the endpoint is bound.

func (*Endpoint) GetRemoteAddress 

func (e *Endpoint) GetRemoteAddress() (tcpip.FullAddress, tcpip.Error)

GetRemoteAddress returns the address to which the endpoint is connected.

func (*Endpoint) GetSockOpt 

func (e *Endpoint) GetSockOpt(opt tcpip.GettableSocketOption) tcpip.Error

GetSockOpt implements tcpip.Endpoint.GetSockOpt.

func (*Endpoint) GetSockOptInt 

func (e *Endpoint) GetSockOptInt(opt tcpip.SockOptInt) (int, tcpip.Error)

GetSockOptInt implements tcpip.Endpoint.GetSockOptInt.

func (*Endpoint) HandleError 

func (e *Endpoint) HandleError(transErr stack.TransportError, pkt *stack.PacketBuffer)

HandleError implements stack.TransportEndpoint.

func (*Endpoint) HandlePacket 

func (*Endpoint) HandlePacket(stack.TransportEndpointID, *stack.PacketBuffer)

HandlePacket implements stack.TransportEndpoint.HandlePacket.

func (*Endpoint) HasNIC 

func (e *Endpoint) HasNIC(id int32) bool

HasNIC returns true if the NICID is defined in the stack or id is 0.

func (*Endpoint) Info 

func (e *Endpoint) Info() tcpip.EndpointInfo

Info returns a copy of the endpoint info.

func (*Endpoint) LastError 

func (e *Endpoint) LastError() tcpip.Error

LastError implements tcpip.Endpoint.LastError.

func (*Endpoint) LastErrorLocked 

func (e *Endpoint) LastErrorLocked() tcpip.Error

LastErrorLocked reads and clears lastError. Only to be used in tests. +checklocks:e.mu

func (*Endpoint) Listen 

func (e *Endpoint) Listen(backlog int) tcpip.Error

Listen puts the endpoint in "listen" mode, which allows it to accept new connections.

func (*Endpoint) LockUser 

func (e *Endpoint) LockUser()

LockUser tries to lock e.mu and if it fails it will check if the lock is held by another syscall goroutine. If yes, then it will goto sleep waiting for the lock to be released, if not then it will spin till it acquires the lock or another syscall goroutine acquires it in which case it will goto sleep as described above.

The assumption behind spinning here being that background packet processing should not be holding the lock for long and spinning reduces latency as we avoid an expensive sleep/wakeup of the syscall goroutine). +checklocksacquire:e.mu

func (*Endpoint) ModerateRecvBuf 

func (e *Endpoint) ModerateRecvBuf(copied int)

ModerateRecvBuf adjusts the receive buffer and the advertised window based on the number of bytes copied to userspace.

func (*Endpoint) OnCorkOptionSet 

func (e *Endpoint) OnCorkOptionSet(v bool)

OnCorkOptionSet implements tcpip.SocketOptionsHandler.OnCorkOptionSet.

func (*Endpoint) OnDelayOptionSet 

func (e *Endpoint) OnDelayOptionSet(v bool)

OnDelayOptionSet implements tcpip.SocketOptionsHandler.OnDelayOptionSet.

func (*Endpoint) OnKeepAliveSet 

func (e *Endpoint) OnKeepAliveSet(bool)

OnKeepAliveSet implements tcpip.SocketOptionsHandler.OnKeepAliveSet.

func (*Endpoint) OnReuseAddressSet 

func (e *Endpoint) OnReuseAddressSet(v bool)

OnReuseAddressSet implements tcpip.SocketOptionsHandler.OnReuseAddressSet.

func (*Endpoint) OnReusePortSet 

func (e *Endpoint) OnReusePortSet(v bool)

OnReusePortSet implements tcpip.SocketOptionsHandler.OnReusePortSet.

func (*Endpoint) OnSetReceiveBufferSize 

func (e *Endpoint) OnSetReceiveBufferSize(rcvBufSz, oldSz int64) (newSz int64, postSet func())

OnSetReceiveBufferSize implements tcpip.SocketOptionsHandler.OnSetReceiveBufferSize.

func (*Endpoint) OnSetSendBufferSize 

func (e *Endpoint) OnSetSendBufferSize(sz int64) int64

OnSetSendBufferSize implements tcpip.SocketOptionsHandler.OnSetSendBufferSize.

func (*Endpoint) Read 

func (e *Endpoint) Read(dst io.Writer, opts tcpip.ReadOptions) (tcpip.ReadResult, tcpip.Error)

Read implements tcpip.Endpoint.Read.

func (*Endpoint) Readiness 

func (e *Endpoint) Readiness(mask waiter.EventMask) waiter.EventMask

Readiness returns the current readiness of the endpoint. For example, if waiter.EventIn is set, the endpoint is immediately readable.

func (*Endpoint) Restore 

func (e *Endpoint) Restore(s *stack.Stack)

Restore implements tcpip.RestoredEndpoint.Restore.

func (*Endpoint) Resume 

func (e *Endpoint) Resume()

Resume implements tcpip.ResumableEndpoint.Resume.

func (*Endpoint) ResumeWork 

func (e *Endpoint) ResumeWork()

ResumeWork resumes packet processing. Only to be used in tests. +checklocksrelease:e.mu

func (*Endpoint) SetOwner 

func (e *Endpoint) SetOwner(owner tcpip.PacketOwner)

SetOwner implements tcpip.Endpoint.SetOwner.

func (*Endpoint) SetSockOpt 

func (e *Endpoint) SetSockOpt(opt tcpip.SettableSocketOption) tcpip.Error

SetSockOpt sets a socket option.

func (*Endpoint) SetSockOptInt 

func (e *Endpoint) SetSockOptInt(opt tcpip.SockOptInt, v int) tcpip.Error

SetSockOptInt sets a socket option.

func (*Endpoint) Shutdown 

func (e *Endpoint) Shutdown(flags tcpip.ShutdownFlags) tcpip.Error

Shutdown closes the read and/or write end of the endpoint connection to its peer.

func (*Endpoint) SocketOptions 

func (e *Endpoint) SocketOptions() *tcpip.SocketOptions

SocketOptions implements tcpip.Endpoint.SocketOptions.

func (*Endpoint) State 

func (e *Endpoint) State() uint32

State implements tcpip.Endpoint.State. It exports the endpoint's protocol state for diagnostics.

func (*Endpoint) Stats 

func (e *Endpoint) Stats() tcpip.EndpointStats

Stats returns a pointer to the endpoint stats.

func (*Endpoint) StopWork 

func (e *Endpoint) StopWork()

StopWork halts packet processing. Only to be used in tests. +checklocksacquire:e.mu

func (*Endpoint) TryLock 

func (e *Endpoint) TryLock() bool

TryLock is a helper that calls TryLock on the endpoint's mutex and adds the necessary checklocks annotations. TODO(b/226403629): Remove this once checklocks understands TryLock. +checklocksacquire:e.mu

func (*Endpoint) UnlockUser 

func (e *Endpoint) UnlockUser()

UnlockUser will check if there are any segments already queued for processing and wake up a processor goroutine to process them before unlocking e.mu. This is required because we when packets arrive and endpoint lock is already held then such packets are queued up to be processed.

Precondition: e.LockUser() must have been called before calling e.UnlockUser() +checklocksrelease:e.mu

func (*Endpoint) UpdateLastError 

func (e *Endpoint) UpdateLastError(err tcpip.Error)

UpdateLastError implements tcpip.SocketOptionsHandler.UpdateLastError.

func (*Endpoint) Wait 

func (e *Endpoint) Wait()

Wait implements stack.TransportEndpoint.Wait.

func (*Endpoint) WakeupWriters 

func (e *Endpoint) WakeupWriters()

WakeupWriters implements tcpip.SocketOptionsHandler.WakeupWriters.

func (*Endpoint) Write 

func (e *Endpoint) Write(p tcpip.Payloader, opts tcpip.WriteOptions) (int64, tcpip.Error)

Write writes data to the endpoint's peer.

type EndpointState 

type EndpointState tcpip.EndpointState

EndpointState represents the state of a TCP endpoint. 

const (

	// TCP protocol states in sync with the definitions in
	// https://github.com/torvalds/linux/blob/7acac4b3196/include/net/tcp_states.h#L13
	StateEstablished EndpointState
	StateSynSent
	StateSynRecv
	StateFinWait1
	StateFinWait2
	StateTimeWait
	StateClose
	StateCloseWait
	StateLastAck
	StateListen
	StateClosing

	// Endpoint states internal to netstack.
	StateInitial
	StateBound
	StateConnecting // Connect() called, but the initial SYN hasn't been sent.
	StateError
)

Endpoint states. Note that are represented in a netstack-specific manner and may not be meaningful externally. Specifically, they need to be translated to Linux's representation for these states if presented to userspace.

func (EndpointState) String 

func (s EndpointState) String() string

String implements fmt.Stringer.String.

type Forwarder 

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

Forwarder is a connection request forwarder, which allows clients to decide what to do with a connection request, for example: ignore it, send a RST, or attempt to complete the 3-way handshake.

The canonical way of using it is to pass the Forwarder.HandlePacket function to stack.SetTransportProtocolHandler.

func NewForwarder 

func NewForwarder(s *stack.Stack, rcvWnd, maxInFlight int, handler func(*ForwarderRequest)) *Forwarder

NewForwarder allocates and initializes a new forwarder with the given maximum number of in-flight connection attempts. Once the maximum is reached new incoming connection requests will be ignored.

If rcvWnd is set to zero, the default buffer size is used instead.

func (*Forwarder) HandlePacket 

func (f *Forwarder) HandlePacket(id stack.TransportEndpointID, pkt *stack.PacketBuffer) bool

HandlePacket handles a packet if it is of interest to the forwarder (i.e., if it's a SYN packet), returning true if it's the case. Otherwise the packet is not handled and false is returned.

This function is expected to be passed as an argument to the stack.SetTransportProtocolHandler function.

type ForwarderRequest 

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

ForwarderRequest represents a connection request received by the forwarder and passed to the client. Clients must eventually call Complete() on it, and may optionally create an endpoint to represent it via CreateEndpoint.

func (*ForwarderRequest) Complete 

func (r *ForwarderRequest) Complete(sendReset bool)

Complete completes the request, and optionally sends a RST segment back to the sender.

func (*ForwarderRequest) CreateEndpoint 

func (r *ForwarderRequest) CreateEndpoint(queue *waiter.Queue) (tcpip.Endpoint, tcpip.Error)

CreateEndpoint creates a TCP endpoint for the connection request, performing the 3-way handshake in the process.

func (*ForwarderRequest) ID 

func (r *ForwarderRequest) ID() stack.TransportEndpointID

ID returns the 4-tuple (src address, src port, dst address, dst port) that represents the connection request.

type ReceiveErrors 

type ReceiveErrors struct {
	tcpip.ReceiveErrors

	// SegmentQueueDropped is the number of segments dropped due to
	// a full segment queue.
	SegmentQueueDropped tcpip.StatCounter

	// ChecksumErrors is the number of segments dropped due to bad checksums.
	ChecksumErrors tcpip.StatCounter

	// ListenOverflowSynDrop is the number of times the listen queue overflowed
	// and a SYN was dropped.
	ListenOverflowSynDrop tcpip.StatCounter

	// ListenOverflowAckDrop is the number of times the final ACK
	// in the handshake was dropped due to overflow.
	ListenOverflowAckDrop tcpip.StatCounter

	// ZeroRcvWindowState is the number of times we advertised
	// a zero receive window when rcvQueue is full.
	ZeroRcvWindowState tcpip.StatCounter

	// WantZeroWindow is the number of times we wanted to advertise a
	// zero receive window but couldn't because it would have caused
	// the receive window's right edge to shrink.
	WantZeroRcvWindow tcpip.StatCounter
}

ReceiveErrors collect segment receive errors within transport layer.

+stateify savable

type SACKInfo 

type SACKInfo struct {
	// Blocks is the maximum number of SACK blocks we track
	// per endpoint.
	Blocks [MaxSACKBlocks]header.SACKBlock

	// NumBlocks is the number of valid SACK blocks stored in the
	// blocks array above.
	NumBlocks int
}

SACKInfo holds TCP SACK related information for a given endpoint.

+stateify savable

type SACKScoreboard 

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

SACKScoreboard stores a set of disjoint SACK ranges.

+stateify savable

func NewSACKScoreboard 

func NewSACKScoreboard(smss uint16, iss seqnum.Value) *SACKScoreboard

NewSACKScoreboard returns a new SACK Scoreboard.

func (*SACKScoreboard) Copy 

func (s *SACKScoreboard) Copy() (sackBlocks []header.SACKBlock, maxSACKED seqnum.Value)

Copy provides a copy of the SACK scoreboard.

func (*SACKScoreboard) Delete 

func (s *SACKScoreboard) Delete(seq seqnum.Value)

Delete removes all SACK information prior to seq.

func (*SACKScoreboard) Empty 

func (s *SACKScoreboard) Empty() bool

Empty returns true if the SACK scoreboard has no entries, false otherwise.

func (*SACKScoreboard) Insert 

func (s *SACKScoreboard) Insert(r header.SACKBlock)

Insert inserts/merges the provided SACKBlock into the scoreboard.

func (*SACKScoreboard) IsLost 

func (s *SACKScoreboard) IsLost(seq seqnum.Value) bool

IsLost implements the IsLost(SeqNum) operation defined in RFC3517 section 4.

This routine returns whether the given sequence number is considered to be lost. The routine returns true when either nDupAckThreshold discontiguous SACKed sequences have arrived above 'SeqNum' or (nDupAckThreshold * SMSS) bytes with sequence numbers greater than 'SeqNum' have been SACKed. Otherwise, the routine returns false.

func (*SACKScoreboard) IsRangeLost 

func (s *SACKScoreboard) IsRangeLost(r header.SACKBlock) bool

IsRangeLost implements the IsLost(SeqNum) operation defined in RFC 6675 section 4 but operates on a range of sequence numbers and returns true if there are at least nDupAckThreshold SACK blocks greater than the range being checked or if at least (nDupAckThreshold-1)*s.smss bytes have been SACKED with sequence numbers greater than the block being checked.

func (*SACKScoreboard) IsSACKED 

func (s *SACKScoreboard) IsSACKED(r header.SACKBlock) bool

IsSACKED returns true if the a given range of sequence numbers denoted by r are already covered by SACK information in the scoreboard.

func (*SACKScoreboard) MaxSACKED 

func (s *SACKScoreboard) MaxSACKED() seqnum.Value

MaxSACKED returns the highest sequence number ever inserted in the SACK scoreboard.

func (*SACKScoreboard) Reset 

func (s *SACKScoreboard) Reset()

Reset erases all known range information from the SACK scoreboard.

func (*SACKScoreboard) SMSS 

func (s *SACKScoreboard) SMSS() uint16

SMSS returns the sender's MSS as held by the SACK scoreboard.

func (*SACKScoreboard) Sacked 

func (s *SACKScoreboard) Sacked() seqnum.Size

Sacked returns the current number of bytes held in the SACK scoreboard.

func (*SACKScoreboard) String 

func (s *SACKScoreboard) String() string

String returns human-readable state of the scoreboard structure.

type SendErrors 

type SendErrors struct {
	tcpip.SendErrors

	// SegmentSendToNetworkFailed is the number of TCP segments failed to be sent
	// to the network endpoint.
	SegmentSendToNetworkFailed tcpip.StatCounter

	// SynSendToNetworkFailed is the number of TCP SYNs failed to be sent
	// to the network endpoint.
	SynSendToNetworkFailed tcpip.StatCounter

	// Retransmits is the number of TCP segments retransmitted.
	Retransmits tcpip.StatCounter

	// FastRetransmit is the number of segments retransmitted in fast
	// recovery.
	FastRetransmit tcpip.StatCounter

	// Timeouts is the number of times the RTO expired.
	Timeouts tcpip.StatCounter
}

SendErrors collect segment send errors within the transport layer.

+stateify savable

type Stats 

type Stats struct {
	// SegmentsReceived is the number of TCP segments received that
	// the transport layer successfully parsed.
	SegmentsReceived tcpip.StatCounter

	// SegmentsSent is the number of TCP segments sent.
	SegmentsSent tcpip.StatCounter

	// FailedConnectionAttempts is the number of times we saw Connect and
	// Accept errors.
	FailedConnectionAttempts tcpip.StatCounter

	// ReceiveErrors collects segment receive errors within the
	// transport layer.
	ReceiveErrors ReceiveErrors

	// ReadErrors collects segment read errors from an endpoint read call.
	ReadErrors tcpip.ReadErrors

	// SendErrors collects segment send errors within the transport layer.
	SendErrors SendErrors

	// WriteErrors collects segment write errors from an endpoint write call.
	WriteErrors tcpip.WriteErrors
}

Stats holds statistics about the endpoint.

+stateify savable

func (*Stats) IsEndpointStats 

func (*Stats) IsEndpointStats()

IsEndpointStats is an empty method to implement the tcpip.EndpointStats marker interface.

Source Files

View all Source files

Directories

Path Synopsis
test
e2e
Package e2e contains definitions common to all e2e tcp tests.
 Package e2e contains definitions common to all e2e tcp tests.
testing
context
Package context provides a test context for use in tcp tests.
 Package context provides a test context for use in tcp tests.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.