quic

package module
v0.0.0-...-2c9eac5 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 26, 2018 License: MIT Imports: 15 Imported by: 0

README

gQUIC

QUIC(Quick UDP Internet Connection) implementation in go draft-ietf-quic-transport-15

Notice

This is WIP, not fully functional. This is test implementation of IETF QUIC, not google QUIC. Sorry for confusing naming

RUN example

commands bellow can run server and client transferring application data. the DEBUG=1 can show the packets exchanged between server and client.

>> cd gQUIC/latest/example
>> DEBUG=1 go run main.go
License

The MIT License (MIT) Copyright (c) 2018 ami-GS

Documentation

Overview

or log package?

Index

Constants

View Source 
const InitialPacketMinimumPayloadSize = 1200

Variables

View Source 
var FrameParserMap = map[FrameType]FrameParser{
	PaddingFrameType:            ParsePaddingFrame,
	RstStreamFrameType:          ParseRstStreamFrame,
	ConnectionCloseFrameType:    ParseConnectionCloseFrame,
	ApplicationCloseFrameType:   ParseApplicationCloseFrame,
	MaxDataFrameType:            ParseMaxDataFrame,
	MaxStreamDataFrameType:      ParseMaxStreamDataFrame,
	MaxStreamIDFrameType:        ParseMaxStreamIDFrame,
	PingFrameType:               ParsePingFrame,
	BlockedFrameType:            ParseBlockedFrame,
	StreamBlockedFrameType:      ParseStreamBlockedFrame,
	StreamIDBlockedFrameType:    ParseStreamIDBlockedFrame,
	NewConnectionIDFrameType:    ParseNewConnectionIDFrame,
	StopSendingFrameType:        ParseStopSendingFrame,
	AckFrameTypeA:               ParseAckFrame,
	AckFrameTypeB:               ParseAckFrame,
	RetireConnectionIDFrameType: ParseRetireConnectionFrame,
	PathChallengeFrameType:      ParsePathChallengeFrame,
	PathResponseFrameType:       ParsePathResponseFrame,

	StreamFrameType: ParseStreamFrame,

	CryptoFrameType:   ParseCryptoFrame,
	NewTokenFrameType: ParseNewTokenFrame,
}
View Source 
var LogLevel int
View Source 
var PacketHeaderParserMap = map[PacketHeaderType]PacketHeaderPerser{
	LongHeaderType:  ParseLongHeader,
	ShortHeaderType: ParseShortHeader,
}

Functions

func GetFrameWires 

func GetFrameWires(frames []Frame) (allWire []byte, err error)

Types

type AckBlock 

type AckBlock struct {
	Block qtype.QuicInt
	Gap   qtype.QuicInt
}

type AckFrame 

type AckFrame struct {
	*BaseFrame
	LargestAcked  qtype.QuicInt
	AckDelay      qtype.QuicInt
	AckBlockCount qtype.QuicInt
	AckBlocks     []AckBlock
	ECN           *ECNSection
}

func NewAckFrame 

func NewAckFrame(lAcked, ackDelay qtype.QuicInt, ackBlocks []AckBlock, ecn *ECNSection) *AckFrame

func (AckFrame) String 

func (f AckFrame) String() string

type ApplicationCloseFrame 

type ApplicationCloseFrame struct {
	*BaseFrame
	ErrorCode    qerror.ApplicationError
	ReasonLength qtype.QuicInt
	Reason       string
}

func NewApplicationCloseFrame 

func NewApplicationCloseFrame(errorCode qerror.ApplicationError, reason string) *ApplicationCloseFrame

func (ApplicationCloseFrame) String 

func (f ApplicationCloseFrame) String() string

type BaseFrame 

type BaseFrame struct {
	Type FrameType
	// contains filtered or unexported fields
}

func NewBaseFrame 

func NewBaseFrame(frameType FrameType) *BaseFrame

func (*BaseFrame) GetType 

func (f *BaseFrame) GetType() FrameType

func (*BaseFrame) GetWire 

func (f *BaseFrame) GetWire() []byte

func (*BaseFrame) GetWireSize 

func (f *BaseFrame) GetWireSize() int

func (*BaseFrame) IsProbeFrame 

func (f *BaseFrame) IsProbeFrame() bool

func (*BaseFrame) String 

func (f *BaseFrame) String() string

type BasePacket 

type BasePacket struct {
	Header     PacketHeader
	Frames     []Frame
	PaddingNum int
	// contains filtered or unexported fields
}

func (*BasePacket) GetFrames 

func (bp *BasePacket) GetFrames() []Frame

func (*BasePacket) GetHeader 

func (bp *BasePacket) GetHeader() PacketHeader

func (*BasePacket) GetPacketNumber 

func (bp *BasePacket) GetPacketNumber() qtype.PacketNumber

