quictracker

package module

Go to main page

Versions in this module

v1

v1.0.0

Jan 19, 2024

Changes in this version

+ var JSONTypeHandlers = map[JSONType]func() interface

type AckECNFrame

+ func (frame AckECNFrame) MarshalJSON() ([]byte, error)

type AckFrame

+ func (frame AckFrame) MarshalJSON() ([]byte, error)

type ApplicationCloseFrame

+ func (frame ApplicationCloseFrame) MarshalJSON() ([]byte, error)

type Connection

+ CurrentStreamID uint64

type ConnectionCloseFrame

+ func (frame ConnectionCloseFrame) MarshalJSON() ([]byte, error)

type CryptoFrame

+ func (frame CryptoFrame) MarshalJSON() ([]byte, error)

type DataBlockedFrame

+ func (frame DataBlockedFrame) MarshalJSON() ([]byte, error)

+ type Envelope struct

+ Message interface{}

+ Type JSONType

type Frame

+ MarshalJSON func() ([]byte, error)

type HandshakeDoneFrame

+ func (frame HandshakeDoneFrame) MarshalJSON() ([]byte, error)

type HandshakePacket

+ func (p HandshakePacket) MarshalJSON() ([]byte, error)

type Header

+ MarshalJSON func() ([]byte, error)

+ SetPacketNumber func(number PacketNumber)

type InitialPacket

+ func (p InitialPacket) MarshalJSON() ([]byte, error)

+ type JSONType int

+ const AckECNFrameJSON

+ const AckFrameJSON

+ const ApplicationCloseFrameJSON

+ const ConnectionCloseFrameJSON

+ const CryptoFrameJSON

+ const DataBlockedFrameJSON

+ const HandshakeDoneFrameJSON

+ const HandshakePacketJSON

+ const InitialPacketJSON

+ const LongHeaderJSON

+ const MaxDataFrameJSON

+ const MaxStreamDataFrameJSON

+ const MaxStreamsFrameJSON

+ const NewConnectionIdFrameJSON

+ const NewTokenFrameJSON

+ const PaddingFrameJSON

+ const PathChallengeJSON

+ const PathResponseJSON

+ const PingFrameJSON

+ const ProtectedPacketJSON

+ const ResetStreamJSON

+ const RetireConnectionIdJSON

+ const RetryPacketJSON

+ const ShortHeaderJSON

+ const StatelessResetPacketJSON

+ const StopSendingFrameJSON

+ const StreamDataBlockedFrameJSON

+ const StreamFrameJSON

+ const StreamsBlockedFrameJSON

+ const VersionNegotiationPacketJSON

+ const ZeroRTTProtectedPacketJSON

+ func (r *JSONType) UnmarshalJSON(data []byte) error

+ func (r JSONType) MarshalJSON() ([]byte, error)

type LongHeader

+ func (h *LongHeader) SetPacketNumber(number PacketNumber)

+ func (h LongHeader) MarshalJSON() ([]byte, error)

type MaxDataFrame

+ func (frame MaxDataFrame) MarshalJSON() ([]byte, error)

type MaxStreamDataFrame

+ func (frame MaxStreamDataFrame) MarshalJSON() ([]byte, error)

type MaxStreamsFrame

+ func (frame MaxStreamsFrame) MarshalJSON() ([]byte, error)

type NewConnectionIdFrame

+ func (frame NewConnectionIdFrame) MarshalJSON() ([]byte, error)

type NewTokenFrame

+ func (frame NewTokenFrame) MarshalJSON() ([]byte, error)

type Packet

+ MarshalJSON func() ([]byte, error)

+ type PacketToPrepare struct

type PacketType

+ const StatelessReset

type PaddingFrame

+ func (frame PaddingFrame) MarshalJSON() ([]byte, error)

type PathChallenge

+ func (frame PathChallenge) MarshalJSON() ([]byte, error)

type PathResponse

+ func (frame PathResponse) MarshalJSON() ([]byte, error)

type PingFrame

+ func (frame PingFrame) MarshalJSON() ([]byte, error)

type ProtectedPacket

+ func (p ProtectedPacket) MarshalJSON() ([]byte, error)

type ResetStream

+ func (frame ResetStream) MarshalJSON() ([]byte, error)

type RetireConnectionId

+ func (frame RetireConnectionId) MarshalJSON() ([]byte, error)

type RetryPacket

+ func (p RetryPacket) MarshalJSON() ([]byte, error)

type ShortHeader

+ func (h *ShortHeader) SetPacketNumber(number PacketNumber)

+ func (h ShortHeader) MarshalJSON() ([]byte, error)

type StatelessResetPacket

+ func (p StatelessResetPacket) MarshalJSON() ([]byte, error)

type StopSendingFrame

+ func (frame StopSendingFrame) MarshalJSON() ([]byte, error)

type StreamDataBlockedFrame

+ func (frame StreamDataBlockedFrame) MarshalJSON() ([]byte, error)

type StreamFrame

