ackhandler

package
v4.14.0+incompatible Latest Latest
Warning

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

Go to latest
Published: Jan 30, 2019 License: MIT, MIT Imports: 10 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func HasRetransmittableFrames

func HasRetransmittableFrames(fs []wire.Frame) bool

HasRetransmittableFrames returns true if at least one frame is retransmittable.

func IsFrameRetransmittable

func IsFrameRetransmittable(f wire.Frame) bool

IsFrameRetransmittable returns true if the frame should be retransmitted.

Types

type Packet

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

A Packet is a 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)

	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
	SetHandshakeComplete()

	// 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.PacketNumber, protocol.PacketNumberLen)
	PopPacketNumber() 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