func (*BasePacket) GetPayloadLen 

func (bp *BasePacket) GetPayloadLen() int

func (*BasePacket) GetWire 

func (bp *BasePacket) GetWire() (wire []byte, err error)

GetWire of BasePacket assembles all wires, from header wire to frame wires

func (*BasePacket) IsProbePacket 

func (bp *BasePacket) IsProbePacket() bool

func (*BasePacket) SetFrames 

func (bp *BasePacket) SetFrames(fs []Frame)

func (*BasePacket) SetHeader 

func (bp *BasePacket) SetHeader(h PacketHeader)

func (*BasePacket) SetWire 

func (bp *BasePacket) SetWire(wire []byte)

func (*BasePacket) String 

func (bp *BasePacket) String() string

type BasePacketHandler 

type BasePacketHandler struct{}

type BasePacketHeader 

type BasePacketHeader struct {
	DestConnID   qtype.ConnectionID
	SrcConnID    qtype.ConnectionID
	PacketNumber qtype.PacketNumber
	// contains filtered or unexported fields
}

func (*BasePacketHeader) GetConnectionIDPair 

func (ph *BasePacketHeader) GetConnectionIDPair() (qtype.ConnectionID, qtype.ConnectionID)

func (*BasePacketHeader) GetWireSize 

func (ph *BasePacketHeader) GetWireSize() int

func (*BasePacketHeader) SetWire 

func (ph *BasePacketHeader) SetWire(wire []byte)

func (*BasePacketHeader) String 

func (ph *BasePacketHeader) String() string

type BaseStream 

type BaseStream struct {
	ID    qtype.StreamID
	State qtype.StreamState
	// contains filtered or unexported fields
}

func (BaseStream) GetID 

func (s BaseStream) GetID() qtype.StreamID

func (BaseStream) GetState 

func (s BaseStream) GetState() qtype.StreamState

func (BaseStream) String 

func (s BaseStream) String() string

func (BaseStream) UpdateConnectionByteReceived 

func (s BaseStream) UpdateConnectionByteReceived()

func (BaseStream) UpdateConnectionByteSent 

func (s BaseStream) UpdateConnectionByteSent()

func (BaseStream) UpdateStreamOffsetReceived 

func (s BaseStream) UpdateStreamOffsetReceived(offset qtype.QuicInt)

func (BaseStream) UpdateStreamOffsetSent 

func (s BaseStream) UpdateStreamOffsetSent(offset qtype.QuicInt)

type BaseStreamLevelFrame 

type BaseStreamLevelFrame struct {
	StreamID qtype.StreamID
}

func (*BaseStreamLevelFrame) GetStreamID 

func (s *BaseStreamLevelFrame) GetStreamID() qtype.StreamID

func (*BaseStreamLevelFrame) String 

func (s *BaseStreamLevelFrame) String() string

type BlockedFrame 

type BlockedFrame struct {
	*BaseFrame
	Offset qtype.QuicInt
}

func NewBlockedFrame 

func NewBlockedFrame(offset qtype.QuicInt) *BlockedFrame

func (BlockedFrame) String 

func (f BlockedFrame) String() string

type Client 

type Client struct {
	*BasePacketHandler
	// contains filtered or unexported fields
}

func DialAddr 

func DialAddr(addr string) (*Client, error)

func (*Client) Close 

func (s *Client) Close()

func (*Client) Connect 

func (c *Client) Connect()

func (*Client) Ping 

func (c *Client) Ping()

func (*Client) ReadUsableToken 

func (c *Client) ReadUsableToken() []byte

func (*Client) Send 

func (s *Client) Send(data []byte) (int, error)

type CoalescingPacket 

type CoalescingPacket []Packet

func NewCoalescingPacket 

func NewCoalescingPacket(packets ...Packet) CoalescingPacket

func (CoalescingPacket) GetFrames 

func (ps CoalescingPacket) GetFrames() []Frame

func (CoalescingPacket) GetHeader 

func (ps CoalescingPacket) GetHeader() PacketHeader

func (CoalescingPacket) GetPacketNumber 

func (ps CoalescingPacket) GetPacketNumber() qtype.PacketNumber

func (CoalescingPacket) GetWire 

func (ps CoalescingPacket) GetWire() ([]byte, error)

func (CoalescingPacket) IsProbePacket 

func (ps CoalescingPacket) IsProbePacket() bool

func (CoalescingPacket) SetFrames 

func (ps CoalescingPacket) SetFrames(fs []Frame)

func (CoalescingPacket) SetHeader 

func (ps CoalescingPacket) SetHeader(ph PacketHeader)

func (CoalescingPacket) SetWire 

func (ps CoalescingPacket) SetWire(wire []byte)

func (CoalescingPacket) String 

func (ps CoalescingPacket) String() string

type Connection 

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