+ func (frame StreamFrame) MarshalJSON() ([]byte, error)

type StreamsBlockedFrame

+ func (frame StreamsBlockedFrame) MarshalJSON() ([]byte, error)

type VersionNegotiationPacket

+ func (p VersionNegotiationPacket) MarshalJSON() ([]byte, error)

type ZeroRTTProtectedPacket

+ func (p ZeroRTTProtectedPacket) MarshalJSON() ([]byte, error)

v0

v0.0.1

Sep 7, 2020

Changes in this version

+ const AckDelayExponent

+ const AckECNType

+ const AckType

+ const ActiveConnectionIdLimit

+ const ApplicationCloseType

+ const ConnectionCloseType

+ const CryptoType

+ const DataBlockedType

+ const DisableMigration

+ const ECNStatusCE

+ const ECNStatusECT_0

+ const ECNStatusECT_1

+ const ECNStatusNonECT

+ const ERR_PROTOCOL_VIOLATION

+ const ERR_STREAM_LIMIT_ERROR

+ const ERR_STREAM_STATE_ERROR

+ const HandshakeDoneType

+ const IdleTimeout

+ const InitialMaxData

+ const InitialMaxStreamDataBidiLocal

+ const InitialMaxStreamDataBidiRemote

+ const InitialMaxStreamDataUni

+ const InitialMaxStreamsBidi

+ const InitialMaxStreamsUni

+ const InitialSourceConnectionId

+ const MaxAckDelay

+ const MaxDataType

+ const MaxStreamDataType

+ const MaxStreamsType

+ const MaxTheoreticUDPPayloadSize

+ const MaxUDPPacketSize

+ const MaximumVersion

+ const MinimumInitialLength

+ const MinimumInitialLengthv6

+ const MinimumVersion

+ const NewConnectionIdType

+ const NewTokenType

+ const OriginalDestinationConnectionId

+ const PaddingFrameType

+ const PathChallengeType

+ const PathResponseType

+ const PingType

+ const PreferredAddress

+ const ResetStreamType

+ const RetireConnectionIdType

+ const RetrySourceConnectionId

+ const StatelessResetToken

+ const StopSendingType

+ const StreamDataBlockedType

+ const StreamType

+ const StreamsBlockedType

+ var EncryptionLevelToEpoch = map[EncryptionLevel]pigotls.Epoch

+ var EncryptionLevelToPNSpace = map[EncryptionLevel]PNSpace

+ var EncryptionLevelToPacketType = map[EncryptionLevel]PacketType

+ var EpochToEncryptionLevel = map[pigotls.Epoch]EncryptionLevel

+ var EpochToPNSpace = map[pigotls.Epoch]PNSpace

+ var PNSpaceToEncryptionLevel = map[PNSpace]EncryptionLevel

+ var PNSpaceToEpoch = map[PNSpace]pigotls.Epoch

+ var PNSpaceToPacketType = map[PNSpace]PacketType

+ var PNSpaceToString = map[PNSpace]string

+ var PacketTypeToEncryptionLevel = map[PacketType]EncryptionLevel

+ var PacketTypeToPNSpace = map[PacketType]PNSpace

+ var QuicALPNToken = "hq-29"

+ var QuicH3ALPNToken = "h3-29"

+ var QuicVersion uint32 = 0xff00001d

+ func EstablishUDPConnection(addr *net.UDPAddr, localAddress *net.UDPAddr) (*net.UDPConn, error)

+ func GetMaxBidiClient(limit uint64) uint64

+ func GetMaxBidiServer(limit uint64) uint64

+ func GetMaxUniClient(limit uint64) uint64

+ func GetMaxUniServer(limit uint64) uint64

+ func GetPacketSample(header Header, packetBytes []byte) ([]byte, int)

+ func GitCommit() string

+ func IsBidi(streamId uint64) bool

+ func IsBidiClient(streamId uint64) bool

+ func IsBidiServer(streamId uint64) bool

+ func IsClient(streamId uint64) bool

+ func IsServer(streamId uint64) bool

+ func IsUni(streamId uint64) bool

+ func IsUniClient(streamId uint64) bool

+ func IsUniServer(streamId uint64) bool

+ func Max(a, b int) int

+ func Min(a, b int) int

+ func NewbyteIntervalList() *byteIntervalList

+ func StartPcapCapture(conn *Connection, netInterface string) (*exec.Cmd, error)

+ func StopPcapCapture(conn *Connection, cmd *exec.Cmd) ([]byte, error)

+ func Uint16ToBEBytes(uint16 uint16) []byte

+ func Uint24ToBEBytes(uint32 uint32) []byte

+ func Uint32ToBEBytes(uint32 uint32) []byte

+ type AbstractPacket struct

+ Header Header

+ func (p *AbstractPacket) SetReceiveContext(ctx PacketContext)

+ func (p *AbstractPacket) SetSendContext(ctx PacketContext)

+ func (p AbstractPacket) Encode(payload []byte) []byte

+ func (p AbstractPacket) EncodeHeader() []byte

