quictracker

type AckECNFrame struct {
	AckFrame
	ECT0Count  uint64
	ECT1Count  uint64
	ECTCECount uint64
}

type AckFrame struct {
	LargestAcknowledged PacketNumber
	AckDelay            uint64
	AckRangeCount       uint64
	AckRanges           []AckRange
}

type AckRange struct {
	Gap      uint64
	AckRange uint64
}

type ApplicationCloseFrame struct {
	// TODO: Merge it with 0x1c
	ErrorCode          uint64
	ReasonPhraseLength uint64
	ReasonPhrase       string
}

type Broadcaster struct {
	broadcast.Broadcaster
	// contains filtered or unexported fields
}

type Connection struct {
	ServerName    string
	UdpConnection *net.UDPConn
	UseIPv6       bool
	Host          *net.UDPAddr
	InterfaceMTU  int

	Tls          *pigotls.Connection
	TLSTPHandler *TLSTransportParameterHandler

	KeyPhaseIndex  uint
	SpinBit        SpinBit
	LastSpinNumber PacketNumber

	CryptoStateLock sync.Locker
	CryptoStates    map[EncryptionLevel]*CryptoState

	ReceivedPacketHandler func([]byte, unsafe.Pointer)
	SentPacketHandler     func([]byte, unsafe.Pointer)

	CryptoStreams CryptoStreams // TODO: It should be a parent class without closing states
	Streams       Streams

	IncomingPackets     Broadcaster //type: Packet
	OutgoingPackets     Broadcaster //type: Packet
	IncomingPayloads    Broadcaster //type: IncomingPayload
	UnprocessedPayloads Broadcaster //type: UnprocessedPayload
	EncryptionLevels    Broadcaster //type: DirectionalEncryptionLevel
	FrameQueue          Broadcaster //type: QueuedFrame
	TransportParameters Broadcaster //type: QuicTransportParameters

	PreparePacket      Broadcaster //type: EncryptionLevel
	SendPacket         Broadcaster //type: PacketToSend
	StreamInput        Broadcaster //type: StreamInput
	PacketAcknowledged Broadcaster //type: PacketAcknowledged

	ConnectionClosed    chan bool
	ConnectionRestart   chan bool // Triggered when receiving a Retry or a VN packet
	ConnectionRestarted chan bool

	OriginalDestinationCID ConnectionID
	SourceCID              ConnectionID
	DestinationCID         ConnectionID
	Version                uint32
	ALPN                   string

	Token            []byte
	ResumptionTicket []byte

	PacketNumberLock       sync.Locker
	PacketNumber           map[PNSpace]PacketNumber // Stores the next PN to be sent
	LargestPNsReceived     map[PNSpace]PacketNumber // Stores the largest PN received
	LargestPNsAcknowledged map[PNSpace]PacketNumber // Stores the largest PN we have sent that were acknowledged by the peer

	MinRTT      uint64
	SmoothedRTT uint64
	RTTVar      uint64

	AckQueue   map[PNSpace][]PacketNumber // Stores the packet numbers to be acked TODO: This should be a channel actually
	Logger     *log.Logger
	QLog       qlog.QLog
	QLogTrace  *qlog.Trace
	QLogEvents chan *qlog.Event
}

type ConnectionCloseFrame struct {
	ErrorCode          uint64
	ErrorFrameType     uint64
	ReasonPhraseLength uint64
	ReasonPhrase       string
}

type ConnectionID []byte

type CryptoFrame struct {
	Offset     uint64
	Length     uint64
	CryptoData []byte
}

type CryptoState struct {
	Read        *pigotls.AEAD
	Write       *pigotls.AEAD
	HeaderRead  *pigotls.Cipher
	HeaderWrite *pigotls.Cipher
}

type CryptoStreams map[PNSpace]*Stream

type DataBlockedFrame struct {
	DataLimit uint64
}

type Direction string

type DirectionalEncryptionLevel struct {
	EncryptionLevel EncryptionLevel
	Read            bool
	Available       bool
}

type ECNStatus int

type EncryptedExtensionsTransportParameters struct {
	TransportParameterList `tls:"head=2"`
}

type EncryptionLevel int

type Frame interface {
	FrameType() FrameType
	WriteTo(buffer *bytes.Buffer)

	FrameLength() uint16
	// contains filtered or unexported methods
}