func (*Connection) Close 

func (c *Connection) Close()

func (*Connection) Read 

func (c *Connection) Read(data []byte) (int, net.Addr, error)

func (*Connection) Write 

func (c *Connection) Write(data []byte) error

type ConnectionCloseFrame 

type ConnectionCloseFrame struct {
	*BaseFrame
	ErrorCode      qerror.TransportError
	ErrorFrameType FrameType
	ReasonLength   qtype.QuicInt
	Reason         string
}

func NewConnectionCloseFrame 

func NewConnectionCloseFrame(errFrameType FrameType, errorCode qerror.TransportError, reason string) *ConnectionCloseFrame

func (ConnectionCloseFrame) String 

func (f ConnectionCloseFrame) String() string

type ConnectionFlowController 

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

func NewConnectionFlowController 

func NewConnectionFlowController() *ConnectionFlowController

func (*ConnectionFlowController) ReceivableByOffset 

func (c *ConnectionFlowController) ReceivableByOffset(largestOffset qtype.QuicInt) error

func (*ConnectionFlowController) SendableByOffset 

func (c *ConnectionFlowController) SendableByOffset(largestOffset qtype.QuicInt) FlowControlFlag

func (*ConnectionFlowController) String 

func (f *ConnectionFlowController) String() string

type CryptoFrame 

type CryptoFrame struct {
	*BaseFrame
	Offset     qtype.QuicInt
	Length     qtype.QuicInt
	CryptoData []byte
}

func NewCryptoFrame 

func NewCryptoFrame(offset qtype.QuicInt, data []byte) *CryptoFrame

func (CryptoFrame) String 

func (f CryptoFrame) String() string

type ECNSection 

type ECNSection struct {
	Etc0Count  qtype.QuicInt
	Etc1Count  qtype.QuicInt
	EcnCeCount qtype.QuicInt
}

func NewECNSection 

func NewECNSection(etc0count, etc1count, ecnCeCount qtype.QuicInt) *ECNSection

func ParseECNSection 

func ParseECNSection(data []byte) (*ECNSection, int, error)

func (ECNSection) GetByteLen 

func (f ECNSection) GetByteLen() int

func (ECNSection) PutWire 

func (f ECNSection) PutWire(wire []byte) (len int, err error)

func (ECNSection) String 

func (f ECNSection) String() string

type FlowControlFlag 

type FlowControlFlag byte
const (
	Sendable          FlowControlFlag = 1
	StreamBlocked     FlowControlFlag = 2
	ConnectionBlocked FlowControlFlag = 3
	// will be represent by StreamBlcked * ConnectionBlocked
	BothBlocked FlowControlFlag = 6
)

type Frame 

type Frame interface {
	GetWire() []byte

	String() string
	GetType() FrameType
	GetWireSize() int
	IsProbeFrame() bool
	// contains filtered or unexported methods
}

func ParseAckFrame 

func ParseAckFrame(data []byte) (Frame, int, error)

func ParseApplicationCloseFrame 

func ParseApplicationCloseFrame(data []byte) (Frame, int, error)

func ParseBlockedFrame 

func ParseBlockedFrame(data []byte) (Frame, int, error)

func ParseConnectionCloseFrame 

func ParseConnectionCloseFrame(data []byte) (Frame, int, error)

func ParseCryptoFrame 

func ParseCryptoFrame(data []byte) (Frame, int, error)

func ParseFrame 

func ParseFrame(data []byte) (f Frame, idx int, err error)

func ParseFrames 

func ParseFrames(data []byte) (fs []Frame, idx int, err error)

func ParseMaxDataFrame 

func ParseMaxDataFrame(data []byte) (Frame, int, error)

func ParseMaxStreamDataFrame 

func ParseMaxStreamDataFrame(data []byte) (Frame, int, error)

func ParseMaxStreamIDFrame 

func ParseMaxStreamIDFrame(data []byte) (Frame, int, error)

func ParseNewConnectionIDFrame 

func ParseNewConnectionIDFrame(data []byte) (Frame, int, error)

func ParseNewTokenFrame 

func ParseNewTokenFrame(data []byte) (Frame, int, error)

func ParsePaddingFrame 

func ParsePaddingFrame(data []byte) (Frame, int, error)

func ParsePathChallengeFrame 

func ParsePathChallengeFrame(data []byte) (Frame, int, error)

func ParsePathResponseFrame 

func ParsePathResponseFrame(data []byte) (Frame, int, error)

func ParsePingFrame 

func ParsePingFrame(data []byte) (Frame, int, error)

func ParseRetireConnectionFrame 

func ParseRetireConnectionFrame(data []byte) (Frame, int, error)

func ParseRstStreamFrame 

func ParseRstStreamFrame(data []byte) (Frame, int, error)

func ParseStopSendingFrame 

