utp

type CongestionAlgorithm int

type Conn interface {
	// ReadFrom reads one datagram into b and returns its length and sender.
	ReadFrom(b []byte) (int, ConnectionPeer, error)
	// WriteTo sends b as one datagram to dst.
	WriteTo(b []byte, dst ConnectionPeer) (int, error)
	// Close closes the transport, ending a ReadFrom in progress.
	Close() error
}

type ConnectionConfig struct {
	// MaxPacketSize is the largest datagram the connection sends, in bytes:
	// the ceiling of its path-MTU search.
	MaxPacketSize uint16
	// MaxConnAttempts is how many times the SYN is sent before a dial gives
	// up with ErrTimedOut.
	MaxConnAttempts int
	// MaxIdleTimeout closes the connection with ErrTimedOut once nothing has
	// been received and nothing written for this long. Zero, the default,
	// disables it: a connection whose peer vanished while nothing was in
	// flight stays open until the application closes it, and one
	// interrupted by an outage resumes when the path returns. A live peer
	// sends a keep-alive every 29 seconds, so a value well above that never
	// closes a live connection.
	MaxIdleTimeout time.Duration
	// InitialTimeout is the retransmission timeout before the first
	// round-trip sample, and the SYN's first timeout.
	InitialTimeout time.Duration
	// MinTimeout is the floor of the retransmission timeout.
	MinTimeout time.Duration
	// MaxTimeout caps the retransmission timeout and its backoff. Zero, the
	// default, means no cap.
	MaxTimeout time.Duration
	// TargetDelay is the queuing delay classic LEDBAT aims for.
	TargetDelay time.Duration

	// DelayWindow is how far back the congestion controller looks for its
	// base delay: the lowest one-way delay seen, taken as the delay of an
	// empty queue. The window is kept in thirteen buckets; the default is
	// thirteen minutes. See baseDelayHist.
	//
	// The window bounds the error clock drift causes: a sender whose clock
	// runs slow sees its measured delay grow until inflated samples age out,
	// so the steady-state error is the window times the drift rate.
	DelayWindow time.Duration
	// WindowSize is the upper bound on the congestion window, in bytes.
	WindowSize uint32
	// BufferSize is the size of the send and receive buffers, in bytes. The
	// receive window advertised to the peer is at most this.
	BufferSize int

	// Metrics, when set, receives periodic snapshots of this connection.
	// See MetricsObserver for the constraints on the callback.
	Metrics MetricsObserver
	// MetricsInterval is the minimum gap between snapshots. Defaults to
	// DefaultMetricsInterval.
	MetricsInterval time.Duration
	// KeepAliveInterval is how long an established connection may stay
	// silent before sending a keep-alive. The default of 29 seconds is below
	// the 30-second UDP mapping timeout common in NATs.
	KeepAliveInterval time.Duration
	// ZeroWindowProbeInterval is how long a zero receive window from the
	// peer is tolerated before one packet is sent to elicit a window update.
	// The peer's update when it reopens the window is a single packet; if it
	// is lost, the sender would otherwise have nothing outstanding and no
	// reason to transmit. The default is 15 seconds.
	ZeroWindowProbeInterval time.Duration
	// CongestionAlgorithm selects the congestion controller. The zero value
	// is AlgorithmLEDBAT; AlgorithmLEDBATPP selects LEDBAT++, which is
	// experimental.
	CongestionAlgorithm CongestionAlgorithm
	// RACK replaces the default loss detection, under which a packet is lost
	// once three packets sent after it are acknowledged, with the
	// time-based rule of RFC 8985. Off by default. Experimental.
	RACK bool
	// NoDelay sends a partial packet as soon as the window allows, like
	// TCP_NODELAY. By default a packet smaller than the maximum waits while
	// anything else is unacknowledged, and later writes are appended to it
	// until it is full, everything before it is acknowledged, or the write
	// side closes. NoDelay lowers latency for small writes at the cost of
	// more, smaller packets.
	NoDelay bool
	// contains filtered or unexported fields
}

type ConnectionID struct {
	// Send is the id this end sends with: the peer's receive id.
	Send uint16
	// Recv is the id this end receives on.
	Recv uint16
	// Peer is the remote end.
	Peer ConnectionPeer
	// contains filtered or unexported fields
}