type FramePacket struct {
	Frames []Frame
	// contains filtered or unexported fields
}

type FrameType uint64

type Framer interface {
	Packet
	GetFrames() []Frame
	AddFrame(frame Frame)
	GetRetransmittableFrames() []Frame
	Contains(frameType FrameType) bool
	OnlyContains(frameType FrameType) bool
	GetFirst(frameType FrameType) Frame
	GetAll(frameType FrameType) []Frame
	PadTo(length int)
}

type HandshakeDoneFrame byte

type HandshakePacket struct {
	FramePacket
}

type Header interface {
	PacketType() PacketType
	DestinationConnectionID() ConnectionID
	PacketNumber() PacketNumber
	TruncatedPN() TruncatedPN
	EncryptionLevel() EncryptionLevel
	Encode() []byte
	HeaderLength() int
}

type IncomingPayload struct {
	PacketContext
	Payload []byte
}

type InitialPacket struct {
	FramePacket
}

type KeyPhaseBit bool

type LongHeader struct {
	Version        uint32
	DestinationCID ConnectionID
	SourceCID      ConnectionID
	TokenLength    VarInt
	Token          []byte
	Length         VarInt
	// contains filtered or unexported fields
}

type MaxDataFrame struct {
	MaximumData uint64
}

type MaxStreamDataFrame struct {
	StreamId          uint64
	MaximumStreamData uint64
}

type MaxStreamsFrame struct {
	StreamsType    StreamsType
	MaximumStreams uint64
}

type NewConnectionIdFrame struct {
	Sequence            uint64
	RetirePriorTo       uint64
	Length              uint8
	ConnectionId        []byte
	StatelessResetToken [16]byte
}

type NewTokenFrame struct {
	Token []byte
}

type PNSpace int

type Packet interface {
	Header() Header
	ShouldBeAcknowledged() bool // Indicates whether or not the packet type should be acknowledged by the mean of sending an ack
	EncodeHeader() []byte
	EncodePayload() []byte
	Encode([]byte) []byte
	Pointer() unsafe.Pointer
	PNSpace() PNSpace
	EncryptionLevel() EncryptionLevel
	ShortString() string
	ReceiveContext() PacketContext
	SetReceiveContext(ctx PacketContext)
	SendContext() PacketContext
	SetSendContext(ctx PacketContext)
}

type PacketAcknowledged struct {
	PacketNumber
	PNSpace
}

type PacketContext struct {
	Timestamp  time.Time
	RemoteAddr net.Addr
	ECNStatus
	DatagramSize uint16
	PacketSize   uint16
	WasBuffered  bool
}

type PacketNumber uint64

type PacketNumberQueue []PacketNumber

type PacketToSend struct {
	Packet
	EncryptionLevel
}

type PacketType uint8

type PaddingFrame byte

type PathChallenge struct {
	Data [8]byte
}

type PathResponse struct {
	Data [8]byte
}

type PingFrame byte

type ProtectedPacket struct {
	FramePacket
}

type QueuedFrame struct {
	Frame
	EncryptionLevel
}

type QuicTransportParameters struct {
	OriginalDestinationConnectionId ConnectionID
	IdleTimeout                     uint64
	StatelessResetToken             []byte
	MaxPacketSize                   uint64
	MaxData                         uint64
	MaxStreamDataBidiLocal          uint64
	MaxStreamDataBidiRemote         uint64
	MaxStreamDataUni                uint64
	MaxBidiStreams                  uint64
	MaxUniStreams                   uint64
	AckDelayExponent                uint64
	MaxAckDelay                     uint64
	DisableMigration                bool
	PreferredAddress                []byte
	ActiveConnectionIdLimit         uint64
	InitialSourceConnectionId       ConnectionID
	RetrySourceConnectionId         ConnectionID
	AdditionalParameters            TransportParameterList
	ToJSON                          map[string]interface{}
}

type ResetStream struct {
	StreamId             uint64
	ApplicationErrorCode uint64
	FinalSize            uint64
}

type RetireConnectionId struct {
	SequenceNumber uint64
}

type RetryPacket struct {
	RetryToken        []byte
	RetryIntegrityTag [16]byte
	// contains filtered or unexported fields
}