func ParseStopSendingFrame(data []byte) (Frame, int, error)

func ParseStreamBlockedFrame 

func ParseStreamBlockedFrame(data []byte) (Frame, int, error)

func ParseStreamFrame 

func ParseStreamFrame(data []byte) (Frame, int, error)

func ParseStreamIDBlockedFrame 

func ParseStreamIDBlockedFrame(data []byte) (Frame, int, error)

type FrameParser 

type FrameParser func(data []byte) (Frame, int, error)

type FrameType 

type FrameType qtype.QuicInt
const (
	// Unknown Frame is 0, same as Padding Frame
	PaddingFrameType FrameType = iota
	RstStreamFrameType
	ConnectionCloseFrameType
	ApplicationCloseFrameType
	MaxDataFrameType
	MaxStreamDataFrameType
	MaxStreamIDFrameType
	PingFrameType
	BlockedFrameType
	StreamBlockedFrameType
	StreamIDBlockedFrameType
	NewConnectionIDFrameType
	StopSendingFrameType
	RetireConnectionIDFrameType
	PathChallengeFrameType
	PathResponseFrameType
	StreamFrameType           // 0x10-0x17
	CryptoFrameType FrameType = iota + 7
	NewTokenFrameType
	AckFrameTypeA
	AckFrameTypeB
	AckFrameTypeMask = 0x1b

	StreamFrameTypeMax  = 0x17
	StreamFrameTypeMask = 0x1f

	FrameSentinel = 0x1c
)

func (FrameType) String 

func (frameType FrameType) String() string

type HandshakePacket 

type HandshakePacket struct {
	*BasePacket
}

long header with type of 0x7D

func NewHandshakePacket 

func NewHandshakePacket(version qtype.Version, destConnID, srcConnID qtype.ConnectionID, packetNumber qtype.PacketNumber, frames ...Frame) *HandshakePacket

type InitialPacket 

type InitialPacket struct {
	*BasePacket
	// Additional Header fields
	TokenLen qtype.QuicInt
	Token    []byte
}

long header with type of 0x7F

func NewInitialPacket 

func NewInitialPacket(version qtype.Version, destConnID, srcConnID qtype.ConnectionID, token []byte, packetNumber qtype.PacketNumber, frames ...Frame) *InitialPacket

TODO: may contain AckFrame

func ParseInitialPacket 

func ParseInitialPacket(lh *LongHeader, data []byte) (*InitialPacket, int, error)

func (*InitialPacket) GetWire 

func (ip *InitialPacket) GetWire() (wire []byte, err error)

TODO: can be optimized

type LongHeader 

type LongHeader struct {
	*BasePacketHeader
	PacketType LongHeaderPacketType
	Version    qtype.Version
	DCIL       byte
	SCIL       byte
	Length     qtype.QuicInt
}

Long Header 

 0                   1                   2                   3
 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+
|1|   Type (7)  |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|                         Version (32)                          |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|DCIL(4)|SCIL(4)|
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|               Destination Connection ID (0/32..144)         ...
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|                 Source Connection ID (0/32..144)            ...
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|                           Length (i)                        ...
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|                       Packet Number (8/16/32)                 |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|                          Payload (*)                        ...
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

func NewLongHeader 

func NewLongHeader(packetType LongHeaderPacketType, version qtype.Version, destConnID, srcConnID qtype.ConnectionID, packetNumber qtype.PacketNumber, length qtype.QuicInt) *LongHeader

func (LongHeader) GetWire 

func (lh LongHeader) GetWire() ([]byte, error)

func (LongHeader) String 

func (lh LongHeader) String() string

type LongHeaderPacketType 

type LongHeaderPacketType byte
const (
	ZeroRTTProtectedPacketType LongHeaderPacketType = iota + 0x7c
	HandshakePacketType
	RetryPacketType
	InitialPacketType
)

func (LongHeaderPacketType) String 

func (lht LongHeaderPacketType) String() string

type MaxDataFrame 

type MaxDataFrame struct {
	*BaseFrame
	Data qtype.QuicInt
}

func NewMaxDataFrame 

func NewMaxDataFrame(maxData qtype.QuicInt) *MaxDataFrame

func (MaxDataFrame) String 

func (f MaxDataFrame) String() string

type MaxStreamDataFrame 

type MaxStreamDataFrame struct {
	*BaseFrame
	*BaseStreamLevelFrame
	Data qtype.QuicInt
}

func NewMaxStreamDataFrame 

func NewMaxStreamDataFrame(streamID qtype.StreamID, maxData qtype.QuicInt) *MaxStreamDataFrame

func (MaxStreamDataFrame) String 

func (f MaxStreamDataFrame) String() string

type MaxStreamIDFrame 

type MaxStreamIDFrame struct {
	*BaseFrame
	*BaseStreamLevelFrame
}