type ConnectionMetrics struct {
	// At is when the snapshot was taken.
	At time.Time
	// CID identifies the connection.
	CID *ConnectionID

	// CwndBytes is the congestion window: what the controller believes the
	// path will carry.
	CwndBytes uint32
	// InFlightBytes is the volume the controller considers outstanding.
	InFlightBytes uint32
	// MinCwndBytes is the floor the window will not drop below. A controller
	// pinned here has collapsed.
	MinCwndBytes uint32
	// PeerRecvWindow is the peer's advertised receive window. When this is
	// smaller than CwndBytes, flow control -- not congestion control -- is
	// what limits sending.
	PeerRecvWindow uint32
	// RTT is the smoothed round-trip estimate, in whole milliseconds.
	RTT time.Duration
	// FineRTT is the same estimate kept in microseconds, for measuring a
	// queue a millisecond or two deep.
	FineRTT time.Duration
	// RTTVarianceMicros is the RTT variance estimate, in microseconds.
	RTTVarianceMicros int64
	// Timeout is the current retransmission timeout.
	Timeout time.Duration
	// BaseDelay is the lowest one-way delay seen in the delay window:
	// LEDBAT's estimate of the path with an empty queue. CurrentDelay is the
	// newest sample of the same series.
	//
	// Both measure the outbound path, as reported by the peer in the
	// timestamp_difference field; that is the direction LEDBAT controls.
	// PeerTimestampDiff measures the inbound path.
	BaseDelay    time.Duration
	CurrentDelay time.Duration
	// ClockSkewCorrection is how much has been added to BaseDelay to cancel
	// clock drift between the two ends, detected from the peer's own base
	// delay falling. Zero on a pair of clocks running at the same rate.
	ClockSkewCorrection time.Duration

	// ClockDrift is the estimated slope of the delay the peer reports for
	// our packets, in microseconds per five-second slot, smoothed 7:1
	// towards its history. A negative value means the reported delay is
	// falling, as when the peer's clock runs slow; below -200000 it incurs
	// a penalty (ClockDriftPenalty).
	//
	// ClockSkewCorrection corrects for ordinary drift between honest
	// clocks; ClockDrift detects drift far outside what hardware produces.
	ClockDrift int64

	// ClockDriftPenalty is how much is currently added to the measured
	// queuing delay because of ClockDrift. It is zero on any ordinary path.
	ClockDriftPenalty time.Duration

	// MtuCurrent is the datagram size the path-MTU search is currently
	// sending, and MtuFloor and MtuCeiling bound the sizes it has yet to
	// test. A converged search has all three equal.
	MtuCurrent uint32
	MtuFloor   uint32
	MtuCeiling uint32

	// MtuProbesLostToDuplicateAcks counts probes that duplicate
	// acknowledgements showed were too large for the path.
	MtuProbesLostToDuplicateAcks uint64

	// WindowReopenedAcks counts acknowledgements sent because delivering
	// data to the application opened a receive window larger than the one
	// last advertised. It is zero while the reader keeps up, since the
	// acknowledgement for incoming data already carries a current window.
	WindowReopenedAcks uint64

	// PeerTimestampDiff is the one-way delay measured from the peer's timestamps:
	// how long the peer's last packet took to arrive. It is echoed back in
	// timestamp_difference_microseconds. It measures the inbound path,
	// whereas BaseDelay and CurrentDelay measure the outbound one.
	PeerTimestampDiff time.Duration
	// TargetDelayMicros is the standing queue the controller aims for.
	TargetDelayMicros uint32
	// SlowStart reports whether the controller is still in slow start.
	SlowStart bool
	// AppLimitedSince is how long since the sender last had data to send
	// and no window to send it in. After a second the controller stops
	// growing the window, since an unfilled window measures nothing. Zero
	// means the window has never been filled.
	AppLimitedSince time.Duration

	// PacketsSent and BytesSent count every transmission, retransmissions
	// included.
	PacketsSent uint64
	BytesSent   uint64
	// PacketsRetransmitted and BytesRetransmitted count only retransmissions.
	// The ratio to PacketsSent is the retransmit rate.
	PacketsRetransmitted uint64
	BytesRetransmitted   uint64
	// PacketsReceived and BytesReceived count packets accepted from the peer.
	PacketsReceived uint64
	BytesReceived   uint64
	// Timeouts counts retransmission-timeout events.
	Timeouts uint64
	// FastRetransmits counts packets resent because they were declared lost
	// by duplicate acks rather than by a timeout.
	FastRetransmits uint64
	// LossProbes counts packets resent by the loss probe because nothing had
	// been acknowledged for a probe timeout, shorter than the retransmission
	// timeout.
	LossProbes uint64
	// RackLosses counts packets declared lost by RACK loss detection, and
	// RackRelosts those that were already retransmissions. Both are zero
	// with RACK off.
	RackLosses  uint64
	RackRelosts uint64

	// SendBufferPending is unsent application data still buffered.
	SendBufferPending int
	// RecvBufferPending is received data not yet read by the application,
	// contiguous or held behind a gap.
	RecvBufferPending int
	// RecvBufferReadable is the contiguous part of RecvBufferPending, which
	// can be delivered now. The difference is data held behind a gap; a
	// large difference indicates a receiver waiting on a missing packet
	// rather than a slow reader.
	RecvBufferReadable int
	// RecvBufferDrops counts data packets refused because the receive
	// buffer had no room. Each is a gap the peer must fill by
	// retransmission.
	RecvBufferDrops uint64
	// PendingWrites is the number of queued write requests.
	PendingWrites int

	// State is the connection's state: "connecting", "connected" or "closed".
	State string
}

type ConnectionPeer interface {
	// Hash returns the peer's key, conventionally its address as text.
	Hash() string
}

type DontFragmentWriter interface {
	WriteToDontFragment(b []byte, dst ConnectionPeer) (int, error)
}

type MetricsObserver func(ConnectionMetrics)

type PathMTUProvider interface {
	PathMTU(peer ConnectionPeer) (int, bool)
}

type QueuedReader interface {
	Queued() int
}

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

type SocketOption func(*Socket)

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

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