+ func (p AbstractPacket) GetHeader() Header

+ func (p AbstractPacket) ReceiveContext() PacketContext

+ func (p AbstractPacket) SendContext() PacketContext

+ func (p AbstractPacket) ShortString() string

+ type AckECNFrame struct

+ ECT0Count uint64

+ ECT1Count uint64

+ ECTCECount uint64

+ func ReadAckECNFrame(buffer *bytes.Reader, conn *Connection) *AckECNFrame

+ func (frame *AckECNFrame) FrameLength() uint16

+ func (frame *AckECNFrame) FrameType() FrameType

+ func (frame *AckECNFrame) WriteTo(buffer *bytes.Buffer)

+ type AckFrame struct

+ AckDelay uint64

+ AckRangeCount uint64

+ AckRanges []AckRange

+ LargestAcknowledged PacketNumber

+ func ReadAckFrame(buffer *bytes.Reader) *AckFrame

+ func (frame *AckFrame) FrameLength() uint16

+ func (frame *AckFrame) FrameType() FrameType

+ func (frame *AckFrame) GetAckedPackets() []PacketNumber

+ func (frame *AckFrame) WriteTo(buffer *bytes.Buffer)

+ func (frame AckFrame) Equal(otherFrame AckFrame) bool

+ type AckRange struct

+ AckRange uint64

+ Gap uint64

+ type ApplicationCloseFrame struct

+ ErrorCode uint64

+ ReasonPhrase string

+ ReasonPhraseLength uint64

+ func NewApplicationCloseFrame(buffer *bytes.Reader) *ApplicationCloseFrame

+ func (frame *ApplicationCloseFrame) FrameLength() uint16

+ func (frame *ApplicationCloseFrame) FrameType() FrameType

+ func (frame *ApplicationCloseFrame) WriteTo(buffer *bytes.Buffer)

+ type Broadcaster struct

+ func NewBroadcaster(buflen int) Broadcaster

+ func (b *Broadcaster) Close() error

+ func (b *Broadcaster) RegisterNewChan(size int) chan interface{}

+ type Connection struct

+ ALPN string

+ AckQueue map[PNSpace][]PacketNumber

+ ConnectionClosed chan bool

+ ConnectionRestart chan bool

+ ConnectionRestarted chan bool

+ CryptoStateLock sync.Locker

+ CryptoStates map[EncryptionLevel]*CryptoState

+ CryptoStreams CryptoStreams

+ DestinationCID ConnectionID

+ EncryptionLevels Broadcaster

+ FlowControlQueue map[FrameRequest][]QueuedFrame

+ FrameQueue Broadcaster

+ Host *net.UDPAddr

+ IncomingPackets Broadcaster

+ IncomingPayloads Broadcaster

+ InterfaceMTU int

+ KeyPhaseIndex uint

+ LargestPNsAcknowledged map[PNSpace]PacketNumber

+ LargestPNsReceived map[PNSpace]PacketNumber

+ LastSpinNumber PacketNumber

+ Logger *log.Logger

+ MinRTT uint64

+ OriginalDestinationCID ConnectionID

+ OutgoingPackets Broadcaster

+ PacketAcknowledged Broadcaster

+ PacketNumber map[PNSpace]PacketNumber

+ PacketNumberLock sync.Locker

+ PreparePacket Broadcaster

+ QLog qlog.QLog

+ QLogEvents chan *qlog.Event

+ QLogTrace *qlog.Trace

+ RTTVar uint64

+ ReceiveFrameBuffer map[PNSpace]map[FrameType][]Frame

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

+ ResumptionTicket []byte

+ SendPacket Broadcaster

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

+ ServerName string

+ SmoothedRTT uint64

+ SourceCID ConnectionID

+ SpinBit SpinBit

+ StreamInput Broadcaster

+ StreamQueue map[FrameRequest][]QueuedFrame

+ Streams Streams

+ TLSTPHandler *TLSTransportParameterHandler

+ Tls *pigotls.Connection

+ TlsQueue map[EncryptionLevel][]QueuedFrame

+ Token []byte

+ TransportParameters Broadcaster

+ UdpConnection *net.UDPConn

+ UnprocessedPayloads Broadcaster

+ UseIPv6 bool

+ Version uint32

+ func NewConnection(serverName string, version uint32, ALPN string, SCID []byte, DCID []byte, ...) *Connection

+ func NewDefaultConnection(address string, serverName string, resumptionTicket []byte, useIPv6 bool, ...) (*Connection, error)

+ func (c *Connection) Close()

+ func (c *Connection) CloseConnection(quicLayer bool, errCode uint64, reasonPhrase string)

+ func (c *Connection) ConnectedIp() net.Addr

+ func (c *Connection) CryptoState(level EncryptionLevel) *CryptoState

+ func (c *Connection) DoSendPacket(packet Packet, level EncryptionLevel)

+ func (c *Connection) EncodeAndEncrypt(packet Packet, level EncryptionLevel) []byte

+ func (c *Connection) GetAckFrame(space PNSpace) *AckFrame

+ func (c *Connection) GetCryptoFrame(encLevel EncryptionLevel) *CryptoFrame

+ func (c *Connection) GetInitialPacket() *InitialPacket

+ func (c *Connection) PacketWasSent(packet Packet)

+ func (c *Connection) ProcessVersionNegotation(vn *VersionNegotiationPacket) error

+ func (c *Connection) SendHTTP09GETRequest(path string, streamID uint64)

+ func (c *Connection) TransitionTo(version uint32, ALPN string)

+ type ConnectionCloseFrame struct

+ ErrorCode uint64

+ ErrorFrameType uint64

+ ReasonPhrase string

+ ReasonPhraseLength uint64

+ func NewConnectionCloseFrame(buffer *bytes.Reader) *ConnectionCloseFrame

+ func (frame *ConnectionCloseFrame) FrameLength() uint16

+ func (frame *ConnectionCloseFrame) FrameType() FrameType

+ func (frame *ConnectionCloseFrame) WriteTo(buffer *bytes.Buffer)

+ type ConnectionID []byte

+ func (c ConnectionID) CIDL() uint8

+ func (c ConnectionID) String() string

+ func (c ConnectionID) WriteTo(buffer *bytes.Buffer)

+ type CryptoFrame struct

+ CryptoData []byte

+ Length uint64

+ Offset uint64

+ func NewCryptoFrame(cryptoStream *Stream, data []byte) *CryptoFrame

+ func ReadCryptoFrame(buffer *bytes.Reader, conn *Connection) *CryptoFrame

+ func (frame *CryptoFrame) FrameLength() uint16

+ func (frame *CryptoFrame) FrameType() FrameType

+ func (frame *CryptoFrame) WriteTo(buffer *bytes.Buffer)

+ type CryptoState struct

+ HeaderRead *pigotls.Cipher

+ HeaderWrite *pigotls.Cipher

+ Read *pigotls.AEAD

+ Write *pigotls.AEAD

+ func NewInitialPacketProtection(conn *Connection) *CryptoState

+ func NewProtectedCryptoState(tls *pigotls.Connection, readSecret []byte, writeSecret []byte) *CryptoState

+ func (s *CryptoState) InitRead(tls *pigotls.Connection, readSecret []byte)

+ func (s *CryptoState) InitWrite(tls *pigotls.Connection, writeSecret []byte)

+ type CryptoStreams map[PNSpace]*Stream

+ func (s CryptoStreams) Get(space PNSpace) *Stream

+ type DataBlockedFrame struct

+ DataLimit uint64

+ func NewBlockedFrame(buffer *bytes.Reader) *DataBlockedFrame

+ func (frame *DataBlockedFrame) FrameLength() uint16

+ func (frame *DataBlockedFrame) FrameType() FrameType

+ func (frame *DataBlockedFrame) WriteTo(buffer *bytes.Buffer)

+ type Direction string

+ const ToClient

+ const ToServer

+ type DirectionalEncryptionLevel struct

+ Available bool

+ EncryptionLevel EncryptionLevel

+ Read bool

+ type ECNStatus int

+ type EncryptedExtensionsTransportParameters struct

+ type EncryptionLevel int

+ const EncryptionLevel0RTT

+ const EncryptionLevel1RTT

+ const EncryptionLevelBest

+ const EncryptionLevelBestAppData

+ const EncryptionLevelHandshake

+ const EncryptionLevelInitial

+ const EncryptionLevelNone

+ func (eL EncryptionLevel) String() string

+ type Frame interface

+ FrameLength func() uint16

+ FrameType func() FrameType

+ WriteTo func(buffer *bytes.Buffer)

+ func NewFrame(buffer *bytes.Reader, conn *Connection) (Frame, error)

+ func NewFrameFromType(frameType FrameType, buffer *bytes.Reader, conn *Connection) (Frame, error)

+ type FramePacket struct

+ Frames []Frame

+ func (p *FramePacket) AddFrame(frame Frame)

+ func (p *FramePacket) Contains(frameType FrameType) bool

+ func (p *FramePacket) EncodePayload() []byte

+ func (p *FramePacket) GetAll(frameType FrameType) []Frame

+ func (p *FramePacket) GetFirst(frameType FrameType) Frame

+ func (p *FramePacket) GetFrames() []Frame

+ func (p *FramePacket) GetRetransmittableFrames() []Frame

+ func (p *FramePacket) OnlyContains(frameType FrameType) bool

+ func (p *FramePacket) PadTo(length int)

+ func (p *FramePacket) Pointer() unsafe.Pointer

+ func (p *FramePacket) RemoveAtIndex(index int)

+ func (p *FramePacket) ShouldBeAcknowledged() bool

+ type FrameRequest struct

+ type FrameType uint64

+ func FrameTypeFromString(input string) FrameType

+ func (t FrameType) String() string

+ type Framer interface

+ AddFrame func(frame Frame)

+ Contains func(frameType FrameType) bool

+ GetAll func(frameType FrameType) []Frame

+ GetFirst func(frameType FrameType) Frame

+ GetFrames func() []Frame

+ GetRetransmittableFrames func() []Frame

+ OnlyContains func(frameType FrameType) bool

+ PadTo func(length int)

+ RemoveAtIndex func(index int)

+ type HandshakeDoneFrame byte

+ func NewHandshakeDoneFrame(buffer *bytes.Reader) *HandshakeDoneFrame

+ func (frame *HandshakeDoneFrame) FrameLength() uint16

+ func (frame *HandshakeDoneFrame) FrameType() FrameType

+ func (frame *HandshakeDoneFrame) WriteTo(buffer *bytes.Buffer)

+ type HandshakePacket struct

+ func NewHandshakePacket(conn *Connection) *HandshakePacket

+ func ReadHandshakePacket(buffer *bytes.Reader, conn *Connection) *HandshakePacket

+ func (p *HandshakePacket) EncryptionLevel() EncryptionLevel

+ func (p *HandshakePacket) PNSpace() PNSpace

+ type Header interface

+ DestinationConnectionID func() ConnectionID

+ Encode func() []byte

+ EncryptionLevel func() EncryptionLevel

+ GetPacketNumber func() PacketNumber

+ GetPacketType func() PacketType

+ GetTruncatedPN func() TruncatedPN

+ HeaderLength func() int

+ func ReadHeader(buffer *bytes.Reader, conn *Connection) Header

+ type IncomingPayload struct

+ Payload []byte

+ type InitialPacket struct

+ func NewInitialPacket(conn *Connection) *InitialPacket

+ func ReadInitialPacket(buffer *bytes.Reader, conn *Connection) *InitialPacket

+ func (p *InitialPacket) EncryptionLevel() EncryptionLevel

+ func (p *InitialPacket) GetRetransmittableFrames() []Frame

+ func (p *InitialPacket) PNSpace() PNSpace

+ type KeyPhaseBit bool

+ const KeyPhaseOne

+ const KeyPhaseZero

+ type LongHeader struct

+ DestinationCID ConnectionID

+ Length VarInt

+ LowerBits byte

+ PacketNumber PacketNumber

+ PacketType PacketType

+ SourceCID ConnectionID

+ Token []byte

+ TokenLength VarInt

+ TruncatedPN TruncatedPN

+ Version uint32

+ func NewLongHeader(packetType PacketType, conn *Connection, space PNSpace) *LongHeader

+ func ReadLongHeader(buffer *bytes.Reader, conn *Connection) *LongHeader

+ func (h *LongHeader) DestinationConnectionID() ConnectionID

+ func (h *LongHeader) Encode() []byte

+ func (h *LongHeader) EncryptionLevel() EncryptionLevel

+ func (h *LongHeader) GetPacketNumber() PacketNumber

+ func (h *LongHeader) GetPacketType() PacketType

+ func (h *LongHeader) GetTruncatedPN() TruncatedPN

+ func (h *LongHeader) HeaderLength() int

+ type MaxDataFrame struct

+ MaximumData uint64

+ func NewMaxDataFrame(buffer *bytes.Reader) *MaxDataFrame

+ func (frame *MaxDataFrame) FrameLength() uint16

+ func (frame *MaxDataFrame) FrameType() FrameType

+ func (frame *MaxDataFrame) WriteTo(buffer *bytes.Buffer)

+ type MaxStreamDataFrame struct

+ MaximumStreamData uint64

+ StreamId uint64

+ func NewMaxStreamDataFrame(buffer *bytes.Reader) *MaxStreamDataFrame

+ func (frame *MaxStreamDataFrame) FrameLength() uint16

+ func (frame *MaxStreamDataFrame) FrameType() FrameType

+ func (frame *MaxStreamDataFrame) WriteTo(buffer *bytes.Buffer)

+ type MaxStreamsFrame struct

+ MaximumStreams uint64

+ StreamsType StreamsType

+ func NewMaxStreamIdFrame(buffer *bytes.Reader) *MaxStreamsFrame

+ func (frame *MaxStreamsFrame) FrameLength() uint16

+ func (frame *MaxStreamsFrame) FrameType() FrameType

+ func (frame *MaxStreamsFrame) IsBidi() bool

+ func (frame *MaxStreamsFrame) IsUni() bool

+ func (frame *MaxStreamsFrame) WriteTo(buffer *bytes.Buffer)

+ type NewConnectionIdFrame struct

+ ConnectionId []byte

+ Length uint8

+ RetirePriorTo uint64

+ Sequence uint64

+ StatelessResetToken [16]byte

+ func NewNewConnectionIdFrame(buffer *bytes.Reader) *NewConnectionIdFrame

+ func (frame *NewConnectionIdFrame) FrameLength() uint16

+ func (frame *NewConnectionIdFrame) FrameType() FrameType

+ func (frame *NewConnectionIdFrame) WriteTo(buffer *bytes.Buffer)

+ type NewTokenFrame struct

+ Token []byte

+ func ReadNewTokenFrame(buffer *bytes.Reader, conn *Connection) *NewTokenFrame

+ func (frame *NewTokenFrame) FrameLength() uint16

+ func (frame *NewTokenFrame) FrameType() FrameType

+ func (frame *NewTokenFrame) WriteTo(buffer *bytes.Buffer)

+ type PNSpace int

+ const PNSpaceAppData

+ const PNSpaceHandshake

+ const PNSpaceInitial

+ const PNSpaceNoSpace

+ func (pns PNSpace) Epoch() pigotls.Epoch

+ func (pns PNSpace) String() string

+ type Packet interface

+ Encode func([]byte) []byte

+ EncodeHeader func() []byte

+ EncodePayload func() []byte

+ EncryptionLevel func() EncryptionLevel

+ GetHeader func() Header

+ PNSpace func() PNSpace

+ Pointer func() unsafe.Pointer

+ ReceiveContext func() PacketContext

+ SendContext func() PacketContext

+ SetReceiveContext func(ctx PacketContext)

+ SetSendContext func(ctx PacketContext)

+ ShortString func() string

+ ShouldBeAcknowledged func() bool

+ type PacketAcknowledged struct

+ type PacketContext struct

+ DatagramSize uint16

+ PacketSize uint16

+ RemoteAddr net.Addr

+ Timestamp time.Time

+ WasBuffered bool

+ type PacketNumber uint64

+ func ReadPacketNumber(buffer *bytes.Reader) PacketNumber

+ func (p PacketNumber) Truncate(largestAcknowledged PacketNumber) TruncatedPN

+ type PacketNumberQueue []PacketNumber

+ func (a PacketNumberQueue) Len() int

+ func (a PacketNumberQueue) Less(i, j int) bool

+ func (a PacketNumberQueue) Swap(i, j int)

+ type PacketToSend struct

+ type PacketType uint8

+ const Handshake

+ const Initial

+ const Retry

+ const ShortHeaderPacket

+ const VersionNegotiation

+ const ZeroRTTProtected

+ func (t PacketType) PNSpace() PNSpace

+ func (t PacketType) String() string

+ type PaddingFrame byte

+ func NewPaddingFrame(buffer *bytes.Reader) *PaddingFrame

+ func (frame *PaddingFrame) FrameLength() uint16

+ func (frame *PaddingFrame) FrameType() FrameType

+ func (frame *PaddingFrame) WriteTo(buffer *bytes.Buffer)

+ type PathChallenge struct

+ Data [8]byte

+ func ReadPathChallenge(buffer *bytes.Reader) *PathChallenge

+ func (frame *PathChallenge) FrameLength() uint16

+ func (frame *PathChallenge) FrameType() FrameType

+ func (frame *PathChallenge) WriteTo(buffer *bytes.Buffer)

+ type PathResponse struct

+ Data [8]byte

+ func NewPathResponse(data [8]byte) *PathResponse

+ func ReadPathResponse(buffer *bytes.Reader) *PathResponse

+ func (frame *PathResponse) FrameLength() uint16

+ func (frame *PathResponse) FrameType() FrameType

+ func (frame *PathResponse) WriteTo(buffer *bytes.Buffer)

+ type PingFrame byte

+ func NewPingFrame(buffer *bytes.Reader) *PingFrame

+ func (frame *PingFrame) FrameLength() uint16

+ func (frame *PingFrame) FrameType() FrameType

+ func (frame *PingFrame) WriteTo(buffer *bytes.Buffer)

+ type ProtectedPacket struct

+ func NewProtectedPacket(conn *Connection) *ProtectedPacket

+ func ReadProtectedPacket(buffer *bytes.Reader, conn *Connection) *ProtectedPacket

+ func (p *ProtectedPacket) EncryptionLevel() EncryptionLevel

+ func (p *ProtectedPacket) PNSpace() PNSpace

+ type QueuedFrame struct

+ type QuicTransportParameters struct

+ AckDelayExponent uint64

+ ActiveConnectionIdLimit uint64

+ AdditionalParameters TransportParameterList

+ DisableMigration bool

+ IdleTimeout uint64

+ InitialSourceConnectionId ConnectionID

+ MaxAckDelay uint64

+ MaxBidiStreams uint64

+ MaxData uint64

+ MaxPacketSize uint64

+ MaxStreamDataBidiLocal uint64

+ MaxStreamDataBidiRemote uint64

+ MaxStreamDataUni uint64

+ MaxUniStreams uint64

+ OriginalDestinationConnectionId ConnectionID

+ PreferredAddress []byte

+ RetrySourceConnectionId ConnectionID

+ StatelessResetToken []byte

+ ToJSON map[string]interface{}

+ type ResetStream struct

+ ApplicationErrorCode uint64

+ FinalSize uint64

+ StreamId uint64

+ func NewResetStream(buffer *bytes.Reader) *ResetStream

+ func (frame *ResetStream) FrameLength() uint16

