spdyframing

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
• type ControlFlags
• type ControlFrameHeader
• type ControlFrameType
• type DataFlags
• type DataFrame
• type Error
  • func (e *Error) Error() string
• type ErrorCode
• type Frame
• type Framer
  • func NewFramer(w io.Writer, r io.Reader) *Framer
  • func (f *Framer) ReadFrame() (Frame, error)
  • func (f *Framer) WriteFrame(frame Frame) error
• type GoAwayFrame
• type GoAwayStatus
• type HeadersFrame
• type PingFrame
• type RstStreamFrame
• type RstStreamStatus
• type Session
  • func Start(fr *Framer, server bool, handle func(*Stream)) *Session
  • func (s *Session) Open(h http.Header, flag ControlFlags) (*Stream, error)
  • func (s *Session) Wait() error
• type SettingsFlag
• type SettingsFlagIdValue
• type SettingsFrame
• type SettingsId
• type Stream
  • func (s *Stream) Close() error
  • func (s *Stream) Header() http.Header
  • func (s *Stream) Read(p []byte) (n int, err error)
  • func (s *Stream) Reply(h http.Header, flag ControlFlags) error
  • func (s *Stream) Reset(status RstStreamStatus) error
  • func (s *Stream) Write(p []byte) (n int, err error)
• type StreamId
• type SynReplyFrame
• type SynStreamFrame
• type WindowUpdateFrame

Constants

const (
	TypeSynStream    ControlFrameType = 0x0001
	TypeSynReply                      = 0x0002
	TypeRstStream                     = 0x0003
	TypeSettings                      = 0x0004
	TypePing                          = 0x0006
	TypeGoAway                        = 0x0007
	TypeHeaders                       = 0x0008
	TypeWindowUpdate                  = 0x0009
)

const (
	ControlFlagFin                   ControlFlags = 0x01
	ControlFlagUnidirectional                     = 0x02
	ControlFlagSettingsClearSettings              = 0x01
)

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"
)

const MaxDataLength = 1<<24 - 1

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

const Version = 3

Version is the protocol version number that this package implements.

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.