type RetryPseudoPacket struct {
	OriginalDestinationCID ConnectionID
	UnusedByte             byte
	Version                uint32
	DestinationCID         ConnectionID
	SourceCID              ConnectionID
	RetryToken             []byte
}

type Secrets struct {
	Epoch pigotls.Epoch `json:"epoch"`
	Read  []byte        `json:"read"`
	Write []byte        `json:"write"`
}

type ShortHeader struct {
	SpinBit        SpinBit
	KeyPhase       KeyPhaseBit
	DestinationCID ConnectionID
	// contains filtered or unexported fields
}

type SpinBit bool

type StatelessResetPacket struct {
	UnpredictableBits   []byte
	StatelessResetToken [16]byte
	// contains filtered or unexported fields
}

type StopSendingFrame struct {
	StreamId             uint64
	ApplicationErrorCode uint64
}

type Stream struct {
	ReadOffset  uint64
	WriteOffset uint64

	ReadLimit        uint64
	ReadBufferOffset uint64
	WriteLimit       uint64
	WriteReserved    uint64

	ReadData  []byte
	WriteData []byte

	ReadChan Broadcaster

	ReadClosed       bool
	ReadCloseOffset  uint64
	WriteClosed      bool
	WriteCloseOffset uint64
	// contains filtered or unexported fields
}

type StreamDataBlockedFrame struct {
	StreamId        uint64
	StreamDataLimit uint64
}

type StreamFrame struct {
	FinBit bool
	LenBit bool
	OffBit bool

	StreamId   uint64
	Offset     uint64
	Length     uint64
	StreamData []byte
}

type StreamInput struct {
	StreamId     uint64
	Data         []byte
	Close        bool
	Reset        bool
	StopSending  bool
	AppErrorCode uint64
}

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

type StreamsBlockedFrame struct {
	StreamsType StreamsType
	StreamLimit uint64
}

type StreamsType bool

type SupportedVersion uint32

type TLSTransportParameterHandler struct {
	QuicTransportParameters
	*EncryptedExtensionsTransportParameters
	ReceivedParameters *QuicTransportParameters
}

type Trace struct {
	Commit          string                    `json:"commit"`   // The git commit that versions the code that produced the trace
	Scenario        string                    `json:"scenario"` // The id of the scenario that produced the trace
	ScenarioVersion int                       `json:"scenario_version"`
	Host            string                    `json:"host"`       // The host against which the scenario was run
	Ip              string                    `json:"ip"`         // The IP that was resolved for the given host
	Results         map[string]interface{}    `json:"results"`    // A dictionary that allows to report scenario-specific results
	StartedAt       int64                     `json:"started_at"` // The time at which the scenario started in epoch seconds
	Duration        uint64                    `json:"duration"`   // Its duration in epoch milliseconds
	ErrorCode       uint8                     `json:"error_code"` // A scenario-specific error code that reports its verdict
	Stream          []TracePacket             `json:"stream"`     // A clear-text copy of the packets that were sent and received
	Pcap            []byte                    `json:"pcap"`       // The packet capture file associated with the trace
	QLog            interface{}               `json:"qlog"`       // The QLog trace captured during the test run
	ClientRandom    []byte                    `json:"client_random"`
	Secrets         map[pigotls.Epoch]Secrets `json:"secrets"`
}

type TracePacket struct {
	Direction    Direction      `json:"direction"`
	Timestamp    int64          `json:"timestamp"`
	Data         []byte         `json:"data"`
	IsOfInterest bool           `json:"is_of_interest"`
	Pointer      unsafe.Pointer `json:"-"`
}

type TransportParameter struct {
	ParameterType TransportParametersType
	Value         []byte `tls:"head=2"`
}

type TransportParameterList []TransportParameter

type TransportParametersType uint64

type TruncatedPN struct {
	Value  uint32
	Length int
}

type UnprocessedPayload struct {
	IncomingPayload
	EncryptionLevel
}

type VarInt struct {
	Value  uint64
	Length int
}

type VersionNegotiationPacket struct {
	UnusedField       uint8
	Version           uint32
	DestinationCID    ConnectionID
	SourceCID         ConnectionID
	SupportedVersions []SupportedVersion
	// contains filtered or unexported fields
}

type ZeroRTTProtectedPacket struct {
	FramePacket
}