+ func (frame *ResetStream) FrameType() FrameType

+ func (frame *ResetStream) WriteTo(buffer *bytes.Buffer)

+ type RetireConnectionId struct

+ SequenceNumber uint64

+ func ReadRetireConnectionId(buffer *bytes.Reader) *RetireConnectionId

+ func (frame *RetireConnectionId) FrameLength() uint16

+ func (frame *RetireConnectionId) FrameType() FrameType

+ func (frame *RetireConnectionId) WriteTo(buffer *bytes.Buffer)

+ type RetryPacket struct

+ RetryIntegrityTag [16]byte

+ RetryToken []byte

+ func ReadRetryPacket(buffer *bytes.Reader, conn *Connection) *RetryPacket

+ func (p *RetryPacket) EncodePayload() []byte

+ func (p *RetryPacket) EncryptionLevel() EncryptionLevel

+ func (p *RetryPacket) GetRetransmittableFrames() []Frame

+ func (p *RetryPacket) PNSpace() PNSpace

+ func (p *RetryPacket) Pointer() unsafe.Pointer

+ func (p *RetryPacket) ShouldBeAcknowledged() bool

+ type RetryPseudoPacket struct

+ DestinationCID ConnectionID

+ OriginalDestinationCID ConnectionID

+ RetryToken []byte

+ SourceCID ConnectionID

+ UnusedByte byte

+ Version uint32

+ func (r *RetryPseudoPacket) Encode() []byte

+ type Secrets struct

+ Epoch pigotls.Epoch

+ Read []byte

+ Write []byte

+ type ShortHeader struct

+ DestinationCID ConnectionID

+ KeyPhase KeyPhaseBit

+ PacketNumber PacketNumber

+ SpinBit SpinBit

+ TruncatedPN TruncatedPN

+ func NewShortHeader(conn *Connection) *ShortHeader

+ func ReadShortHeader(buffer *bytes.Reader, conn *Connection) *ShortHeader

+ func (h *ShortHeader) DestinationConnectionID() ConnectionID

+ func (h *ShortHeader) Encode() []byte

+ func (h *ShortHeader) EncryptionLevel() EncryptionLevel

+ func (h *ShortHeader) GetPacketNumber() PacketNumber

+ func (h *ShortHeader) GetPacketType() PacketType

+ func (h *ShortHeader) GetTruncatedPN() TruncatedPN

+ func (h *ShortHeader) HeaderLength() int

+ type SpinBit bool

+ const SpinValueOne

+ const SpinValueZero

+ type StatelessResetPacket struct

+ StatelessResetToken [16]byte

+ UnpredictableBits []byte

+ func ReadStatelessResetPacket(buffer *bytes.Reader) *StatelessResetPacket

+ func (*StatelessResetPacket) EncryptionLevel() EncryptionLevel

+ func (*StatelessResetPacket) PNSpace() PNSpace

+ func (*StatelessResetPacket) ShouldBeAcknowledged() bool

+ func (StatelessResetPacket) EncodePayload() []byte

+ func (p *StatelessResetPacket) Pointer() unsafe.Pointer

+ type StopSendingFrame struct

+ ApplicationErrorCode uint64

+ StreamId uint64

+ func NewStopSendingFrame(buffer *bytes.Reader) *StopSendingFrame

+ func (frame *StopSendingFrame) FrameLength() uint16

+ func (frame *StopSendingFrame) FrameType() FrameType

+ func (frame *StopSendingFrame) WriteTo(buffer *bytes.Buffer)

+ type Stream struct

+ ReadBufferOffset uint64

+ ReadChan Broadcaster

+ ReadCloseOffset uint64

+ ReadClosed bool

+ ReadData []byte

+ ReadLimit uint64

+ ReadOffset uint64

+ WriteCloseOffset uint64

+ WriteClosed bool

+ WriteData []byte

+ WriteLimit uint64

+ WriteOffset uint64

+ WriteReserved uint64

+ func NewStream() *Stream

+ type StreamDataBlockedFrame struct

+ StreamDataLimit uint64

+ StreamId uint64

+ func NewStreamBlockedFrame(buffer *bytes.Reader) *StreamDataBlockedFrame

+ func (frame *StreamDataBlockedFrame) FrameLength() uint16

+ func (frame *StreamDataBlockedFrame) FrameType() FrameType

+ func (frame *StreamDataBlockedFrame) WriteTo(buffer *bytes.Buffer)

+ type StreamFrame struct

+ FinBit bool

+ LenBit bool

+ Length uint64

+ OffBit bool

+ Offset uint64

+ StreamData []byte

+ StreamId uint64

+ func NewStreamFrame(streamId, offset uint64, data []byte, finBit bool) *StreamFrame

+ func ReadStreamFrame(buffer *bytes.Reader, conn *Connection) *StreamFrame

+ func (frame *StreamFrame) FrameLength() uint16

+ func (frame *StreamFrame) FrameType() FrameType

+ func (frame *StreamFrame) WriteTo(buffer *bytes.Buffer)