func NewMaxStreamIDFrame 

func NewMaxStreamIDFrame(streamID qtype.StreamID) *MaxStreamIDFrame

func (MaxStreamIDFrame) String 

func (f MaxStreamIDFrame) String() string

type NewConnectionIDFrame 

type NewConnectionIDFrame struct {
	*BaseFrame
	Length          byte
	Sequence        qtype.QuicInt
	ConnID          qtype.ConnectionID
	StatelessRstTkn [16]byte
}

func NewNewConnectionIDFrame 

func NewNewConnectionIDFrame(sequence qtype.QuicInt, connID qtype.ConnectionID, stateLessRstTkn [16]byte) *NewConnectionIDFrame

func (NewConnectionIDFrame) String 

func (f NewConnectionIDFrame) String() string

type NewTokenFrame 

type NewTokenFrame struct {
	*BaseFrame
	TokenLen qtype.QuicInt
	Token    []byte
}

func NewNewTokenFrame 

func NewNewTokenFrame(token []byte) *NewTokenFrame

func (NewTokenFrame) String 

func (f NewTokenFrame) String() string

type Packet 

type Packet interface {
	// doesn't need genWire
	GetWire() ([]byte, error)
	SetWire(wire []byte)
	GetHeader() PacketHeader
	String() string
	SetHeader(ph PacketHeader)
	GetFrames() []Frame
	GetPacketNumber() qtype.PacketNumber
	SetFrames(fs []Frame)
	IsProbePacket() bool
}

func ParsePackets 

func ParsePackets(data []byte) (packets []Packet, idx int, err error)

func ParseRetryPacket 

func ParseRetryPacket(header *LongHeader, data []byte) (Packet, int, error)

func ParseVersionNegotiationPacket 

func ParseVersionNegotiationPacket(data []byte) (Packet, int, error)

type PacketHandler 

type PacketHandler interface {
	// contains filtered or unexported methods
}

type PacketHeader 

type PacketHeader interface {
	// TODO: can be defined as different interface, like WireObject?
	GetWire() ([]byte, error)
	SetWire(wire []byte)
	GetWireSize() int

	String() string
	GetConnectionIDPair() (qtype.ConnectionID, qtype.ConnectionID) // srcID, destID
	// contains filtered or unexported methods
}

func ParseLongHeader 

func ParseLongHeader(data []byte) (PacketHeader, int, error)

func ParseShortHeader 

func ParseShortHeader(data []byte) (PacketHeader, int, error)

type PacketHeaderPerser 

type PacketHeaderPerser func(data []byte) (p PacketHeader, length int, err error)

before passing data, need to check whether data[1:5] == 0x00 or not data[1:5] == 0x00 means version negotiation packet

type PacketHeaderType 

type PacketHeaderType byte
const (
	LongHeaderType  PacketHeaderType = 0x80
	ShortHeaderType PacketHeaderType = 0x00
)

type PaddingFrame 

type PaddingFrame struct {
	*BaseFrame
}

func NewPaddingFrame 

func NewPaddingFrame() *PaddingFrame

func (PaddingFrame) String 

func (f PaddingFrame) String() string

type PathChallengeFrame 

type PathChallengeFrame struct {
	*BaseFrame
	Data [8]byte
}

func NewPathChallengeFrame 

func NewPathChallengeFrame(data [8]byte) *PathChallengeFrame

func (PathChallengeFrame) String 

func (f PathChallengeFrame) String() string

type PathResponseFrame 

type PathResponseFrame struct {
	*BaseFrame
	Data [8]byte
}

func NewPathResponseFrame 

func NewPathResponseFrame(data [8]byte) *PathResponseFrame

func (PathResponseFrame) String 

func (f PathResponseFrame) String() string

type PingFrame 

type PingFrame struct {
	*BaseFrame
}

func NewPingFrame 

func NewPingFrame() *PingFrame

func (PingFrame) String 

func (f PingFrame) String() string

type PingHelper 

type PingHelper struct {
	Ticker *time.Ticker
	// contains filtered or unexported fields
}

func NewPingHelper 

func NewPingHelper(interval time.Duration) *PingHelper

type ProtectedPacket 

type ProtectedPacket struct {
	*BasePacket
	RTT byte
}

long header with 0-RTT (type:0x7C) short header with 1-RTT

func NewProtectedPacket0RTT 

func NewProtectedPacket0RTT(version qtype.Version, destConnID, srcConnID qtype.ConnectionID, packetNumber qtype.PacketNumber, frames ...Frame) *ProtectedPacket

func NewProtectedPacket1RTT 

func NewProtectedPacket1RTT(key bool, destConnID qtype.ConnectionID, packetNumber qtype.PacketNumber, frames ...Frame) *ProtectedPacket

func (ProtectedPacket) String 

func (p ProtectedPacket) String() string

type RecvStream 

type RecvStream struct {
	*BaseStream
	DataBuffer *utils.RingBuffer
	DataSize   qtype.QuicInt // will be known after receiving all data

	ReceiveAllDetector qtype.QuicInt
}

func (*RecvStream) Close 

func (s *RecvStream) Close()

func (RecvStream) IsTerminated 

func (s RecvStream) IsTerminated() bool

func (*RecvStream) QueueFrame 

func (s *RecvStream) QueueFrame(f StreamLevelFrame) (err error)

QueueFrame is used for validate the frame can be sent, and then queue the frame

func (*RecvStream) ReadData 

func (s *RecvStream) ReadData() ([]byte, bool)

returns data, is_reset

type RetireConnectionIDFrame 

type RetireConnectionIDFrame struct {
	*BaseFrame
	SequenceNumber qtype.QuicInt
}

func NewRetireConnectionIDFrame 

func NewRetireConnectionIDFrame(sequence qtype.QuicInt) *RetireConnectionIDFrame

type RetryPacket 

type RetryPacket struct {
	*BasePacket
	ODCIL              byte
	OriginalDestConnID qtype.ConnectionID
	RetryToken         []byte
}

long header with type of 0x7E

func NewRetryPacket 

func NewRetryPacket(version qtype.Version, destConnID, srcConnID qtype.ConnectionID, originalDestConnID qtype.ConnectionID, retryToken []byte) *RetryPacket

func (*RetryPacket) GetWire 

func (rp *RetryPacket) GetWire() (wire []byte, err error)

TODO: can be optimized

func (RetryPacket) String 

func (p RetryPacket) String() string

type RstStreamFrame 

type RstStreamFrame struct {
	*BaseFrame
	*BaseStreamLevelFrame
	ErrorCode   qerror.ApplicationError
	FinalOffset qtype.QuicInt
}

func NewRstStreamFrame 

func NewRstStreamFrame(streamID qtype.StreamID, errorCode qerror.ApplicationError, offset qtype.QuicInt) *RstStreamFrame

func (RstStreamFrame) String 

func (f RstStreamFrame) String() string

type SendRecvStream 

type SendRecvStream struct {
	*BaseStream
	*SendStream
	*RecvStream
}

func (*SendRecvStream) Close 

func (s *SendRecvStream) Close()

func (*SendRecvStream) IsTerminated 

func (s *SendRecvStream) IsTerminated() bool

func (*SendRecvStream) QueueFrame 

func (s *SendRecvStream) QueueFrame(f StreamLevelFrame) error

type SendStream 

type SendStream struct {
	*BaseStream
	// application data can be buffered at "Ready" state
	SendBuffer []byte
	// contains filtered or unexported fields
}

func (*SendStream) Close 

func (s *SendStream) Close()

func (SendStream) IsTerminated 

func (s SendStream) IsTerminated() bool

func (*SendStream) QueueFrame 

func (s *SendStream) QueueFrame(f StreamLevelFrame) (err error)

QueueFrame is used for validate the frame can be sent, and then queue the frame

type Server 

type Server struct {
	SupportedVersions []qtype.Version
	// TODO: consider here? or in utility? or decide dynamically?
	SessionLimitNum int
	NumHandshake    int
	// contains filtered or unexported fields
}

func ListenAddr 

func ListenAddr(addr string) (*Server, error)

func (*Server) ChangeConnectionID 

func (s *Server) ChangeConnectionID(fromID, toID qtype.ConnectionID)

func (*Server) Close 

func (s *Server) Close(fType FrameType, err qerror.TransportError) error

func (*Server) DeleteSessionFromMap 

func (s *Server) DeleteSessionFromMap(ID qtype.ConnectionID)

func (*Server) IsAcceptableSession 

func (s *Server) IsAcceptableSession(version qtype.Version, srcID, destID qtype.ConnectionID, remoteAddr net.Addr) bool

func (*Server) IsVersionSupported 

func (s *Server) IsVersionSupported(version qtype.Version) bool

func (*Server) SendVersionNegotiationPacket 

func (s *Server) SendVersionNegotiationPacket(srcID, destID qtype.ConnectionID, remoteAddr net.Addr) error

func (*Server) Serve 

func (s *Server) Serve() error

type Session 

type Session struct {
	*BasePacketHandler

	// tls config
	// connection
	DestConnID qtype.ConnectionID
	DesSeqID   qtype.QuicInt
	SrcConnID  qtype.ConnectionID
	SrcSeqID   qtype.QuicInt

	DoneHandShake bool

	// A server MAY encode tokens provided with NEW_TOKEN
	// frames and Retry packets differently, and validate the latter more strictly.
	RetryPacketTokenSent string
	// from Token of Retry Packet, MUST not be discarded
	RetryTokenReceived []byte
	// from NEW_TOKEN
	TokenReceived []byte

	AssembleFrameChan chan struct{}
	WaitFrameTimeout  *time.Ticker

	// three packet number spaces
	LastHandshakePN qtype.PacketNumber
	LastAppPN       qtype.PacketNumber
	LastInitialPN   qtype.PacketNumber

	UnAckedPacket map[qtype.PacketNumber]Packet

	PathChallengeData [][8]byte

	// For RetireConnectionIDFrame
	SmallestSeqIDSent    qtype.QuicInt
	DidSendZeroLenConnID bool
	// Maximum of 8 IDs, experimentally used now, Set is better
	// int is SequenceNumber
	MySeqNumber   qtype.QuicInt
	MyConIDPool   map[qtype.QuicInt]qtype.ConnectionID
	MyConIDUsed   map[qtype.QuicInt]qtype.ConnectionID
	PeerSeqNumber qtype.QuicInt
	PeerConIDPool map[qtype.QuicInt]qtype.ConnectionID
	PeerConIDUsed map[qtype.QuicInt]qtype.ConnectionID
	// connectionID string
	StatelessResetToken map[string][16]byte
	// contains filtered or unexported fields
}

func NewSession 

func NewSession(conn *Connection, dstConnID, srcConnID qtype.ConnectionID, isClient bool) *Session

func (*Session) AssembleAckFrame 

func (s *Session) AssembleAckFrame() *AckFrame

func (*Session) Close 

func (s *Session) Close(f *ConnectionCloseFrame) error

func (*Session) HandleFrames 

func (s *Session) HandleFrames(fs []Frame) error

func (*Session) HandleMigration 

func (s *Session) HandleMigration() error

func (*Session) HandlePacket 

func (s *Session) HandlePacket(p Packet) error

func (*Session) Migration 

func (s *Session) Migration() error

func (*Session) PathValidation 

func (s *Session) PathValidation() error

func (*Session) QueueFrame 

func (s *Session) QueueFrame(frame Frame) error

func (*Session) Read 

func (s *Session) Read() (data []byte, err error)

TODO: want to implement Read(data []byte) (n int, err error)

func (*Session) Run 

func (s *Session) Run()

func (*Session) SendPacket 

func (s *Session) SendPacket(packet Packet) error

func (*Session) SetFinishedStream 

func (s *Session) SetFinishedStream(stream *RecvStream)

func (*Session) UpdateConnectionOffsetSent 

func (s *Session) UpdateConnectionOffsetSent(offset qtype.QuicInt)

func (*Session) Write 

func (s *Session) Write(data []byte) (n int, err error)

Write() starts new Stream to send data

type SessionStore 

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

func (*SessionStore) Delete 

func (s *SessionStore) Delete(connID qtype.ConnectionID, remoteAddr net.Addr)

func (SessionStore) GetSession 

func (s SessionStore) GetSession(connID qtype.ConnectionID, remoteAddr net.Addr) (*Session, bool)

func (*SessionStore) Store 

func (s *SessionStore) Store(connID qtype.ConnectionID, remoteAddr net.Addr, sess *Session)

type ShortHeader 

type ShortHeader struct {
	*BasePacketHeader
	PacketType ShortHeaderPacketType
}

func NewShortHeader 

func NewShortHeader(key bool, destConnID qtype.ConnectionID, packetNumber qtype.PacketNumber) *ShortHeader

func (ShortHeader) GetWire 

func (sh ShortHeader) GetWire() ([]byte, error)

func (ShortHeader) String 

func (sh ShortHeader) String() string

type ShortHeaderFlagType 

type ShortHeaderFlagType byte
const (
	KeyPhaseFlag           ShortHeaderFlagType = 0x40
	GQUICDemultipexingFlag                     = 0x08
)

type ShortHeaderPacketType 

type ShortHeaderPacketType byte
const (
	ShortHeaderReservedBits ShortHeaderPacketType = 0x30
	KeyPhase                ShortHeaderPacketType = 0x40
)

func (ShortHeaderPacketType) String 

func (sht ShortHeaderPacketType) String() string

type StopSendingFrame 

type StopSendingFrame struct {
	*BaseFrame
	*BaseStreamLevelFrame
	ErrorCode qerror.ApplicationError
}

func NewStopSendingFrame 

func NewStopSendingFrame(streamID qtype.StreamID, errCode qerror.ApplicationError) *StopSendingFrame

func (StopSendingFrame) String 

func (f StopSendingFrame) String() string

type Stream 

type Stream interface {
	GetState() qtype.StreamState
	GetID() qtype.StreamID
	Close()
	IsTerminated() bool
	QueueFrame(f StreamLevelFrame) error
	UpdateConnectionByteSent()
	UpdateConnectionByteReceived()
	UpdateStreamOffsetSent(offset qtype.QuicInt)
	UpdateStreamOffsetReceived(offset qtype.QuicInt)
	// contains filtered or unexported methods
}

