func newControlFrame(frameType ControlFrameType) (controlFrame, os.Error) {
ctor, ok := cframeCtor[frameType]
if !ok {
- return nil, InvalidControlFrame
+ return nil, &Error{Err: InvalidControlFrame}
}
return ctor(), nil
}
// TODO(willchan): Add TypeWindowUpdate
}
-type corkedReader struct {
- r io.Reader
- ch chan int
- n int
-}
-
-func (cr *corkedReader) Read(p []byte) (int, os.Error) {
- if cr.n == 0 {
- cr.n = <-cr.ch
- }
- if len(p) > cr.n {
- p = p[:cr.n]
- }
- n, err := cr.r.Read(p)
- cr.n -= n
- return n, err
-}
-
-func (f *Framer) uncorkHeaderDecompressor(payloadSize int) os.Error {
+func (f *Framer) uncorkHeaderDecompressor(payloadSize int64) os.Error {
if f.headerDecompressor != nil {
- f.headerReader.ch <- payloadSize
+ f.headerReader.N = payloadSize
return nil
}
- f.headerReader = corkedReader{r: f.r, ch: make(chan int, 1), n: payloadSize}
+ f.headerReader = io.LimitedReader{R: f.r, N: payloadSize}
decompressor, err := zlib.NewReaderDict(&f.headerReader, []byte(HeaderDictionary))
if err != nil {
return err
return cframe, nil
}
-func parseHeaderValueBlock(r io.Reader) (http.Header, os.Error) {
+func parseHeaderValueBlock(r io.Reader, streamId uint32) (http.Header, os.Error) {
var numHeaders uint16
if err := binary.Read(r, binary.BigEndian, &numHeaders); err != nil {
return nil, err
}
+ var e os.Error
h := make(http.Header, int(numHeaders))
for i := 0; i < int(numHeaders); i++ {
var length uint16
}
name := string(nameBytes)
if name != strings.ToLower(name) {
- return nil, UnlowercasedHeaderName
+ e = &Error{UnlowercasedHeaderName, streamId}
+ name = strings.ToLower(name)
}
if h[name] != nil {
- return nil, DuplicateHeaders
+ e = &Error{DuplicateHeaders, streamId}
}
if err := binary.Read(r, binary.BigEndian, &length); err != nil {
return nil, err
h.Add(name, v)
}
}
+ if e != nil {
+ return h, e
+ }
return h, nil
}
reader := f.r
if !f.headerCompressionDisabled {
- f.uncorkHeaderDecompressor(int(h.length - 10))
+ f.uncorkHeaderDecompressor(int64(h.length - 10))
reader = f.headerDecompressor
}
- frame.Headers, err = parseHeaderValueBlock(reader)
+ frame.Headers, err = parseHeaderValueBlock(reader, frame.StreamId)
+ if !f.headerCompressionDisabled && ((err == os.EOF && f.headerReader.N == 0) || f.headerReader.N != 0) {
+ err = &Error{WrongCompressedPayloadSize, 0}
+ }
if err != nil {
return err
}
+ // Remove this condition when we bump Version to 3.
+ if Version >= 3 {
+ for h, _ := range frame.Headers {
+ if invalidReqHeaders[h] {
+ return &Error{InvalidHeaderPresent, frame.StreamId}
+ }
+ }
+ }
return nil
}
}
reader := f.r
if !f.headerCompressionDisabled {
- f.uncorkHeaderDecompressor(int(h.length - 6))
+ f.uncorkHeaderDecompressor(int64(h.length - 6))
reader = f.headerDecompressor
}
- frame.Headers, err = parseHeaderValueBlock(reader)
+ frame.Headers, err = parseHeaderValueBlock(reader, frame.StreamId)
+ if !f.headerCompressionDisabled && ((err == os.EOF && f.headerReader.N == 0) || f.headerReader.N != 0) {
+ err = &Error{WrongCompressedPayloadSize, 0}
+ }
if err != nil {
return err
}
+ // Remove this condition when we bump Version to 3.
+ if Version >= 3 {
+ for h, _ := range frame.Headers {
+ if invalidRespHeaders[h] {
+ return &Error{InvalidHeaderPresent, frame.StreamId}
+ }
+ }
+ }
return nil
}
}
reader := f.r
if !f.headerCompressionDisabled {
- f.uncorkHeaderDecompressor(int(h.length - 6))
+ f.uncorkHeaderDecompressor(int64(h.length - 6))
reader = f.headerDecompressor
}
- frame.Headers, err = parseHeaderValueBlock(reader)
+ frame.Headers, err = parseHeaderValueBlock(reader, frame.StreamId)
+ if !f.headerCompressionDisabled && ((err == os.EOF && f.headerReader.N == 0) || f.headerReader.N != 0) {
+ err = &Error{WrongCompressedPayloadSize, 0}
+ }
if err != nil {
return err
}
+
+ // Remove this condition when we bump Version to 3.
+ if Version >= 3 {
+ var invalidHeaders map[string]bool
+ if frame.StreamId%2 == 0 {
+ invalidHeaders = invalidReqHeaders
+ } else {
+ invalidHeaders = invalidRespHeaders
+ }
+ for h, _ := range frame.Headers {
+ if invalidHeaders[h] {
+ return &Error{InvalidHeaderPresent, frame.StreamId}
+ }
+ }
+ }
return nil
}
frame.Flags = DataFlags(length >> 24)
length &= 0xffffff
frame.Data = make([]byte, length)
- // TODO(willchan): Support compressed data frames.
if _, err := io.ReadFull(f.r, frame.Data); err != nil {
return nil, err
}
"http"
"io"
"os"
- "strconv"
)
// Data Frame Format
"chunkedtext/htmlimage/pngimage/jpgimage/gifapplication/xmlapplication/xhtmltext/plainpublicmax-age" +
"charset=iso-8859-1utf-8gzipdeflateHTTP/1.1statusversionurl\x00"
-type FramerError int
+// A SPDY specific error.
+type ErrorCode string
const (
- Internal FramerError = iota
- InvalidControlFrame
- UnlowercasedHeaderName
- DuplicateHeaders
- UnknownFrameType
- InvalidDataFrame
+ UnlowercasedHeaderName ErrorCode = "header was not lowercased"
+ DuplicateHeaders ErrorCode = "multiple headers with same name"
+ WrongCompressedPayloadSize ErrorCode = "compressed payload size was incorrect"
+ UnknownFrameType ErrorCode = "unknown frame type"
+ InvalidControlFrame ErrorCode = "invalid control frame"
+ InvalidDataFrame ErrorCode = "invalid data frame"
+ InvalidHeaderPresent ErrorCode = "frame contained invalid header"
)
-func (e FramerError) String() string {
- switch e {
- case Internal:
- return "Internal"
- case InvalidControlFrame:
- return "InvalidControlFrame"
- case UnlowercasedHeaderName:
- return "UnlowercasedHeaderName"
- case DuplicateHeaders:
- return "DuplicateHeaders"
- case UnknownFrameType:
- return "UnknownFrameType"
- case InvalidDataFrame:
- return "InvalidDataFrame"
- }
- return "Error(" + strconv.Itoa(int(e)) + ")"
+// Error contains both the type of error and additional values. StreamId is 0
+// if Error is not associated with a stream.
+type Error struct {
+ Err ErrorCode
+ StreamId uint32
+}
+
+func (e *Error) String() string {
+ return string(e.Err)
+}
+
+var invalidReqHeaders = map[string]bool{
+ "Connection": true,
+ "Keep-Alive": true,
+ "Proxy-Connection": true,
+ "Transfer-Encoding": true,
+}
+
+var invalidRespHeaders = map[string]bool{
+ "Connection": true,
+ "Keep-Alive": true,
+ "Transfer-Encoding": true,
}
// Framer handles serializing/deserializing SPDY frames, including compressing/
headerBuf *bytes.Buffer
headerCompressor *zlib.Writer
r io.Reader
- headerReader corkedReader
+ headerReader io.LimitedReader
headerDecompressor io.ReadCloser
}