ackhandler

package
v0.0.0-...-ffe55c2 Latest Latest
Warning

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

Go to latest
Published: May 24, 2022 License: MIT Imports: 10 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func HasAckElicitingFrames

func HasAckElicitingFrames(fs []wire.Frame) bool

HasAckElicitingFrames returns true if at least one frame is ack-eliciting.

func IsFrameAckEliciting

func IsFrameAckEliciting(f wire.Frame) bool

IsFrameAckEliciting returns true if the frame is ack-eliciting.

Types

type Packet

type Packet struct {
	PacketNumber    protocol.PacketNumber
	PacketType      protocol.PacketType
	Ack             *wire.AckFrame
	Frames          []wire.Frame
	Length          protocol.ByteCount
	EncryptionLevel protocol.EncryptionLevel
	SendTime        time.Time
	// contains filtered or unexported fields
}

A Packet is a packet

func (*Packet) ToPacket

func (p *Packet) ToPacket() *protocol.Packet

type PacketElement

type PacketElement struct {

	// The value stored with this element.
	Value Packet
	// contains filtered or unexported fields
}

PacketElement is an element of a linked list.

func (*PacketElement) Next

func (e *PacketElement) Next() *PacketElement

Next returns the next list element or nil.

func (*PacketElement) Prev

func (e *PacketElement) Prev() *PacketElement

Prev returns the previous list element or nil.

type PacketList

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

PacketList is a linked list of Packets.

func NewPacketList

func NewPacketList() *PacketList

NewPacketList returns an initialized list.

func (*PacketList) Back

func (l *PacketList) Back() *PacketElement

Back returns the last element of list l or nil if the list is empty.

func (*PacketList) Front

func (l *PacketList) Front() *PacketElement

Front returns the first element of list l or nil if the list is empty.

func (*PacketList) Init

func (l *PacketList) Init() *PacketList

Init initializes or clears list l.

func (*PacketList) InsertAfter

func (l *PacketList) InsertAfter(v Packet, mark *PacketElement) *PacketElement

InsertAfter inserts a new element e with value v immediately after mark and returns e. If mark is not an element of l, the list is not modified. The mark must not be nil.

func (*PacketList) InsertBefore

func (l *PacketList) InsertBefore(v Packet, mark *PacketElement) *PacketElement

InsertBefore inserts a new element e with value v immediately before mark and returns e. If mark is not an element of l, the list is not modified. The mark must not be nil.

func (*PacketList) Len

func (l *PacketList) Len() int

Len returns the number of elements of list l. The complexity is O(1).

func (*PacketList) MoveAfter

func (l *PacketList) MoveAfter(e, mark *PacketElement)

MoveAfter moves element e to its new position after mark. If e or mark is not an element of l, or e == mark, the list is not modified. The element and mark must not be nil.

func (*PacketList) MoveBefore

func (l *PacketList) MoveBefore(e, mark *PacketElement)

MoveBefore moves element e to its new position before mark. If e or mark is not an element of l, or e == mark, the list is not modified. The element and mark must not be nil.

func (*PacketList) MoveToBack

func (l *PacketList) MoveToBack(e *PacketElement)

MoveToBack moves element e to the back of list l. If e is not an element of l, the list is not modified. The element must not be nil.

func (*PacketList) MoveToFront

func (l *PacketList) MoveToFront(e *PacketElement)

MoveToFront moves element e to the front of list l. If e is not an element of l, the list is not modified. The element must not be nil.

func (*PacketList) PushBack

func (l *PacketList) PushBack(v Packet) *PacketElement

PushBack inserts a new element e with value v at the back of list l and returns e.

func (*PacketList) PushBackList

func (l *PacketList) PushBackList(other *PacketList)

PushBackList inserts a copy of an other list at the back of list l. The lists l and other may be the same. They must not be nil.

func (*PacketList) PushFront

func (l *PacketList) PushFront(v Packet) *PacketElement

PushFront inserts a new element e with value v at the front of list l and returns e.

func (*PacketList) PushFrontList

func (l *PacketList) PushFrontList(other *PacketList)

PushFrontList inserts a copy of an other list at the front of list l. The lists l and other may be the same. They must not be nil.

func (*PacketList) Remove

func (l *PacketList) Remove(e *PacketElement) Packet

Remove removes e from l if e is an element of list l. It returns the element value e.Value. The element must not be nil.

type ReceivedPacketHandler

type ReceivedPacketHandler interface {
	ReceivedPacket(pn protocol.PacketNumber, encLevel protocol.EncryptionLevel, rcvTime time.Time, shouldInstigateAck bool) error
	IgnoreBelow(protocol.PacketNumber)
	DropPackets(protocol.EncryptionLevel)

	GetAlarmTimeout() time.Time
	GetAckFrame(protocol.EncryptionLevel) *wire.AckFrame
}

ReceivedPacketHandler handles ACKs needed to send for incoming packets

func NewReceivedPacketHandler

func NewReceivedPacketHandler(
	rttStats *congestion.RTTStats,
	logger utils.Logger,
	version protocol.VersionNumber,
) ReceivedPacketHandler

NewReceivedPacketHandler creates a new receivedPacketHandler

type SendMode

type SendMode uint8

The SendMode says what kind of packets can be sent.

const (
	// SendNone means that no packets should be sent
	SendNone SendMode = iota
	// SendAck means an ACK-only packet should be sent
	SendAck
	// SendRetransmission means that retransmissions should be sent
	SendRetransmission
	// SendPTO means that a probe packet should be sent
	SendPTO
	// SendAny means that any packet should be sent
	SendAny
)

func (SendMode) String

func (s SendMode) String() string

type SentPacketHandler

type SentPacketHandler interface {
	// SentPacket may modify the packet
	SentPacket(packet *Packet)
	SentPacketsAsRetransmission(packets []*Packet, retransmissionOf protocol.PacketNumber)
	ReceivedAck(ackFrame *wire.AckFrame, withPacketNumber protocol.PacketNumber, encLevel protocol.EncryptionLevel, recvTime time.Time) error
	SetMaxAckDelay(time.Duration)
	DropPackets(protocol.EncryptionLevel)
	ResetForRetry() error

	// The SendMode determines if and what kind of packets can be sent.
	SendMode() SendMode
	// TimeUntilSend is the time when the next packet should be sent.
	// It is used for pacing packets.
	TimeUntilSend() time.Time
	// ShouldSendNumPackets returns the number of packets that should be sent immediately.
	// It always returns a number greater or equal than 1.
	// A number greater than 1 is returned when the pacing delay is smaller than the minimum pacing delay.
	// Note that the number of packets is only calculated based on the pacing algorithm.
	// Before sending any packet, SendingAllowed() must be called to learn if we can actually send it.
	ShouldSendNumPackets() int

	// only to be called once the handshake is complete
	GetLowestPacketNotConfirmedAcked() protocol.PacketNumber
	DequeuePacketForRetransmission() *Packet
	DequeueProbePacket() (*Packet, error)

	PeekPacketNumber(protocol.EncryptionLevel) (protocol.PacketNumber, protocol.PacketNumberLen)
	PopPacketNumber(protocol.EncryptionLevel) protocol.PacketNumber

	GetAlarmTimeout() time.Time
	OnAlarm() error
}

SentPacketHandler handles ACKs received for outgoing packets

func NewSentPacketHandler

func NewSentPacketHandler(
	initialPacketNumber protocol.PacketNumber,
	rttStats *congestion.RTTStats,
	logger utils.Logger,
) SentPacketHandler

NewSentPacketHandler creates a new sentPacketHandler

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL