spdyframing

package
v0.0.0-...-b6b3b6c Latest Latest
Warning

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

 Go to latest Published: Aug 8, 2013 License: BSD-3-Clause Imports: 10 Imported by: 1

Documentation

Overview

Package spdyframing implements the SPDY protocol (currently SPDY/3), described in http://www.chromium.org/spdy/spdy-protocol/spdy-protocol-draft3.

Index

Constants

View Source 
const (
	TypeSynStream    ControlFrameType = 0x0001
	TypeSynReply                      = 0x0002
	TypeRstStream                     = 0x0003
	TypeSettings                      = 0x0004
	TypePing                          = 0x0006
	TypeGoAway                        = 0x0007
	TypeHeaders                       = 0x0008
	TypeWindowUpdate                  = 0x0009
)
View Source 
const (
	ControlFlagFin                   ControlFlags = 0x01
	ControlFlagUnidirectional                     = 0x02
	ControlFlagSettingsClearSettings              = 0x01
)
View Source 
const (
	UnlowercasedHeaderName     ErrorCode = "header was not lowercased"
	DuplicateHeaders                     = "multiple headers with same name"
	WrongCompressedPayloadSize           = "compressed payload size was incorrect"
	UnknownFrameType                     = "unknown frame type"
	InvalidControlFrame                  = "invalid control frame"
	InvalidDataFrame                     = "invalid data frame"
	InvalidHeaderPresent                 = "frame contained invalid header"
	ZeroStreamId                         = "stream id zero is disallowed"
)
View Source 
const MaxDataLength = 1<<24 - 1

MaxDataLength is the maximum number of bytes that can be stored in one frame.

View Source 
const Version = 3

Version is the protocol version number that this package implements.

Variables

This section is empty.

Functions

This section is empty.

Types

type ControlFlags 

type ControlFlags uint8

ControlFlags are the flags that can be set on a control frame.

type ControlFrameHeader 

type ControlFrameHeader struct {
	Flags ControlFlags
	// contains filtered or unexported fields
}

ControlFrameHeader contains all the fields in a control frame header, in its unpacked in-memory representation.

type ControlFrameType 

type ControlFrameType uint16

ControlFrameType stores the type field in a control frame header.

type DataFlags 

type DataFlags uint8

DataFlags are the flags that can be set on a data frame. 

const (
	DataFlagFin DataFlags = 0x01
)

type DataFrame 

type DataFrame struct {
	// Note, high bit is the "Control" bit. Should be 0 for data frames.
	StreamId StreamId
	Flags    DataFlags
	Data     []byte // payload data of this frame
}

DataFrame is the unpacked, in-memory representation of a DATA frame.

type Error 

type Error struct {
	Err      ErrorCode
	StreamId StreamId
}

Error contains both the type of error and additional values. StreamId is 0 if Error is not associated with a stream.

func (*Error) Error 

func (e *Error) Error() string

type ErrorCode 

type ErrorCode string

A SPDY specific error.

type Frame 

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

Frame is a single SPDY frame in its unpacked in-memory representation. Use Framer to read and write it.

type Framer 

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

Framer handles serializing/deserializing SPDY frames, including compressing/ decompressing payloads.

func NewFramer 

func NewFramer(w io.Writer, r io.Reader) *Framer

NewFramer allocates a new Framer for a given SPDY connection, repesented by a io.Writer and io.Reader. Note that Framer will read and write individual fields from/to the Reader and Writer, so the caller should pass in an appropriately buffered implementation to optimize performance.

func (*Framer) ReadFrame 

func (f *Framer) ReadFrame() (Frame, error)

ReadFrame reads SPDY encoded data and returns a decompressed Frame.

func (*Framer) WriteFrame 

func (f *Framer) WriteFrame(frame Frame) error

WriteFrame writes a frame.

type GoAwayFrame 

type GoAwayFrame struct {
	CFHeader         ControlFrameHeader
	LastGoodStreamId StreamId // last stream id which was accepted by sender
	Status           GoAwayStatus
}

GoAwayFrame is the unpacked, in-memory representation of a GOAWAY frame.

type GoAwayStatus 

type GoAwayStatus uint32

GoAwayStatus represents the status in a GoAwayFrame. 

const (
	GoAwayOK GoAwayStatus = iota
	GoAwayProtocolError
	GoAwayInternalError
)

type HeadersFrame 

type HeadersFrame struct {
	CFHeader ControlFrameHeader
	StreamId StreamId
	Headers  http.Header
}

HeadersFrame is the unpacked, in-memory representation of a HEADERS frame.

type PingFrame 

type PingFrame struct {
	CFHeader ControlFrameHeader
	Id       uint32 // unique id for this ping, from server is even, from client is odd.
}

PingFrame is the unpacked, in-memory representation of a PING frame.

type RstStreamFrame 

type RstStreamFrame struct {
	CFHeader ControlFrameHeader
	StreamId StreamId
	Status   RstStreamStatus
}

RstStreamFrame is the unpacked, in-memory representation of a RST_STREAM frame.

type RstStreamStatus 

type RstStreamStatus uint32

RstStreamStatus represents the status that led to a RST_STREAM. 

const (
	ProtocolError RstStreamStatus = iota + 1
	InvalidStream
	RefusedStream
	UnsupportedVersion
	Cancel
	InternalError
	FlowControlError
	StreamInUse
	StreamAlreadyClosed
	InvalidCredentials
	FrameTooLarge
)

type Session 

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

Session represents a session in the low-level SPDY framing layer.

func Start 

func Start(fr *Framer, server bool, handle func(*Stream)) *Session

Start runs a new session on fr. If server is true, the session will initiate even-numbered streams and expect odd-numbered streams from the remote endpoint; otherwise the reverse. Func handle is called in a separate goroutine for every incoming stream.

func (*Session) Open 

func (s *Session) Open(h http.Header, flag ControlFlags) (*Stream, error)

Open initiates a new SPDY stream with SYN_STREAM. Flags invalid for SYN_STREAM will be silently ignored.

func (*Session) Wait 

func (s *Session) Wait() error

Wait waits until s stops and returns the error, if any.

type SettingsFlag 

type SettingsFlag uint8

SettingsFlag represents a flag in a SETTINGS frame. 

const (
	FlagSettingsPersistValue SettingsFlag = 0x1
	FlagSettingsPersisted                 = 0x2
)

type SettingsFlagIdValue 

type SettingsFlagIdValue struct {
	Flag  SettingsFlag
	Id    SettingsId
	Value uint32
}

SettingsFlagIdValue is the unpacked, in-memory representation of the combined flag/id/value for a setting in a SETTINGS frame.

type SettingsFrame 

type SettingsFrame struct {
	CFHeader     ControlFrameHeader
	FlagIdValues []SettingsFlagIdValue
}

SettingsFrame is the unpacked, in-memory representation of a SPDY SETTINGS frame.

type SettingsId 

type SettingsId uint32

SettingsFlag represents the id of an id/value pair in a SETTINGS frame. 

const (
	SettingsUploadBandwidth SettingsId = iota + 1
	SettingsDownloadBandwidth
	SettingsRoundTripTime
	SettingsMaxConcurrentStreams
	SettingsCurrentCwnd
	SettingsDownloadRetransRate
	SettingsInitialWindowSize
	SettingsClientCretificateVectorSize
)

type Stream 

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

Stream represents a stream in the low-level SPDY framing layer. It is okay to call Read concurrently with the other methods.

func (*Stream) Close 

func (s *Stream) Close() error

Close sends an emtpy DATA or SYN_REPLY frame with FLAG_FIN set. This shuts down the writing side of s. To close both sides, use Reset. It is an error to call Close before calling Reply on a stream initiated by the remote endpoint.

func (*Stream) Header 

func (s *Stream) Header() http.Header

Incoming header, from either SYN_STREAM or SYN_REPLY. Returns nil if there is no incoming direction (either because s is unidirectional, or because of an error).

func (*Stream) Read 

func (s *Stream) Read(p []byte) (n int, err error)

Read reads the contents of DATA frames received on s.

func (*Stream) Reply 

func (s *Stream) Reply(h http.Header, flag ControlFlags) error

Reply sends SYN_REPLY with header fields from h. It is an error to call Reply twice or to call Reply on a stream initiated by the local endpoint.

func (*Stream) Reset 

func (s *Stream) Reset(status RstStreamStatus) error

Reset sends RST_STREAM, closing the stream and indicating an error condition.

func (*Stream) Write 

func (s *Stream) Write(p []byte) (n int, err error)

Write writes p as the contents of one or more DATA frames. It is an error to call Write before calling Reply on a stream initiated by the remote endpoint.

type StreamId 

type StreamId uint32

StreamId represents a 31-bit value identifying the stream.

type SynReplyFrame 

type SynReplyFrame struct {
	CFHeader ControlFrameHeader
	StreamId StreamId
	Headers  http.Header
}

SynReplyFrame is the unpacked, in-memory representation of a SYN_REPLY frame.

type SynStreamFrame 

type SynStreamFrame struct {
	CFHeader             ControlFrameHeader
	StreamId             StreamId
	AssociatedToStreamId StreamId // stream id for a stream which this stream is associated to
	Priority             uint8    // priority of this frame (3-bit)
	Slot                 uint8    // index in the server's credential vector of the client certificate
	Headers              http.Header
}

SynStreamFrame is the unpacked, in-memory representation of a SYN_STREAM frame.

type WindowUpdateFrame 

type WindowUpdateFrame struct {
	CFHeader        ControlFrameHeader
	StreamId        StreamId
	DeltaWindowSize uint32 // additional number of bytes to existing window size
}

WindowUpdateFrame is the unpacked, in-memory representation of a WINDOW_UPDATE frame.

Source Files

View all Source files

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.