masterthesis

type AckBlock struct {
	Gap   uint64
	Block uint64
}

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

type AckFrame struct {
	LargestAcknowledged uint64
	AckDelay            uint64
	AckBlockCount       uint64
	AckBlocks           []AckBlock
}

type Acknowledger interface {
	ShouldBeAcknowledged() bool // Indicates whether or not the packet type should be acknowledged by the mean of sending an ack
}

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

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

type ClientHelloTransportParameters struct {
	InitialVersion uint32
	Parameters     TransportParameterList `tls:"head=2"`
}

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

	Tls          *pigotls.Connection
	TLSTPHandler *TLSTransportParameterHandler

	CryptoStates map[EncryptionLevel]*CryptoState

	ClientRandom   []byte
	ExporterSecret []byte

	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           broadcast.Broadcaster //type: Packet
	OutgoingPackets           broadcast.Broadcaster //type: Packet
	IncomingPayloads          broadcast.Broadcaster //type: []byte
	UnprocessedPayloads       broadcast.Broadcaster //type: UnprocessedPayload
	EncryptionLevelsAvailable broadcast.Broadcaster //type: DirectionalEncryptionLevel
	FrameQueue                broadcast.Broadcaster //type: QueuedFrame

	OriginalDestinationCID ConnectionID
	SourceCID              ConnectionID
	DestinationCID         ConnectionID
	Version                uint32

	PacketNumber map[PNSpace]uint64

	AckQueue map[PNSpace][]uint64 // Stores the packet numbers to be acked TODO: This should be a channel actually
	Logger   *log.Logger
}

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

type ConnectionID []byte

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

type CryptoState struct {
	Read        cipher.AEAD
	Write       cipher.AEAD
	PacketRead  *pigotls.Cipher
	PacketWrite *pigotls.Cipher
}

type CryptoStreams map[PNSpace]*Stream

type Direction string

type DirectionalEncryptionLevel struct {
	EncryptionLevel
	Read bool
}

type EncryptedExtensionsTransportParameters struct {
	NegotiatedVersion uint32
	SupportedVersions []SupportedVersion     `tls:"head=1"`
	Parameters        TransportParameterList `tls:"head=2"`
}

type EncryptionLevel int

type Frame interface {
	FrameType() FrameType

	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
	GetFirst(frameType FrameType) Frame
	GetAll(frameType FrameType) []Frame
}

type HandshakePacket struct {
	FramePacket
}

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

type InitialPacket struct {
	FramePacket
}

type KeyPhaseBit bool

type LongHeader struct {
	Version        uint32
	DestinationCID ConnectionID
	SourceCID      ConnectionID
	PayloadLength  uint64
	Token          []byte

	LengthBeforePN int
	// contains filtered or unexported fields
}

type MaxDataFrame struct {
	MaximumData uint64
}

type MaxStreamDataFrame struct {
	StreamId          uint64
	MaximumStreamData uint64
}

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

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

type NewTokenFrame struct {
	Token []byte
}

type PNSpace int

type Packet interface {
	Header() Header
	Acknowledger
	PacketEncoder
	Pointer() unsafe.Pointer
	PNSpace() PNSpace
	EncryptionLevel() EncryptionLevel
	ShortString() string
}

type PacketEncoder interface {
	EncodeHeader() []byte
	EncodePayload() []byte
	Encode([]byte) []byte
}

type PacketNumberQueue []uint64

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 {
	MaxStreamData        uint32
	MaxData              uint32
	MaxBidiStreams       uint16
	MaxUniStreams        uint16
	IdleTimeout          uint16
	PreferredAddress     string
	MaxPacketSize        uint16
	StatelessResetToken  []byte
	AckDelayExponent     uint8
	DisableMigration     bool
	AdditionalParameters TransportParameterList
	ToJSON               map[string]interface{}
}

type ResetStream struct {
	StreamId    uint64
	ErrorCode   uint16
	FinalOffset uint64
}

type RetryPacket struct {
	OriginalDestinationCID ConnectionID
	RetryToken             []byte
	// contains filtered or unexported fields
}

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

type StopSendingFrame struct {
	StreamId  uint64
	ErrorCode uint16
}

type Stream struct {
	ReadOffset  uint64
	WriteOffset uint64

	ReadData  []byte
	WriteData []byte

	ReadChan        broadcast.Broadcaster
	MaxReadReceived uint64

	ReadClosed      bool
	ReadCloseOffset uint64

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

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

type StreamFrame struct {
	FinBit bool
	LenBit bool
	OffBit bool

	StreamId   uint64
	Offset     uint64
	Length     uint64
	StreamData []byte
}

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

type Streams map[uint64]*Stream

type SupportedVersion uint32

type TLSTransportParameterHandler struct {
	NegotiatedVersion uint32
	InitialVersion    uint32
	QuicTransportParameters
	*EncryptedExtensionsTransportParameters
	ReceivedParameters *QuicTransportParameters
}

type Trace struct {
	Commit              string                 `json:"commit"`
	Scenario            string                 `json:"scenario"`
	ScenarioVersion     int                    `json:"scenario_version"`
	Host                string                 `json:"host"`
	Ip                  string                 `json:"ip"`
	Results             map[string]interface{} `json:"results"`
	StartedAt           int64                  `json:"started_at"`
	Duration            uint64                 `json:"duration"`
	ErrorCode           uint8                  `json:"error_code"`
	Stream              []TracePacket          `json:"stream"`
	Pcap                []byte                 `json:"pcap"`
	DecryptedPcap       []byte                 `json:"decrypted_pcap"`
	ClientRandom        []byte                 `json:"client_random"`
	ExporterSecret      []byte                 `json:"exporter_secret"`
	EarlyExporterSecret []byte                 `json:"early_exporter_secret"`
}

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 uint16

type UnprocessedPayload struct {
	EncryptionLevel
	Payload []byte
}

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

type ZeroRTTProtectedPacket struct {
	FramePacket
}