Documentation

Index

Constants

This section is empty.

Variables

View Source
var ErrInvalidReservedBits = errors.New("invalid reserved bits")

    ErrInvalidReservedBits is returned when the reserved bits are incorrect. When this error is returned, parsing continues, and an ExtendedHeader is returned. This is necessary because we need to decrypt the packet in that case, in order to avoid a timing side-channel.

    View Source
    var ErrUnsupportedVersion = errors.New("unsupported version")

    Functions

    func ComposeVersionNegotiation

    func ComposeVersionNegotiation(destConnID, srcConnID protocol.ConnectionID, versions []protocol.VersionNumber) ([]byte, error)

      ComposeVersionNegotiation composes a Version Negotiation

      func IsVersionNegotiationPacket

      func IsVersionNegotiationPacket(b []byte) bool

        IsVersionNegotiationPacket says if this is a version negotiation packet

        func LogFrame

        func LogFrame(logger utils.Logger, frame Frame, sent bool)

          LogFrame logs a frame, either sent or received

          func ParseConnectionID

          func ParseConnectionID(data []byte, shortHeaderConnIDLen int) (protocol.ConnectionID, error)

            ParseConnectionID parses the destination connection ID of a packet. It uses the data slice for the connection ID. That means that the connection ID must not be used after the packet buffer is released.

            Types

            type AckFrame

            type AckFrame struct {
            	AckRanges []AckRange // has to be ordered. The highest ACK range goes first, the lowest ACK range goes last
            	DelayTime time.Duration
            
            	ECT0, ECT1, ECNCE uint64
            }

              An AckFrame is an ACK frame

              func (*AckFrame) AcksPacket

              func (f *AckFrame) AcksPacket(p protocol.PacketNumber) bool

                AcksPacket determines if this ACK frame acks a certain packet number

                func (*AckFrame) HasMissingRanges

                func (f *AckFrame) HasMissingRanges() bool

                  HasMissingRanges returns if this frame reports any missing packets

                  func (*AckFrame) LargestAcked

                  func (f *AckFrame) LargestAcked() protocol.PacketNumber

                    LargestAcked is the largest acked packet number

                    func (*AckFrame) Length

                    func (f *AckFrame) Length(version protocol.VersionNumber) protocol.ByteCount

                      Length of a written frame

                      func (*AckFrame) LowestAcked

                      func (f *AckFrame) LowestAcked() protocol.PacketNumber

                        LowestAcked is the lowest acked packet number

                        func (*AckFrame) Write

                        func (f *AckFrame) Write(b *bytes.Buffer, _ protocol.VersionNumber) error

                          Write writes an ACK frame.

                          type AckRange

                          type AckRange struct {
                          	Smallest protocol.PacketNumber
                          	Largest  protocol.PacketNumber
                          }

                            AckRange is an ACK range

                            func (AckRange) Len

                            func (r AckRange) Len() protocol.PacketNumber

                              Len returns the number of packets contained in this ACK range

                              type ConnectionCloseFrame

                              type ConnectionCloseFrame struct {
                              	IsApplicationError bool
                              	ErrorCode          qerr.ErrorCode
                              	FrameType          uint64
                              	ReasonPhrase       string
                              }

                                A ConnectionCloseFrame is a CONNECTION_CLOSE frame

                                func (*ConnectionCloseFrame) Length

                                  Length of a written frame

                                  func (*ConnectionCloseFrame) Write

                                  type CryptoFrame

                                  type CryptoFrame struct {
                                  	Offset protocol.ByteCount
                                  	Data   []byte
                                  }

                                    A CryptoFrame is a CRYPTO frame

                                    func (*CryptoFrame) Length

                                      Length of a written frame

                                      func (*CryptoFrame) MaxDataLen

                                      func (f *CryptoFrame) MaxDataLen(maxSize protocol.ByteCount) protocol.ByteCount

                                        MaxDataLen returns the maximum data length

                                        func (*CryptoFrame) MaybeSplitOffFrame

                                        func (f *CryptoFrame) MaybeSplitOffFrame(maxSize protocol.ByteCount, version protocol.VersionNumber) (*CryptoFrame, bool)

                                          MaybeSplitOffFrame splits a frame such that it is not bigger than n bytes. It returns if the frame was actually split. The frame might not be split if: * the size is large enough to fit the whole frame * the size is too small to fit even a 1-byte frame. In that case, the frame returned is nil.

                                          func (*CryptoFrame) Write

                                          type DataBlockedFrame

                                          type DataBlockedFrame struct {
                                          	MaximumData protocol.ByteCount
                                          }

                                            A DataBlockedFrame is a DATA_BLOCKED frame

                                            func (*DataBlockedFrame) Length

                                              Length of a written frame

                                              func (*DataBlockedFrame) Write

                                              func (f *DataBlockedFrame) Write(b *bytes.Buffer, version protocol.VersionNumber) error

                                              type ExtendedHeader

                                              type ExtendedHeader struct {
                                              	Header
                                              
                                              	KeyPhase protocol.KeyPhaseBit
                                              
                                              	PacketNumberLen protocol.PacketNumberLen
                                              	PacketNumber    protocol.PacketNumber
                                              	// contains filtered or unexported fields
                                              }

                                                ExtendedHeader is the header of a QUIC packet.

                                                func (*ExtendedHeader) GetLength

                                                  GetLength determines the length of the Header.

                                                  func (*ExtendedHeader) Log

                                                  func (h *ExtendedHeader) Log(logger utils.Logger)

                                                    Log logs the Header

                                                    func (*ExtendedHeader) ParsedLen

                                                    func (h *ExtendedHeader) ParsedLen() protocol.ByteCount

                                                      ParsedLen returns the number of bytes that were consumed when parsing the header

                                                      func (*ExtendedHeader) Write

                                                        Write writes the Header.

                                                        type Frame

                                                        type Frame interface {
                                                        	Write(b *bytes.Buffer, version protocol.VersionNumber) error
                                                        	Length(version protocol.VersionNumber) protocol.ByteCount
                                                        }

                                                          A Frame in QUIC

                                                          type FrameParser

                                                          type FrameParser interface {
                                                          	ParseNext(*bytes.Reader, protocol.EncryptionLevel) (Frame, error)
                                                          	SetAckDelayExponent(uint8)
                                                          }

                                                            A FrameParser parses QUIC frames, one by one.

                                                            func NewFrameParser

                                                            func NewFrameParser(v protocol.VersionNumber) FrameParser

                                                              NewFrameParser creates a new frame parser.

                                                              type HandshakeDoneFrame

                                                              type HandshakeDoneFrame struct{}

                                                                A HandshakeDoneFrame is a HANDSHAKE_DONE frame

                                                                func (*HandshakeDoneFrame) Length

                                                                  Length of a written frame

                                                                  func (*HandshakeDoneFrame) Write

                                                                  type Header struct {
                                                                  	IsLongHeader bool
                                                                  
                                                                  	Type protocol.PacketType
                                                                  
                                                                  	Version          protocol.VersionNumber
                                                                  	SrcConnectionID  protocol.ConnectionID
                                                                  	DestConnectionID protocol.ConnectionID
                                                                  
                                                                  	Length protocol.ByteCount
                                                                  
                                                                  	Token []byte
                                                                  	// contains filtered or unexported fields
                                                                  }

                                                                    The Header is the version independent part of the header

                                                                    func ParsePacket

                                                                    func ParsePacket(data []byte, shortHeaderConnIDLen int) (*Header, []byte, []byte, error)

                                                                      ParsePacket parses a packet. If the packet has a long header, the packet is cut according to the length field. If we understand the version, the packet is header up unto the packet number. Otherwise, only the invariant part of the header is parsed.

                                                                      func ParseVersionNegotiationPacket

                                                                      func ParseVersionNegotiationPacket(b *bytes.Reader) (*Header, []protocol.VersionNumber, error)

                                                                        ParseVersionNegotiationPacket parses a Version Negotiation packet.

                                                                        func (*Header) PacketType

                                                                        func (h *Header) PacketType() string

                                                                          PacketType is the type of the packet, for logging purposes

                                                                          func (*Header) ParseExtended

                                                                          func (h *Header) ParseExtended(b *bytes.Reader, ver protocol.VersionNumber) (*ExtendedHeader, error)

                                                                            ParseExtended parses the version dependent part of the header. The Reader has to be set such that it points to the first byte of the header.

                                                                            func (*Header) ParsedLen

                                                                            func (h *Header) ParsedLen() protocol.ByteCount

                                                                              ParsedLen returns the number of bytes that were consumed when parsing the header

                                                                              type MaxDataFrame

                                                                              type MaxDataFrame struct {
                                                                              	MaximumData protocol.ByteCount
                                                                              }

                                                                                A MaxDataFrame carries flow control information for the connection

                                                                                func (*MaxDataFrame) Length

                                                                                  Length of a written frame

                                                                                  func (*MaxDataFrame) Write

                                                                                  func (f *MaxDataFrame) Write(b *bytes.Buffer, version protocol.VersionNumber) error

                                                                                    Write writes a MAX_STREAM_DATA frame

                                                                                    type MaxStreamDataFrame

                                                                                    type MaxStreamDataFrame struct {
                                                                                    	StreamID          protocol.StreamID
                                                                                    	MaximumStreamData protocol.ByteCount
                                                                                    }

                                                                                      A MaxStreamDataFrame is a MAX_STREAM_DATA frame

                                                                                      func (*MaxStreamDataFrame) Length

                                                                                        Length of a written frame

                                                                                        func (*MaxStreamDataFrame) Write

                                                                                        type MaxStreamsFrame

                                                                                        type MaxStreamsFrame struct {
                                                                                        	Type         protocol.StreamType
                                                                                        	MaxStreamNum protocol.StreamNum
                                                                                        }

                                                                                          A MaxStreamsFrame is a MAX_STREAMS frame

                                                                                          func (*MaxStreamsFrame) Length

                                                                                            Length of a written frame

                                                                                            func (*MaxStreamsFrame) Write

                                                                                            type NewConnectionIDFrame

                                                                                            type NewConnectionIDFrame struct {
                                                                                            	SequenceNumber      uint64
                                                                                            	RetirePriorTo       uint64
                                                                                            	ConnectionID        protocol.ConnectionID
                                                                                            	StatelessResetToken protocol.StatelessResetToken
                                                                                            }

                                                                                              A NewConnectionIDFrame is a NEW_CONNECTION_ID frame

                                                                                              func (*NewConnectionIDFrame) Length

                                                                                                Length of a written frame

                                                                                                func (*NewConnectionIDFrame) Write

                                                                                                type NewTokenFrame

                                                                                                type NewTokenFrame struct {
                                                                                                	Token []byte
                                                                                                }

                                                                                                  A NewTokenFrame is a NEW_TOKEN frame

                                                                                                  func (*NewTokenFrame) Length

                                                                                                    Length of a written frame

                                                                                                    func (*NewTokenFrame) Write

                                                                                                    type PathChallengeFrame

                                                                                                    type PathChallengeFrame struct {
                                                                                                    	Data [8]byte
                                                                                                    }

                                                                                                      A PathChallengeFrame is a PATH_CHALLENGE frame

                                                                                                      func (*PathChallengeFrame) Length

                                                                                                        Length of a written frame

                                                                                                        func (*PathChallengeFrame) Write

                                                                                                        type PathResponseFrame

                                                                                                        type PathResponseFrame struct {
                                                                                                        	Data [8]byte
                                                                                                        }

                                                                                                          A PathResponseFrame is a PATH_RESPONSE frame

                                                                                                          func (*PathResponseFrame) Length

                                                                                                            Length of a written frame

                                                                                                            func (*PathResponseFrame) Write

                                                                                                            type PingFrame

                                                                                                            type PingFrame struct{}

                                                                                                              A PingFrame is a PING frame

                                                                                                              func (*PingFrame) Length

                                                                                                              func (f *PingFrame) Length(version protocol.VersionNumber) protocol.ByteCount

                                                                                                                Length of a written frame

                                                                                                                func (*PingFrame) Write

                                                                                                                func (f *PingFrame) Write(b *bytes.Buffer, version protocol.VersionNumber) error

                                                                                                                type PreferredAddress

                                                                                                                type PreferredAddress struct {
                                                                                                                	IPv4                net.IP
                                                                                                                	IPv4Port            uint16
                                                                                                                	IPv6                net.IP
                                                                                                                	IPv6Port            uint16
                                                                                                                	ConnectionID        protocol.ConnectionID
                                                                                                                	StatelessResetToken protocol.StatelessResetToken
                                                                                                                }

                                                                                                                  PreferredAddress is the value encoding in the preferred_address transport parameter

                                                                                                                  type ResetStreamFrame

                                                                                                                  type ResetStreamFrame struct {
                                                                                                                  	StreamID  protocol.StreamID
                                                                                                                  	ErrorCode protocol.ApplicationErrorCode
                                                                                                                  	FinalSize protocol.ByteCount
                                                                                                                  }

                                                                                                                    A ResetStreamFrame is a RESET_STREAM frame in QUIC

                                                                                                                    func (*ResetStreamFrame) Length

                                                                                                                      Length of a written frame

                                                                                                                      func (*ResetStreamFrame) Write

                                                                                                                      type RetireConnectionIDFrame

                                                                                                                      type RetireConnectionIDFrame struct {
                                                                                                                      	SequenceNumber uint64
                                                                                                                      }

                                                                                                                        A RetireConnectionIDFrame is a RETIRE_CONNECTION_ID frame

                                                                                                                        func (*RetireConnectionIDFrame) Length

                                                                                                                          Length of a written frame

                                                                                                                          func (*RetireConnectionIDFrame) Write

                                                                                                                          type StopSendingFrame

                                                                                                                          type StopSendingFrame struct {
                                                                                                                          	StreamID  protocol.StreamID
                                                                                                                          	ErrorCode protocol.ApplicationErrorCode
                                                                                                                          }

                                                                                                                            A StopSendingFrame is a STOP_SENDING frame

                                                                                                                            func (*StopSendingFrame) Length

                                                                                                                              Length of a written frame

                                                                                                                              func (*StopSendingFrame) Write

                                                                                                                              type StreamDataBlockedFrame

                                                                                                                              type StreamDataBlockedFrame struct {
                                                                                                                              	StreamID          protocol.StreamID
                                                                                                                              	MaximumStreamData protocol.ByteCount
                                                                                                                              }

                                                                                                                                A StreamDataBlockedFrame is a STREAM_DATA_BLOCKED frame

                                                                                                                                func (*StreamDataBlockedFrame) Length

                                                                                                                                  Length of a written frame

                                                                                                                                  func (*StreamDataBlockedFrame) Write

                                                                                                                                  type StreamFrame

                                                                                                                                  type StreamFrame struct {
                                                                                                                                  	StreamID       protocol.StreamID
                                                                                                                                  	Offset         protocol.ByteCount
                                                                                                                                  	Data           []byte
                                                                                                                                  	Fin            bool
                                                                                                                                  	DataLenPresent bool
                                                                                                                                  	// contains filtered or unexported fields
                                                                                                                                  }

                                                                                                                                    A StreamFrame of QUIC

                                                                                                                                    func GetStreamFrame

                                                                                                                                    func GetStreamFrame() *StreamFrame

                                                                                                                                    func (*StreamFrame) DataLen

                                                                                                                                    func (f *StreamFrame) DataLen() protocol.ByteCount

                                                                                                                                      DataLen gives the length of data in bytes

                                                                                                                                      func (*StreamFrame) Length

                                                                                                                                        Length returns the total length of the STREAM frame

                                                                                                                                        func (*StreamFrame) MaxDataLen

                                                                                                                                        func (f *StreamFrame) MaxDataLen(maxSize protocol.ByteCount, version protocol.VersionNumber) protocol.ByteCount

                                                                                                                                          MaxDataLen returns the maximum data length If 0 is returned, writing will fail (a STREAM frame must contain at least 1 byte of data).

                                                                                                                                          func (*StreamFrame) MaybeSplitOffFrame

                                                                                                                                          func (f *StreamFrame) MaybeSplitOffFrame(maxSize protocol.ByteCount, version protocol.VersionNumber) (*StreamFrame, bool)

                                                                                                                                            MaybeSplitOffFrame splits a frame such that it is not bigger than n bytes. It returns if the frame was actually split. The frame might not be split if: * the size is large enough to fit the whole frame * the size is too small to fit even a 1-byte frame. In that case, the frame returned is nil.

                                                                                                                                            func (*StreamFrame) PutBack

                                                                                                                                            func (f *StreamFrame) PutBack()

                                                                                                                                            func (*StreamFrame) Write

                                                                                                                                            func (f *StreamFrame) Write(b *bytes.Buffer, version protocol.VersionNumber) error

                                                                                                                                              Write writes a STREAM frame

                                                                                                                                              type StreamsBlockedFrame

                                                                                                                                              type StreamsBlockedFrame struct {
                                                                                                                                              	Type        protocol.StreamType
                                                                                                                                              	StreamLimit protocol.StreamNum
                                                                                                                                              }

                                                                                                                                                A StreamsBlockedFrame is a STREAMS_BLOCKED frame

                                                                                                                                                func (*StreamsBlockedFrame) Length

                                                                                                                                                  Length of a written frame

                                                                                                                                                  func (*StreamsBlockedFrame) Write

                                                                                                                                                  type TransportParameters

                                                                                                                                                  type TransportParameters struct {
                                                                                                                                                  	InitialMaxStreamDataBidiLocal  protocol.ByteCount
                                                                                                                                                  	InitialMaxStreamDataBidiRemote protocol.ByteCount
                                                                                                                                                  	InitialMaxStreamDataUni        protocol.ByteCount
                                                                                                                                                  	InitialMaxData                 protocol.ByteCount
                                                                                                                                                  
                                                                                                                                                  	MaxAckDelay      time.Duration
                                                                                                                                                  	AckDelayExponent uint8
                                                                                                                                                  
                                                                                                                                                  	DisableActiveMigration bool
                                                                                                                                                  
                                                                                                                                                  	MaxUDPPayloadSize protocol.ByteCount
                                                                                                                                                  
                                                                                                                                                  	MaxUniStreamNum  protocol.StreamNum
                                                                                                                                                  	MaxBidiStreamNum protocol.StreamNum
                                                                                                                                                  
                                                                                                                                                  	MaxIdleTimeout time.Duration
                                                                                                                                                  
                                                                                                                                                  	PreferredAddress *PreferredAddress
                                                                                                                                                  
                                                                                                                                                  	OriginalDestinationConnectionID protocol.ConnectionID
                                                                                                                                                  	InitialSourceConnectionID       protocol.ConnectionID
                                                                                                                                                  	RetrySourceConnectionID         *protocol.ConnectionID // use a pointer here to distinguish zero-length connection IDs from missing transport parameters
                                                                                                                                                  
                                                                                                                                                  	StatelessResetToken     *protocol.StatelessResetToken
                                                                                                                                                  	ActiveConnectionIDLimit uint64
                                                                                                                                                  }

                                                                                                                                                    TransportParameters are parameters sent to the peer during the handshake

                                                                                                                                                    func (*TransportParameters) Marshal

                                                                                                                                                    func (p *TransportParameters) Marshal(pers protocol.Perspective) []byte

                                                                                                                                                      Marshal the transport parameters

                                                                                                                                                      func (*TransportParameters) MarshalForSessionTicket

                                                                                                                                                      func (p *TransportParameters) MarshalForSessionTicket(b *bytes.Buffer)

                                                                                                                                                        MarshalForSessionTicket marshals the transport parameters we save in the session ticket. When sending a 0-RTT enabled TLS session tickets, we need to save the transport parameters. The client will remember the transport parameters used in the last session, and apply those to the 0-RTT data it sends. Saving the transport parameters in the ticket gives the server the option to reject 0-RTT if the transport parameters changed. Since the session ticket is encrypted, the serialization format is defined by the server. For convenience, we use the same format that we also use for sending the transport parameters.

                                                                                                                                                        func (*TransportParameters) String

                                                                                                                                                        func (p *TransportParameters) String() string

                                                                                                                                                          String returns a string representation, intended for logging.

                                                                                                                                                          func (*TransportParameters) Unmarshal

                                                                                                                                                          func (p *TransportParameters) Unmarshal(data []byte, sentBy protocol.Perspective) error

                                                                                                                                                            Unmarshal the transport parameters

                                                                                                                                                            func (*TransportParameters) UnmarshalFromSessionTicket

                                                                                                                                                            func (p *TransportParameters) UnmarshalFromSessionTicket(r *bytes.Reader) error

                                                                                                                                                              UnmarshalFromSessionTicket unmarshals transport parameters from a session ticket.

                                                                                                                                                              func (*TransportParameters) ValidFor0RTT

                                                                                                                                                              func (p *TransportParameters) ValidFor0RTT(tp *TransportParameters) bool

                                                                                                                                                                ValidFor0RTT checks if the transport parameters match those saved in the session ticket.