tcp

package
v0.0.0-...-55fcc16 Latest Latest
Warning

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

 Go to latest Published: Nov 23, 2019 License: Apache-2.0 Imports: 24 Imported by: 37

Documentation

Overview

Package tcp contains the implementation of the TCP transport protocol. To use it in the networking stack, this package must be added to the project, and activated on the stack by passing tcp.NewProtocol() as one of the transport protocols when calling stack.New(). Then endpoints can be created by passing tcp.ProtocolNumber as the transport protocol number when calling Stack.NewEndpoint().

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

	// MaxUnprocessedSegments is the maximum number of unprocessed segments
	// that can be queued for a given endpoint.
	MaxUnprocessedSegments = 300

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

	// DefaultTCPTimeWaitTimeout is the amount of time that sockets linger
	// in TIME_WAIT state before being marked closed.
	DefaultTCPTimeWaitTimeout = 60 * time.Second
)
View Source 
const (
	// Open indicates that the sender is receiving acks in order and
	// no loss or dupACK's etc have been detected.
	Open ccState = iota
	// RTORecovery indicates that an RTO has occurred and the sender
	// has entered an RTO based recovery phase.
	RTORecovery
	// FastRecovery indicates that the sender has entered FastRecovery
	// based on receiving nDupAck's. This state is entered only when
	// SACK is not in use.
	FastRecovery
	// SACKRecovery indicates that the sender has entered SACK based
	// recovery.
	SACKRecovery
	// Disorder indicates the sender either received some SACK blocks
	// or dupACK's.
	Disorder
)
View Source 
const (

	// InitialCwnd is the initial congestion window.
	InitialCwnd = 10
)
View Source 
const (
	// MaxSACKBlocks is the maximum number of SACK blocks stored
	// at receiver side.
	MaxSACKBlocks = 6
)

Variables

View Source 
var (
	// SynRcvdCountThreshold is the global maximum number of connections
	// that are allowed to be in SYN-RCVD state before TCP starts using SYN
	// cookies to accept connections.
	//
	// It is an exported variable only for testing, and should not otherwise
	// be used by importers of this package.
	SynRcvdCountThreshold uint64 = 1000
)

Functions

func FindWndScale 

func FindWndScale(wnd seqnum.Size) int

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

func NewProtocol 

func NewProtocol() stack.TransportProtocol

NewProtocol returns a TCP transport protocol.

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 DelayEnabled 

type DelayEnabled bool

DelayEnabled option can be used to enable Nagle's algorithm in the TCP protocol.

type EndpointInfo 

type EndpointInfo struct {
	stack.TransportEndpointInfo

	// HardError is meaningful only when state is stateError. It stores the
	// error to be returned when read/write syscalls are called and the
	// endpoint is in this state. HardError is protected by endpoint mu.
	HardError *tcpip.Error
}

EndpointInfo holds useful information about a transport endpoint which can be queried by monitoring tools.

+stateify savable

func (*EndpointInfo) IsEndpointInfo 

func (*EndpointInfo) IsEndpointInfo()

IsEndpointInfo is an empty method to implement the tcpip.EndpointInfo marker interface.

type EndpointState 

type EndpointState uint32

EndpointState represents the state of a TCP endpoint. 

const (
	// Endpoint states internal to netstack. These map to the TCP state CLOSED.
	StateInitial EndpointState = iota
	StateBound
	StateConnecting // Connect() called, but the initial SYN hasn't been sent.
	StateError

	// TCP protocol states.
	StateEstablished
	StateSynSent
	StateSynRecv
	StateFinWait1
	StateFinWait2
	StateTimeWait
	StateClose
	StateCloseWait
	StateLastAck
	StateListen
	StateClosing
)

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(r *stack.Route, id stack.TransportEndpointID, pkt tcpip.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 ReceiveBufferSizeOption 

type ReceiveBufferSizeOption struct {
	Min     int
	Default int
	Max     int
}

ReceiveBufferSizeOption allows the default, min and max receive buffer size for TCP endpoints to be queried or configured.

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 rcvList is full.
	ZeroRcvWindowState tcpip.StatCounter
}

ReceiveErrors collect segment receive errors within transport layer.

type SACKEnabled 

type SACKEnabled bool

SACKEnabled option can be used to enable SACK support in the TCP protocol. See: https://tools.ietf.org/html/rfc2018.

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

Dump prints the state of the scoreboard structure.

type SendBufferSizeOption 

type SendBufferSizeOption struct {
	Min     int
	Default int
	Max     int
}

SendBufferSizeOption allows the default, min and max send buffer sizes for TCP endpoints to be queried or configured.

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.

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.

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
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.