+ type StreamInput struct

+ AppErrorCode uint64

+ Close bool

+ Data []byte

+ Reset bool

+ StopSending bool

+ StreamId uint64

+ type Streams struct

+ func (s Streams) Close(streamId uint64)

+ func (s Streams) Get(streamId uint64) *Stream

+ func (s Streams) GetAll() map[uint64]*Stream

+ func (s Streams) Has(streamId uint64) (*Stream, bool)

+ func (s Streams) NumberOfServerStreamsOpen() int

+ func (s Streams) Reset(streamId uint64, appErrorCode uint64)

+ func (s Streams) Send(streamId uint64, data []byte, close bool)

+ func (s Streams) StopSending(streamId uint64, appErrorCode uint64)

+ type StreamsBlockedFrame struct

+ StreamLimit uint64

+ StreamsType StreamsType

+ func NewStreamIdNeededFrame(buffer *bytes.Reader) *StreamsBlockedFrame

+ func (frame *StreamsBlockedFrame) FrameLength() uint16

+ func (frame *StreamsBlockedFrame) FrameType() FrameType

+ func (frame *StreamsBlockedFrame) IsBidi() bool

+ func (frame *StreamsBlockedFrame) IsUni() bool

+ func (frame *StreamsBlockedFrame) WriteTo(buffer *bytes.Buffer)

+ type StreamsType bool

+ const BidiStreams

+ const UniStreams

+ func (s StreamsType) String() string

+ type SupportedVersion uint32

+ func (v SupportedVersion) String() string

+ type TLSTransportParameterHandler struct

+ ReceivedParameters *QuicTransportParameters

+ func NewTLSTransportParameterHandler(scid ConnectionID) *TLSTransportParameterHandler

+ func (h *TLSTransportParameterHandler) GetExtensionData() ([]byte, error)

+ func (h *TLSTransportParameterHandler) ReceiveExtensionData(data []byte) error

+ type Trace struct

+ ClientRandom []byte

+ Commit string

+ Duration uint64

+ ErrorCode uint8

+ Host string

+ Ip string

+ Pcap []byte

+ QLog interface{}

+ Results map[string]interface{}

+ Scenario string

+ ScenarioVersion int

+ Secrets map[pigotls.Epoch]Secrets

+ StartedAt int64

+ Stream []TracePacket

+ func NewTrace(scenarioName string, scenarioVersion int, host string) *Trace

+ func (t *Trace) AddPcap(conn *Connection, cmd *exec.Cmd) error

+ func (t *Trace) AttachTo(conn *Connection)

+ func (t *Trace) Complete(conn *Connection)

+ func (t *Trace) MarkError(error uint8, message string, packet Packet)

+ type TracePacket struct

+ Data []byte

+ Direction Direction

+ IsOfInterest bool

+ Pointer unsafe.Pointer

+ Timestamp int64

+ type TransportParameter struct

+ ParameterType TransportParametersType

+ Value []byte

+ type TransportParameterList []TransportParameter

+ func (list *TransportParameterList) AddParameter(p TransportParameter)

+ func (list *TransportParameterList) GetParameter(id TransportParametersType) []byte

+ type TransportParametersType uint64

+ type TruncatedPN struct

+ Length int

+ Value uint32

+ func ReadTruncatedPN(buffer *bytes.Reader, length int) TruncatedPN

+ func (t *TruncatedPN) SetLength(length int)

+ func (t TruncatedPN) Encode() []byte

+ func (t TruncatedPN) Join(p PacketNumber) PacketNumber

+ type UnprocessedPayload struct

+ type VarInt struct

+ Length int

+ Value uint64

+ func NewVarInt(value uint64) VarInt

+ func ReadVarInt(buffer io.ByteReader) (VarInt, error)

+ func (v VarInt) Encode() []byte

+ type VersionNegotiationPacket struct

+ DestinationCID ConnectionID

+ SourceCID ConnectionID

+ SupportedVersions []SupportedVersion

+ UnusedField uint8

+ Version uint32

+ func NewVersionNegotiationPacket(unusedField uint8, version uint32, versions []SupportedVersion, ...) *VersionNegotiationPacket

+ func ReadVersionNegotationPacket(buffer *bytes.Reader) *VersionNegotiationPacket

+ func (p *VersionNegotiationPacket) EncodePayload() []byte

+ func (p *VersionNegotiationPacket) EncryptionLevel() EncryptionLevel

+ func (p *VersionNegotiationPacket) PNSpace() PNSpace

+ func (p *VersionNegotiationPacket) Pointer() unsafe.Pointer

+ func (p *VersionNegotiationPacket) ShouldBeAcknowledged() bool

+ type ZeroRTTProtectedPacket struct

+ func NewZeroRTTProtectedPacket(conn *Connection) *ZeroRTTProtectedPacket

+ func (p *ZeroRTTProtectedPacket) EncryptionLevel() EncryptionLevel

+ func (p *ZeroRTTProtectedPacket) PNSpace() PNSpace

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