type StreamBlockedFrame 

type StreamBlockedFrame struct {
	*BaseFrame
	*BaseStreamLevelFrame
	Offset qtype.QuicInt
}

func NewStreamBlockedFrame 

func NewStreamBlockedFrame(streamID qtype.StreamID, offset qtype.QuicInt) *StreamBlockedFrame

func (StreamBlockedFrame) String 

func (f StreamBlockedFrame) String() string

type StreamFlowController 

type StreamFlowController struct {
	IsStreamZero bool
	// contains filtered or unexported fields
}

func NewStreamFlowController 

func NewStreamFlowController(isZero bool, connFC *ConnectionFlowController) *StreamFlowController

func (*StreamFlowController) ReceivableByOffset 

func (s *StreamFlowController) ReceivableByOffset(offset qtype.QuicInt) error

func (*StreamFlowController) SendableByOffset 

func (s *StreamFlowController) SendableByOffset(offset qtype.QuicInt) FlowControlFlag

func (*StreamFlowController) String 

func (f *StreamFlowController) String() string

type StreamFrame 

type StreamFrame struct {
	*BaseFrame
	*BaseStreamLevelFrame
	Offset qtype.QuicInt
	Length qtype.QuicInt
	Finish bool
	Data   []byte
}

func NewStreamFrame 

func NewStreamFrame(streamID qtype.StreamID, offset qtype.QuicInt, offF, lenF, fin bool, data []byte) *StreamFrame

func (StreamFrame) String 

func (f StreamFrame) String() string

type StreamIDBlockedFrame 

type StreamIDBlockedFrame struct {
	*BaseFrame
	*BaseStreamLevelFrame
}

func NewStreamIDBlockedFrame 

func NewStreamIDBlockedFrame(streamID qtype.StreamID) *StreamIDBlockedFrame

func (StreamIDBlockedFrame) String 

func (f StreamIDBlockedFrame) String() string

type StreamLevelFrame 

type StreamLevelFrame interface {
	GetStreamID() qtype.StreamID
}

type StreamManager 

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

func NewStreamManager 

func NewStreamManager(sess *Session) *StreamManager

func (*StreamManager) CloseAllStream 

func (s *StreamManager) CloseAllStream() error

func (*StreamManager) GetOrNewStream 

func (s *StreamManager) GetOrNewStream(streamID qtype.StreamID, send bool) (st Stream, isNew bool, err error)

func (*StreamManager) IsValidID 

func (s *StreamManager) IsValidID(streamID qtype.StreamID) error

func (*StreamManager) QueueFrame 

func (s *StreamManager) QueueFrame(stream Stream, f StreamLevelFrame) error

called from session.QueueFrame(f)

func (*StreamManager) Read 

func (s *StreamManager) Read() ([]byte, error)

func (*StreamManager) StartNewSendStream 

func (s *StreamManager) StartNewSendStream() (Stream, error)

func (*StreamManager) Write 

func (s *StreamManager) Write(data []byte) (n int, err error)

type VersionNegotiationPacket 

type VersionNegotiationPacket struct {
	*BasePacketHeader

	Version           qtype.Version
	DCIL              byte
	SCIL              byte
	SupportedVersions []qtype.Version
	// contains filtered or unexported fields
}

Version negotiation doesn't use long header, but have similar form

func NewVersionNegotiationPacket 

func NewVersionNegotiationPacket(destConnID, srcConnID qtype.ConnectionID, supportedVersions []qtype.Version) *VersionNegotiationPacket

func (VersionNegotiationPacket) GetFrames 

func (p VersionNegotiationPacket) GetFrames() []Frame

func (VersionNegotiationPacket) GetHeader 

func (p VersionNegotiationPacket) GetHeader() PacketHeader

func (VersionNegotiationPacket) GetPacketNumber 

func (p VersionNegotiationPacket) GetPacketNumber() qtype.PacketNumber

func (VersionNegotiationPacket) GetWire 

func (p VersionNegotiationPacket) GetWire() ([]byte, error)

func (VersionNegotiationPacket) IsProbePacket 

func (p VersionNegotiationPacket) IsProbePacket() bool

func (VersionNegotiationPacket) SetFrames 

func (p VersionNegotiationPacket) SetFrames(fs []Frame)

func (VersionNegotiationPacket) SetHeader 

func (p VersionNegotiationPacket) SetHeader(h PacketHeader)

func (VersionNegotiationPacket) SetWire 

func (p VersionNegotiationPacket) SetWire(wire []byte)

func (VersionNegotiationPacket) String 

func (p VersionNegotiationPacket) String() string

Source Files

View all Source files

Directories

Path Synopsis
examplles
utils

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.