Skip to content

N
net
Commit 10d81ae2 authored by Yusuke Kagiwada's avatar Yusuke Kagiwada Committed by Mikio Hara
Browse files
Options

go.net/spdy: update SPDY/2 to SPDY/3 

Update to SPDY/3
http://www.chromium.org/spdy/spdy-protocol/spdy-protocol-draft3

R=adg, mikioh.mikioh, minux.ma, bradfitz, remyoudompheng
CC=golang-dev
https://golang.org/cl/7092050
parent cd34c46d
Hide whitespace changes
Inline Side-by-side
Showing with 540 additions and 377 deletions
spdy/dictionary.go 0 → 100644
View file @ 10d81ae2
// Copyright 2013 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package spdy
// headerDictionary is the dictionary sent to the zlib compressor/decompressor.
var headerDictionary = []byte{
0x00, 0x00, 0x00, 0x07, 0x6f, 0x70, 0x74, 0x69,
0x6f, 0x6e, 0x73, 0x00, 0x00, 0x00, 0x04, 0x68,
0x65, 0x61, 0x64, 0x00, 0x00, 0x00, 0x04, 0x70,
0x6f, 0x73, 0x74, 0x00, 0x00, 0x00, 0x03, 0x70,
0x75, 0x74, 0x00, 0x00, 0x00, 0x06, 0x64, 0x65,
0x6c, 0x65, 0x74, 0x65, 0x00, 0x00, 0x00, 0x05,
0x74, 0x72, 0x61, 0x63, 0x65, 0x00, 0x00, 0x00,
0x06, 0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x00,
0x00, 0x00, 0x0e, 0x61, 0x63, 0x63, 0x65, 0x70,
0x74, 0x2d, 0x63, 0x68, 0x61, 0x72, 0x73, 0x65,
0x74, 0x00, 0x00, 0x00, 0x0f, 0x61, 0x63, 0x63,
0x65, 0x70, 0x74, 0x2d, 0x65, 0x6e, 0x63, 0x6f,
0x64, 0x69, 0x6e, 0x67, 0x00, 0x00, 0x00, 0x0f,
0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x2d, 0x6c,
0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, 0x00,
0x00, 0x00, 0x0d, 0x61, 0x63, 0x63, 0x65, 0x70,
0x74, 0x2d, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x73,
0x00, 0x00, 0x00, 0x03, 0x61, 0x67, 0x65, 0x00,
0x00, 0x00, 0x05, 0x61, 0x6c, 0x6c, 0x6f, 0x77,
0x00, 0x00, 0x00, 0x0d, 0x61, 0x75, 0x74, 0x68,
0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f,
0x6e, 0x00, 0x00, 0x00, 0x0d, 0x63, 0x61, 0x63,
0x68, 0x65, 0x2d, 0x63, 0x6f, 0x6e, 0x74, 0x72,
0x6f, 0x6c, 0x00, 0x00, 0x00, 0x0a, 0x63, 0x6f,
0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e,
0x00, 0x00, 0x00, 0x0c, 0x63, 0x6f, 0x6e, 0x74,
0x65, 0x6e, 0x74, 0x2d, 0x62, 0x61, 0x73, 0x65,
0x00, 0x00, 0x00, 0x10, 0x63, 0x6f, 0x6e, 0x74,
0x65, 0x6e, 0x74, 0x2d, 0x65, 0x6e, 0x63, 0x6f,
0x64, 0x69, 0x6e, 0x67, 0x00, 0x00, 0x00, 0x10,
0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x2d,
0x6c, 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65,
0x00, 0x00, 0x00, 0x0e, 0x63, 0x6f, 0x6e, 0x74,
0x65, 0x6e, 0x74, 0x2d, 0x6c, 0x65, 0x6e, 0x67,
0x74, 0x68, 0x00, 0x00, 0x00, 0x10, 0x63, 0x6f,
0x6e, 0x74, 0x65, 0x6e, 0x74, 0x2d, 0x6c, 0x6f,
0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x00, 0x00,
0x00, 0x0b, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e,
0x74, 0x2d, 0x6d, 0x64, 0x35, 0x00, 0x00, 0x00,
0x0d, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74,
0x2d, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x00, 0x00,
0x00, 0x0c, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e,
0x74, 0x2d, 0x74, 0x79, 0x70, 0x65, 0x00, 0x00,
0x00, 0x04, 0x64, 0x61, 0x74, 0x65, 0x00, 0x00,
0x00, 0x04, 0x65, 0x74, 0x61, 0x67, 0x00, 0x00,
0x00, 0x06, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74,
0x00, 0x00, 0x00, 0x07, 0x65, 0x78, 0x70, 0x69,
0x72, 0x65, 0x73, 0x00, 0x00, 0x00, 0x04, 0x66,
0x72, 0x6f, 0x6d, 0x00, 0x00, 0x00, 0x04, 0x68,
0x6f, 0x73, 0x74, 0x00, 0x00, 0x00, 0x08, 0x69,
0x66, 0x2d, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x00,
0x00, 0x00, 0x11, 0x69, 0x66, 0x2d, 0x6d, 0x6f,
0x64, 0x69, 0x66, 0x69, 0x65, 0x64, 0x2d, 0x73,
0x69, 0x6e, 0x63, 0x65, 0x00, 0x00, 0x00, 0x0d,
0x69, 0x66, 0x2d, 0x6e, 0x6f, 0x6e, 0x65, 0x2d,
0x6d, 0x61, 0x74, 0x63, 0x68, 0x00, 0x00, 0x00,
0x08, 0x69, 0x66, 0x2d, 0x72, 0x61, 0x6e, 0x67,
0x65, 0x00, 0x00, 0x00, 0x13, 0x69, 0x66, 0x2d,
0x75, 0x6e, 0x6d, 0x6f, 0x64, 0x69, 0x66, 0x69,
0x65, 0x64, 0x2d, 0x73, 0x69, 0x6e, 0x63, 0x65,
0x00, 0x00, 0x00, 0x0d, 0x6c, 0x61, 0x73, 0x74,
0x2d, 0x6d, 0x6f, 0x64, 0x69, 0x66, 0x69, 0x65,
0x64, 0x00, 0x00, 0x00, 0x08, 0x6c, 0x6f, 0x63,
0x61, 0x74, 0x69, 0x6f, 0x6e, 0x00, 0x00, 0x00,
0x0c, 0x6d, 0x61, 0x78, 0x2d, 0x66, 0x6f, 0x72,
0x77, 0x61, 0x72, 0x64, 0x73, 0x00, 0x00, 0x00,
0x06, 0x70, 0x72, 0x61, 0x67, 0x6d, 0x61, 0x00,
0x00, 0x00, 0x12, 0x70, 0x72, 0x6f, 0x78, 0x79,
0x2d, 0x61, 0x75, 0x74, 0x68, 0x65, 0x6e, 0x74,
0x69, 0x63, 0x61, 0x74, 0x65, 0x00, 0x00, 0x00,
0x13, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x2d, 0x61,
0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61,
0x74, 0x69, 0x6f, 0x6e, 0x00, 0x00, 0x00, 0x05,
0x72, 0x61, 0x6e, 0x67, 0x65, 0x00, 0x00, 0x00,
0x07, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x72,
0x00, 0x00, 0x00, 0x0b, 0x72, 0x65, 0x74, 0x72,
0x79, 0x2d, 0x61, 0x66, 0x74, 0x65, 0x72, 0x00,
0x00, 0x00, 0x06, 0x73, 0x65, 0x72, 0x76, 0x65,
0x72, 0x00, 0x00, 0x00, 0x02, 0x74, 0x65, 0x00,
0x00, 0x00, 0x07, 0x74, 0x72, 0x61, 0x69, 0x6c,
0x65, 0x72, 0x00, 0x00, 0x00, 0x11, 0x74, 0x72,
0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2d, 0x65,
0x6e, 0x63, 0x6f, 0x64, 0x69, 0x6e, 0x67, 0x00,
0x00, 0x00, 0x07, 0x75, 0x70, 0x67, 0x72, 0x61,
0x64, 0x65, 0x00, 0x00, 0x00, 0x0a, 0x75, 0x73,
0x65, 0x72, 0x2d, 0x61, 0x67, 0x65, 0x6e, 0x74,
0x00, 0x00, 0x00, 0x04, 0x76, 0x61, 0x72, 0x79,
0x00, 0x00, 0x00, 0x03, 0x76, 0x69, 0x61, 0x00,
0x00, 0x00, 0x07, 0x77, 0x61, 0x72, 0x6e, 0x69,
0x6e, 0x67, 0x00, 0x00, 0x00, 0x10, 0x77, 0x77,
0x77, 0x2d, 0x61, 0x75, 0x74, 0x68, 0x65, 0x6e,
0x74, 0x69, 0x63, 0x61, 0x74, 0x65, 0x00, 0x00,
0x00, 0x06, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64,
0x00, 0x00, 0x00, 0x03, 0x67, 0x65, 0x74, 0x00,
0x00, 0x00, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75,
0x73, 0x00, 0x00, 0x00, 0x06, 0x32, 0x30, 0x30,
0x20, 0x4f, 0x4b, 0x00, 0x00, 0x00, 0x07, 0x76,
0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x00, 0x00,
0x00, 0x08, 0x48, 0x54, 0x54, 0x50, 0x2f, 0x31,
0x2e, 0x31, 0x00, 0x00, 0x00, 0x03, 0x75, 0x72,
0x6c, 0x00, 0x00, 0x00, 0x06, 0x70, 0x75, 0x62,
0x6c, 0x69, 0x63, 0x00, 0x00, 0x00, 0x0a, 0x73,
0x65, 0x74, 0x2d, 0x63, 0x6f, 0x6f, 0x6b, 0x69,
0x65, 0x00, 0x00, 0x00, 0x0a, 0x6b, 0x65, 0x65,
0x70, 0x2d, 0x61, 0x6c, 0x69, 0x76, 0x65, 0x00,
0x00, 0x00, 0x06, 0x6f, 0x72, 0x69, 0x67, 0x69,
0x6e, 0x31, 0x30, 0x30, 0x31, 0x30, 0x31, 0x32,
0x30, 0x31, 0x32, 0x30, 0x32, 0x32, 0x30, 0x35,
0x32, 0x30, 0x36, 0x33, 0x30, 0x30, 0x33, 0x30,
0x32, 0x33, 0x30, 0x33, 0x33, 0x30, 0x34, 0x33,
0x30, 0x35, 0x33, 0x30, 0x36, 0x33, 0x30, 0x37,
0x34, 0x30, 0x32, 0x34, 0x30, 0x35, 0x34, 0x30,
0x36, 0x34, 0x30, 0x37, 0x34, 0x30, 0x38, 0x34,
0x30, 0x39, 0x34, 0x31, 0x30, 0x34, 0x31, 0x31,
0x34, 0x31, 0x32, 0x34, 0x31, 0x33, 0x34, 0x31,
0x34, 0x34, 0x31, 0x35, 0x34, 0x31, 0x36, 0x34,
0x31, 0x37, 0x35, 0x30, 0x32, 0x35, 0x30, 0x34,
0x35, 0x30, 0x35, 0x32, 0x30, 0x33, 0x20, 0x4e,
0x6f, 0x6e, 0x2d, 0x41, 0x75, 0x74, 0x68, 0x6f,
0x72, 0x69, 0x74, 0x61, 0x74, 0x69, 0x76, 0x65,
0x20, 0x49, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61,
0x74, 0x69, 0x6f, 0x6e, 0x32, 0x30, 0x34, 0x20,
0x4e, 0x6f, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x65,
0x6e, 0x74, 0x33, 0x30, 0x31, 0x20, 0x4d, 0x6f,
0x76, 0x65, 0x64, 0x20, 0x50, 0x65, 0x72, 0x6d,
0x61, 0x6e, 0x65, 0x6e, 0x74, 0x6c, 0x79, 0x34,
0x30, 0x30, 0x20, 0x42, 0x61, 0x64, 0x20, 0x52,
0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x34, 0x30,
0x31, 0x20, 0x55, 0x6e, 0x61, 0x75, 0x74, 0x68,
0x6f, 0x72, 0x69, 0x7a, 0x65, 0x64, 0x34, 0x30,
0x33, 0x20, 0x46, 0x6f, 0x72, 0x62, 0x69, 0x64,
0x64, 0x65, 0x6e, 0x34, 0x30, 0x34, 0x20, 0x4e,
0x6f, 0x74, 0x20, 0x46, 0x6f, 0x75, 0x6e, 0x64,
0x35, 0x30, 0x30, 0x20, 0x49, 0x6e, 0x74, 0x65,
0x72, 0x6e, 0x61, 0x6c, 0x20, 0x53, 0x65, 0x72,
0x76, 0x65, 0x72, 0x20, 0x45, 0x72, 0x72, 0x6f,
0x72, 0x35, 0x30, 0x31, 0x20, 0x4e, 0x6f, 0x74,
0x20, 0x49, 0x6d, 0x70, 0x6c, 0x65, 0x6d, 0x65,
0x6e, 0x74, 0x65, 0x64, 0x35, 0x30, 0x33, 0x20,
0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x20,
0x55, 0x6e, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61,
0x62, 0x6c, 0x65, 0x4a, 0x61, 0x6e, 0x20, 0x46,
0x65, 0x62, 0x20, 0x4d, 0x61, 0x72, 0x20, 0x41,
0x70, 0x72, 0x20, 0x4d, 0x61, 0x79, 0x20, 0x4a,
0x75, 0x6e, 0x20, 0x4a, 0x75, 0x6c, 0x20, 0x41,
0x75, 0x67, 0x20, 0x53, 0x65, 0x70, 0x74, 0x20,
0x4f, 0x63, 0x74, 0x20, 0x4e, 0x6f, 0x76, 0x20,
0x44, 0x65, 0x63, 0x20, 0x30, 0x30, 0x3a, 0x30,
0x30, 0x3a, 0x30, 0x30, 0x20, 0x4d, 0x6f, 0x6e,
0x2c, 0x20, 0x54, 0x75, 0x65, 0x2c, 0x20, 0x57,
0x65, 0x64, 0x2c, 0x20, 0x54, 0x68, 0x75, 0x2c,
0x20, 0x46, 0x72, 0x69, 0x2c, 0x20, 0x53, 0x61,
0x74, 0x2c, 0x20, 0x53, 0x75, 0x6e, 0x2c, 0x20,
0x47, 0x4d, 0x54, 0x63, 0x68, 0x75, 0x6e, 0x6b,
0x65, 0x64, 0x2c, 0x74, 0x65, 0x78, 0x74, 0x2f,
0x68, 0x74, 0x6d, 0x6c, 0x2c, 0x69, 0x6d, 0x61,
0x67, 0x65, 0x2f, 0x70, 0x6e, 0x67, 0x2c, 0x69,
0x6d, 0x61, 0x67, 0x65, 0x2f, 0x6a, 0x70, 0x67,
0x2c, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x2f, 0x67,
0x69, 0x66, 0x2c, 0x61, 0x70, 0x70, 0x6c, 0x69,
0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2f, 0x78,
0x6d, 0x6c, 0x2c, 0x61, 0x70, 0x70, 0x6c, 0x69,
0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2f, 0x78,
0x68, 0x74, 0x6d, 0x6c, 0x2b, 0x78, 0x6d, 0x6c,
0x2c, 0x74, 0x65, 0x78, 0x74, 0x2f, 0x70, 0x6c,
0x61, 0x69, 0x6e, 0x2c, 0x74, 0x65, 0x78, 0x74,
0x2f, 0x6a, 0x61, 0x76, 0x61, 0x73, 0x63, 0x72,
0x69, 0x70, 0x74, 0x2c, 0x70, 0x75, 0x62, 0x6c,
0x69, 0x63, 0x70, 0x72, 0x69, 0x76, 0x61, 0x74,
0x65, 0x6d, 0x61, 0x78, 0x2d, 0x61, 0x67, 0x65,
0x3d, 0x67, 0x7a, 0x69, 0x70, 0x2c, 0x64, 0x65,
0x66, 0x6c, 0x61, 0x74, 0x65, 0x2c, 0x73, 0x64,
0x63, 0x68, 0x63, 0x68, 0x61, 0x72, 0x73, 0x65,
0x74, 0x3d, 0x75, 0x74, 0x66, 0x2d, 0x38, 0x63,
0x68, 0x61, 0x72, 0x73, 0x65, 0x74, 0x3d, 0x69,
0x73, 0x6f, 0x2d, 0x38, 0x38, 0x35, 0x39, 0x2d,
0x31, 0x2c, 0x75, 0x74, 0x66, 0x2d, 0x2c, 0x2a,
0x2c, 0x65, 0x6e, 0x71, 0x3d, 0x30, 0x2e,
}
spdy/read.go
View file @ 10d81ae2
...@@ -28,6 +28,9 @@ func (frame *RstStreamFrame) read(h ControlFrameHeader, f *Framer) error { ...@@ -28,6 +28,9 @@ func (frame *RstStreamFrame) read(h ControlFrameHeader, f *Framer) error {
if err := binary.Read(f.r, binary.BigEndian, &frame.Status); err != nil { if err := binary.Read(f.r, binary.BigEndian, &frame.Status); err != nil {
return err return err
} }
if frame.Status == 0 {
return &Error{InvalidControlFrame, frame.StreamId}
}
if frame.StreamId == 0 { if frame.StreamId == 0 {
return &Error{ZeroStreamId, 0} return &Error{ZeroStreamId, 0}
} }
...@@ -54,11 +57,6 @@ func (frame *SettingsFrame) read(h ControlFrameHeader, f *Framer) error { ...@@ -54,11 +57,6 @@ func (frame *SettingsFrame) read(h ControlFrameHeader, f *Framer) error {
return nil return nil
} }
func (frame *NoopFrame) read(h ControlFrameHeader, f *Framer) error {
frame.CFHeader = h
return nil
}
func (frame *PingFrame) read(h ControlFrameHeader, f *Framer) error { func (frame *PingFrame) read(h ControlFrameHeader, f *Framer) error {
frame.CFHeader = h frame.CFHeader = h
if err := binary.Read(f.r, binary.BigEndian, &frame.Id); err != nil { if err := binary.Read(f.r, binary.BigEndian, &frame.Id); err != nil {
...@@ -67,6 +65,9 @@ func (frame *PingFrame) read(h ControlFrameHeader, f *Framer) error { ...@@ -67,6 +65,9 @@ func (frame *PingFrame) read(h ControlFrameHeader, f *Framer) error {
if frame.Id == 0 { if frame.Id == 0 {
return &Error{ZeroStreamId, 0} return &Error{ZeroStreamId, 0}
} }
if frame.CFHeader.Flags != 0 {
return &Error{InvalidControlFrame, StreamId(frame.Id)}
}
return nil return nil
} }
...@@ -75,6 +76,15 @@ func (frame *GoAwayFrame) read(h ControlFrameHeader, f *Framer) error { ...@@ -75,6 +76,15 @@ func (frame *GoAwayFrame) read(h ControlFrameHeader, f *Framer) error {
if err := binary.Read(f.r, binary.BigEndian, &frame.LastGoodStreamId); err != nil { if err := binary.Read(f.r, binary.BigEndian, &frame.LastGoodStreamId); err != nil {
return err return err
} }
if frame.CFHeader.Flags != 0 {
return &Error{InvalidControlFrame, frame.LastGoodStreamId}
}
if frame.CFHeader.length != 8 {
return &Error{InvalidControlFrame, frame.LastGoodStreamId}
}
if err := binary.Read(f.r, binary.BigEndian, &frame.Status); err != nil {
return err
}
return nil return nil
} }
...@@ -82,6 +92,23 @@ func (frame *HeadersFrame) read(h ControlFrameHeader, f *Framer) error { ...@@ -82,6 +92,23 @@ func (frame *HeadersFrame) read(h ControlFrameHeader, f *Framer) error {
return f.readHeadersFrame(h, frame) return f.readHeadersFrame(h, frame)
} }
func (frame *WindowUpdateFrame) read(h ControlFrameHeader, f *Framer) error {
frame.CFHeader = h
if err := binary.Read(f.r, binary.BigEndian, &frame.StreamId); err != nil {
return err
}
if frame.CFHeader.Flags != 0 {
return &Error{InvalidControlFrame, frame.StreamId}
}
if frame.CFHeader.length != 8 {
return &Error{InvalidControlFrame, frame.StreamId}
}
if err := binary.Read(f.r, binary.BigEndian, &frame.DeltaWindowSize); err != nil {
return err
}
return nil
}
func newControlFrame(frameType ControlFrameType) (controlFrame, error) { func newControlFrame(frameType ControlFrameType) (controlFrame, error) {
ctor, ok := cframeCtor[frameType] ctor, ok := cframeCtor[frameType]
if !ok { if !ok {
...@@ -91,15 +118,14 @@ func newControlFrame(frameType ControlFrameType) (controlFrame, error) { ...@@ -91,15 +118,14 @@ func newControlFrame(frameType ControlFrameType) (controlFrame, error) {
} }
var cframeCtor = map[ControlFrameType]func() controlFrame{ var cframeCtor = map[ControlFrameType]func() controlFrame{
TypeSynStream: func() controlFrame { return new(SynStreamFrame) }, TypeSynStream: func() controlFrame { return new(SynStreamFrame) },
TypeSynReply: func() controlFrame { return new(SynReplyFrame) }, TypeSynReply: func() controlFrame { return new(SynReplyFrame) },
TypeRstStream: func() controlFrame { return new(RstStreamFrame) }, TypeRstStream: func() controlFrame { return new(RstStreamFrame) },
TypeSettings: func() controlFrame { return new(SettingsFrame) }, TypeSettings: func() controlFrame { return new(SettingsFrame) },
TypeNoop: func() controlFrame { return new(NoopFrame) }, TypePing: func() controlFrame { return new(PingFrame) },
TypePing: func() controlFrame { return new(PingFrame) }, TypeGoAway: func() controlFrame { return new(GoAwayFrame) },
TypeGoAway: func() controlFrame { return new(GoAwayFrame) }, TypeHeaders: func() controlFrame { return new(HeadersFrame) },
TypeHeaders: func() controlFrame { return new(HeadersFrame) }, TypeWindowUpdate: func() controlFrame { return new(WindowUpdateFrame) },
// TODO(willchan): Add TypeWindowUpdate
} }
func (f *Framer) uncorkHeaderDecompressor(payloadSize int64) error { func (f *Framer) uncorkHeaderDecompressor(payloadSize int64) error {
...@@ -108,7 +134,7 @@ func (f *Framer) uncorkHeaderDecompressor(payloadSize int64) error { ...@@ -108,7 +134,7 @@ func (f *Framer) uncorkHeaderDecompressor(payloadSize int64) error {
return nil return nil
} }
f.headerReader = io.LimitedReader{R: f.r, N: payloadSize} f.headerReader = io.LimitedReader{R: f.r, N: payloadSize}
decompressor, err := zlib.NewReaderDict(&f.headerReader, []byte(HeaderDictionary)) decompressor, err := zlib.NewReaderDict(&f.headerReader, []byte(headerDictionary))
if err != nil { if err != nil {
return err return err
} }
...@@ -122,12 +148,12 @@ func (f *Framer) ReadFrame() (Frame, error) { ...@@ -122,12 +148,12 @@ func (f *Framer) ReadFrame() (Frame, error) {
if err := binary.Read(f.r, binary.BigEndian, &firstWord); err != nil { if err := binary.Read(f.r, binary.BigEndian, &firstWord); err != nil {
return nil, err return nil, err
} }
if (firstWord & 0x80000000) != 0 { if firstWord&0x80000000 != 0 {
frameType := ControlFrameType(firstWord & 0xffff) frameType := ControlFrameType(firstWord & 0xffff)
version := uint16(0x7fff & (firstWord >> 16)) version := uint16(firstWord >> 16 & 0x7fff)
return f.parseControlFrame(version, frameType) return f.parseControlFrame(version, frameType)
} }
return f.parseDataFrame(firstWord & 0x7fffffff) return f.parseDataFrame(StreamId(firstWord & 0x7fffffff))
} }
func (f *Framer) parseControlFrame(version uint16, frameType ControlFrameType) (Frame, error) { func (f *Framer) parseControlFrame(version uint16, frameType ControlFrameType) (Frame, error) {
...@@ -148,15 +174,15 @@ func (f *Framer) parseControlFrame(version uint16, frameType ControlFrameType) ( ...@@ -148,15 +174,15 @@ func (f *Framer) parseControlFrame(version uint16, frameType ControlFrameType) (
return cframe, nil return cframe, nil
} }
func parseHeaderValueBlock(r io.Reader, streamId uint32) (http.Header, error) { func parseHeaderValueBlock(r io.Reader, streamId StreamId) (http.Header, error) {
var numHeaders uint16 var numHeaders uint32
if err := binary.Read(r, binary.BigEndian, &numHeaders); err != nil { if err := binary.Read(r, binary.BigEndian, &numHeaders); err != nil {
return nil, err return nil, err
} }
var e error var e error
h := make(http.Header, int(numHeaders)) h := make(http.Header, int(numHeaders))
for i := 0; i < int(numHeaders); i++ { for i := 0; i < int(numHeaders); i++ {
var length uint16 var length uint32
if err := binary.Read(r, binary.BigEndian, &length); err != nil { if err := binary.Read(r, binary.BigEndian, &length); err != nil {
return nil, err return nil, err
} }
...@@ -179,7 +205,7 @@ func parseHeaderValueBlock(r io.Reader, streamId uint32) (http.Header, error) { ...@@ -179,7 +205,7 @@ func parseHeaderValueBlock(r io.Reader, streamId uint32) (http.Header, error) {
if _, err := io.ReadFull(r, value); err != nil { if _, err := io.ReadFull(r, value); err != nil {
return nil, err return nil, err
} }
valueList := strings.Split(string(value), "\x00") valueList := strings.Split(string(value), headerValueSeparator)
for _, v := range valueList { for _, v := range valueList {
h.Add(name, v) h.Add(name, v)
} }
...@@ -202,8 +228,10 @@ func (f *Framer) readSynStreamFrame(h ControlFrameHeader, frame *SynStreamFrame) ...@@ -202,8 +228,10 @@ func (f *Framer) readSynStreamFrame(h ControlFrameHeader, frame *SynStreamFrame)
if err = binary.Read(f.r, binary.BigEndian, &frame.Priority); err != nil { if err = binary.Read(f.r, binary.BigEndian, &frame.Priority); err != nil {
return err return err
} }
frame.Priority >>= 14 frame.Priority >>= 5
if err = binary.Read(f.r, binary.BigEndian, &frame.Slot); err != nil {
return err
}
reader := f.r reader := f.r
if !f.headerCompressionDisabled { if !f.headerCompressionDisabled {
err := f.uncorkHeaderDecompressor(int64(h.length - 10)) err := f.uncorkHeaderDecompressor(int64(h.length - 10))
...@@ -212,20 +240,16 @@ func (f *Framer) readSynStreamFrame(h ControlFrameHeader, frame *SynStreamFrame) ...@@ -212,20 +240,16 @@ func (f *Framer) readSynStreamFrame(h ControlFrameHeader, frame *SynStreamFrame)
} }
reader = f.headerDecompressor reader = f.headerDecompressor
} }
frame.Headers, err = parseHeaderValueBlock(reader, frame.StreamId) frame.Headers, err = parseHeaderValueBlock(reader, frame.StreamId)
if !f.headerCompressionDisabled && ((err == io.EOF && f.headerReader.N == 0) || f.headerReader.N != 0) { if !f.headerCompressionDisabled && (err == io.EOF && f.headerReader.N == 0 || f.headerReader.N != 0) {
err = &Error{WrongCompressedPayloadSize, 0} err = &Error{WrongCompressedPayloadSize, 0}
} }
if err != nil { if err != nil {
return err return err
} }
// Remove this condition when we bump Version to 3. for h := range frame.Headers {
if Version >= 3 { if invalidReqHeaders[h] {
for h := range frame.Headers { return &Error{InvalidHeaderPresent, frame.StreamId}
if invalidReqHeaders[h] {
return &Error{InvalidHeaderPresent, frame.StreamId}
}
} }
} }
if frame.StreamId == 0 { if frame.StreamId == 0 {
...@@ -240,31 +264,24 @@ func (f *Framer) readSynReplyFrame(h ControlFrameHeader, frame *SynReplyFrame) e ...@@ -240,31 +264,24 @@ func (f *Framer) readSynReplyFrame(h ControlFrameHeader, frame *SynReplyFrame) e
if err = binary.Read(f.r, binary.BigEndian, &frame.StreamId); err != nil { if err = binary.Read(f.r, binary.BigEndian, &frame.StreamId); err != nil {
return err return err
} }
var unused uint16
if err = binary.Read(f.r, binary.BigEndian, &unused); err != nil {
return err
}
reader := f.r reader := f.r
if !f.headerCompressionDisabled { if !f.headerCompressionDisabled {
err := f.uncorkHeaderDecompressor(int64(h.length - 6)) err := f.uncorkHeaderDecompressor(int64(h.length - 4))
if err != nil { if err != nil {
return err return err
} }
reader = f.headerDecompressor reader = f.headerDecompressor
} }
frame.Headers, err = parseHeaderValueBlock(reader, frame.StreamId) frame.Headers, err = parseHeaderValueBlock(reader, frame.StreamId)
if !f.headerCompressionDisabled && ((err == io.EOF && f.headerReader.N == 0) || f.headerReader.N != 0) { if !f.headerCompressionDisabled && (err == io.EOF && f.headerReader.N == 0 || f.headerReader.N != 0) {
err = &Error{WrongCompressedPayloadSize, 0} err = &Error{WrongCompressedPayloadSize, 0}
} }
if err != nil { if err != nil {
return err return err
} }
// Remove this condition when we bump Version to 3. for h := range frame.Headers {
if Version >= 3 { if invalidRespHeaders[h] {
for h := range frame.Headers { return &Error{InvalidHeaderPresent, frame.StreamId}
if invalidRespHeaders[h] {
return &Error{InvalidHeaderPresent, frame.StreamId}
}
} }
} }
if frame.StreamId == 0 { if frame.StreamId == 0 {
...@@ -279,38 +296,30 @@ func (f *Framer) readHeadersFrame(h ControlFrameHeader, frame *HeadersFrame) err ...@@ -279,38 +296,30 @@ func (f *Framer) readHeadersFrame(h ControlFrameHeader, frame *HeadersFrame) err
if err = binary.Read(f.r, binary.BigEndian, &frame.StreamId); err != nil { if err = binary.Read(f.r, binary.BigEndian, &frame.StreamId); err != nil {
return err return err
} }
var unused uint16
if err = binary.Read(f.r, binary.BigEndian, &unused); err != nil {
return err
}
reader := f.r reader := f.r
if !f.headerCompressionDisabled { if !f.headerCompressionDisabled {
err := f.uncorkHeaderDecompressor(int64(h.length - 6)) err := f.uncorkHeaderDecompressor(int64(h.length - 4))
if err != nil { if err != nil {
return err return err
} }
reader = f.headerDecompressor reader = f.headerDecompressor
} }
frame.Headers, err = parseHeaderValueBlock(reader, frame.StreamId) frame.Headers, err = parseHeaderValueBlock(reader, frame.StreamId)
if !f.headerCompressionDisabled && ((err == io.EOF && f.headerReader.N == 0) || f.headerReader.N != 0) { if !f.headerCompressionDisabled && (err == io.EOF && f.headerReader.N == 0 || f.headerReader.N != 0) {
err = &Error{WrongCompressedPayloadSize, 0} err = &Error{WrongCompressedPayloadSize, 0}
} }
if err != nil { if err != nil {
return err return err
} }
var invalidHeaders map[string]bool
// Remove this condition when we bump Version to 3. if frame.StreamId%2 == 0 {
if Version >= 3 { invalidHeaders = invalidReqHeaders
var invalidHeaders map[string]bool } else {
if frame.StreamId%2 == 0 { invalidHeaders = invalidRespHeaders
invalidHeaders = invalidReqHeaders }
} else { for h := range frame.Headers {
invalidHeaders = invalidRespHeaders if invalidHeaders[h] {
} return &Error{InvalidHeaderPresent, frame.StreamId}
for h := range frame.Headers {
if invalidHeaders[h] {
return &Error{InvalidHeaderPresent, frame.StreamId}
}
} }
} }
if frame.StreamId == 0 { if frame.StreamId == 0 {
...@@ -319,7 +328,7 @@ func (f *Framer) readHeadersFrame(h ControlFrameHeader, frame *HeadersFrame) err ...@@ -319,7 +328,7 @@ func (f *Framer) readHeadersFrame(h ControlFrameHeader, frame *HeadersFrame) err
return nil return nil
} }
func (f *Framer) parseDataFrame(streamId uint32) (*DataFrame, error) { func (f *Framer) parseDataFrame(streamId StreamId) (*DataFrame, error) {
var length uint32 var length uint32
if err := binary.Read(f.r, binary.BigEndian, &length); err != nil { if err := binary.Read(f.r, binary.BigEndian, &length); err != nil {
return nil, err return nil, err
......
spdy/spdy_test.go
View file @ 10d81ae2
...@@ -15,28 +15,28 @@ import ( ...@@ -15,28 +15,28 @@ import (
"testing" "testing"
) )
var HeadersFixture = http.Header{
"Url": []string{"http://www.google.com/"},
"Method": []string{"get"},
"Version": []string{"http/1.1"},
}
func TestHeaderParsing(t *testing.T) { func TestHeaderParsing(t *testing.T) {
headers := http.Header{
"Url": []string{"http://www.google.com/"},
"Method": []string{"get"},
"Version": []string{"http/1.1"},
}
var headerValueBlockBuf bytes.Buffer var headerValueBlockBuf bytes.Buffer
writeHeaderValueBlock(&headerValueBlockBuf, headers) writeHeaderValueBlock(&headerValueBlockBuf, HeadersFixture)
const bogusStreamId = 1 const bogusStreamId = 1
newHeaders, err := parseHeaderValueBlock(&headerValueBlockBuf, bogusStreamId) newHeaders, err := parseHeaderValueBlock(&headerValueBlockBuf, bogusStreamId)
if err != nil { if err != nil {
t.Fatal("parseHeaderValueBlock:", err) t.Fatal("parseHeaderValueBlock:", err)
} }
if !reflect.DeepEqual(HeadersFixture, newHeaders) {
if !reflect.DeepEqual(headers, newHeaders) { t.Fatal("got: ", newHeaders, "\nwant: ", HeadersFixture)
t.Fatal("got: ", newHeaders, "\nwant: ", headers)
} }
} }
func TestCreateParseSynStreamFrame(t *testing.T) { func TestCreateParseSynStreamFrameCompressionDisable(t *testing.T) {
buffer := new(bytes.Buffer) buffer := new(bytes.Buffer)
// Fixture framer for no compression test.
framer := &Framer{ framer := &Framer{
headerCompressionDisabled: true, headerCompressionDisabled: true,
w: buffer, w: buffer,
...@@ -49,11 +49,7 @@ func TestCreateParseSynStreamFrame(t *testing.T) { ...@@ -49,11 +49,7 @@ func TestCreateParseSynStreamFrame(t *testing.T) {
frameType: TypeSynStream, frameType: TypeSynStream,
}, },
StreamId: 2, StreamId: 2,
Headers: http.Header{ Headers: HeadersFixture,
"Url": []string{"http://www.google.com/"},
"Method": []string{"get"},
"Version": []string{"http/1.1"},
},
} }
if err := framer.WriteFrame(&synStreamFrame); err != nil { if err := framer.WriteFrame(&synStreamFrame); err != nil {
t.Fatal("WriteFrame without compression:", err) t.Fatal("WriteFrame without compression:", err)
...@@ -69,21 +65,30 @@ func TestCreateParseSynStreamFrame(t *testing.T) { ...@@ -69,21 +65,30 @@ func TestCreateParseSynStreamFrame(t *testing.T) {
if !reflect.DeepEqual(synStreamFrame, *parsedSynStreamFrame) { if !reflect.DeepEqual(synStreamFrame, *parsedSynStreamFrame) {
t.Fatal("got: ", *parsedSynStreamFrame, "\nwant: ", synStreamFrame) t.Fatal("got: ", *parsedSynStreamFrame, "\nwant: ", synStreamFrame)
} }
}
// Test again with compression func TestCreateParseSynStreamFrameCompressionEnable(t *testing.T) {
buffer.Reset() buffer := new(bytes.Buffer)
framer, err = NewFramer(buffer, buffer) framer, err := NewFramer(buffer, buffer)
synStreamFrame := SynStreamFrame{
CFHeader: ControlFrameHeader{
version: Version,
frameType: TypeSynStream,
},
StreamId: 2,
Headers: HeadersFixture,
}
if err != nil { if err != nil {
t.Fatal("Failed to create new framer:", err) t.Fatal("Failed to create new framer:", err)
} }
if err := framer.WriteFrame(&synStreamFrame); err != nil { if err := framer.WriteFrame(&synStreamFrame); err != nil {
t.Fatal("WriteFrame with compression:", err) t.Fatal("WriteFrame with compression:", err)
} }
frame, err = framer.ReadFrame() frame, err := framer.ReadFrame()
if err != nil { if err != nil {
t.Fatal("ReadFrame with compression:", err) t.Fatal("ReadFrame with compression:", err)
} }
parsedSynStreamFrame, ok = frame.(*SynStreamFrame) parsedSynStreamFrame, ok := frame.(*SynStreamFrame)
if !ok { if !ok {
t.Fatal("Parsed incorrect frame type:", frame) t.Fatal("Parsed incorrect frame type:", frame)
} }
...@@ -92,7 +97,7 @@ func TestCreateParseSynStreamFrame(t *testing.T) { ...@@ -92,7 +97,7 @@ func TestCreateParseSynStreamFrame(t *testing.T) {
} }
} }
func TestCreateParseSynReplyFrame(t *testing.T) { func TestCreateParseSynReplyFrameCompressionDisable(t *testing.T) {
buffer := new(bytes.Buffer) buffer := new(bytes.Buffer)
framer := &Framer{ framer := &Framer{
headerCompressionDisabled: true, headerCompressionDisabled: true,
...@@ -106,11 +111,7 @@ func TestCreateParseSynReplyFrame(t *testing.T) { ...@@ -106,11 +111,7 @@ func TestCreateParseSynReplyFrame(t *testing.T) {
frameType: TypeSynReply, frameType: TypeSynReply,
}, },
StreamId: 2, StreamId: 2,
Headers: http.Header{ Headers: HeadersFixture,
"Url": []string{"http://www.google.com/"},
"Method": []string{"get"},
"Version": []string{"http/1.1"},
},
} }
if err := framer.WriteFrame(&synReplyFrame); err != nil { if err := framer.WriteFrame(&synReplyFrame); err != nil {
t.Fatal("WriteFrame without compression:", err) t.Fatal("WriteFrame without compression:", err)
...@@ -126,21 +127,30 @@ func TestCreateParseSynReplyFrame(t *testing.T) { ...@@ -126,21 +127,30 @@ func TestCreateParseSynReplyFrame(t *testing.T) {
if !reflect.DeepEqual(synReplyFrame, *parsedSynReplyFrame) { if !reflect.DeepEqual(synReplyFrame, *parsedSynReplyFrame) {
t.Fatal("got: ", *parsedSynReplyFrame, "\nwant: ", synReplyFrame) t.Fatal("got: ", *parsedSynReplyFrame, "\nwant: ", synReplyFrame)
} }
}
// Test again with compression func TestCreateParseSynReplyFrameCompressionEnable(t *testing.T) {
buffer.Reset() buffer := new(bytes.Buffer)
framer, err = NewFramer(buffer, buffer) framer, err := NewFramer(buffer, buffer)
synReplyFrame := SynReplyFrame{
CFHeader: ControlFrameHeader{
version: Version,
frameType: TypeSynReply,
},
StreamId: 2,
Headers: HeadersFixture,
}
if err != nil { if err != nil {
t.Fatal("Failed to create new framer:", err) t.Fatal("Failed to create new framer:", err)
} }
if err := framer.WriteFrame(&synReplyFrame); err != nil { if err := framer.WriteFrame(&synReplyFrame); err != nil {
t.Fatal("WriteFrame with compression:", err) t.Fatal("WriteFrame with compression:", err)
} }
frame, err = framer.ReadFrame() frame, err := framer.ReadFrame()
if err != nil { if err != nil {
t.Fatal("ReadFrame with compression:", err) t.Fatal("ReadFrame with compression:", err)
} }
parsedSynReplyFrame, ok = frame.(*SynReplyFrame) parsedSynReplyFrame, ok := frame.(*SynReplyFrame)
if !ok { if !ok {
t.Fatal("Parsed incorrect frame type:", frame) t.Fatal("Parsed incorrect frame type:", frame)
} }
...@@ -211,34 +221,6 @@ func TestCreateParseSettings(t *testing.T) { ...@@ -211,34 +221,6 @@ func TestCreateParseSettings(t *testing.T) {
} }
} }
func TestCreateParseNoop(t *testing.T) {
buffer := new(bytes.Buffer)
framer, err := NewFramer(buffer, buffer)
if err != nil {
t.Fatal("Failed to create new framer:", err)
}
noopFrame := NoopFrame{
CFHeader: ControlFrameHeader{
version: Version,
frameType: TypeNoop,
},
}
if err := framer.WriteFrame(&noopFrame); err != nil {
t.Fatal("WriteFrame:", err)
}
frame, err := framer.ReadFrame()
if err != nil {
t.Fatal("ReadFrame:", err)
}
parsedNoopFrame, ok := frame.(*NoopFrame)
if !ok {
t.Fatal("Parsed incorrect frame type:", frame)
}
if !reflect.DeepEqual(noopFrame, *parsedNoopFrame) {
t.Fatal("got: ", *parsedNoopFrame, "\nwant: ", noopFrame)
}
}
func TestCreateParsePing(t *testing.T) { func TestCreateParsePing(t *testing.T) {
buffer := new(bytes.Buffer) buffer := new(bytes.Buffer)
framer, err := NewFramer(buffer, buffer) framer, err := NewFramer(buffer, buffer)
...@@ -255,6 +237,9 @@ func TestCreateParsePing(t *testing.T) { ...@@ -255,6 +237,9 @@ func TestCreateParsePing(t *testing.T) {
if err := framer.WriteFrame(&pingFrame); err != nil { if err := framer.WriteFrame(&pingFrame); err != nil {
t.Fatal("WriteFrame:", err) t.Fatal("WriteFrame:", err)
} }
if pingFrame.CFHeader.Flags != 0 {
t.Fatal("Incorrect frame type:", pingFrame)
}
frame, err := framer.ReadFrame() frame, err := framer.ReadFrame()
if err != nil { if err != nil {
t.Fatal("ReadFrame:", err) t.Fatal("ReadFrame:", err)
...@@ -263,6 +248,9 @@ func TestCreateParsePing(t *testing.T) { ...@@ -263,6 +248,9 @@ func TestCreateParsePing(t *testing.T) {
if !ok { if !ok {
t.Fatal("Parsed incorrect frame type:", frame) t.Fatal("Parsed incorrect frame type:", frame)
} }
if parsedPingFrame.CFHeader.Flags != 0 {
t.Fatal("Parsed incorrect frame type:", parsedPingFrame)
}
if !reflect.DeepEqual(pingFrame, *parsedPingFrame) { if !reflect.DeepEqual(pingFrame, *parsedPingFrame) {
t.Fatal("got: ", *parsedPingFrame, "\nwant: ", pingFrame) t.Fatal("got: ", *parsedPingFrame, "\nwant: ", pingFrame)
} }
...@@ -280,10 +268,17 @@ func TestCreateParseGoAway(t *testing.T) { ...@@ -280,10 +268,17 @@ func TestCreateParseGoAway(t *testing.T) {
frameType: TypeGoAway, frameType: TypeGoAway,
}, },
LastGoodStreamId: 31337, LastGoodStreamId: 31337,
Status: 1,
} }
if err := framer.WriteFrame(&goAwayFrame); err != nil { if err := framer.WriteFrame(&goAwayFrame); err != nil {
t.Fatal("WriteFrame:", err) t.Fatal("WriteFrame:", err)
} }
if goAwayFrame.CFHeader.Flags != 0 {
t.Fatal("Incorrect frame type:", goAwayFrame)
}
if goAwayFrame.CFHeader.length != 8 {
t.Fatal("Incorrect frame type:", goAwayFrame)
}
frame, err := framer.ReadFrame() frame, err := framer.ReadFrame()
if err != nil { if err != nil {
t.Fatal("ReadFrame:", err) t.Fatal("ReadFrame:", err)
...@@ -292,6 +287,12 @@ func TestCreateParseGoAway(t *testing.T) { ...@@ -292,6 +287,12 @@ func TestCreateParseGoAway(t *testing.T) {
if !ok { if !ok {
t.Fatal("Parsed incorrect frame type:", frame) t.Fatal("Parsed incorrect frame type:", frame)
} }
if parsedGoAwayFrame.CFHeader.Flags != 0 {
t.Fatal("Incorrect frame type:", parsedGoAwayFrame)
}
if parsedGoAwayFrame.CFHeader.length != 8 {
t.Fatal("Incorrect frame type:", parsedGoAwayFrame)
}
if !reflect.DeepEqual(goAwayFrame, *parsedGoAwayFrame) { if !reflect.DeepEqual(goAwayFrame, *parsedGoAwayFrame) {
t.Fatal("got: ", *parsedGoAwayFrame, "\nwant: ", goAwayFrame) t.Fatal("got: ", *parsedGoAwayFrame, "\nwant: ", goAwayFrame)
} }
...@@ -312,11 +313,7 @@ func TestCreateParseHeadersFrame(t *testing.T) { ...@@ -312,11 +313,7 @@ func TestCreateParseHeadersFrame(t *testing.T) {
}, },
StreamId: 2, StreamId: 2,
} }
headersFrame.Headers = http.Header{ headersFrame.Headers = HeadersFixture
"Url": []string{"http://www.google.com/"},
"Method": []string{"get"},
"Version": []string{"http/1.1"},
}
if err := framer.WriteFrame(&headersFrame); err != nil { if err := framer.WriteFrame(&headersFrame); err != nil {
t.Fatal("WriteFrame without compression:", err) t.Fatal("WriteFrame without compression:", err)
} }
...@@ -331,18 +328,28 @@ func TestCreateParseHeadersFrame(t *testing.T) { ...@@ -331,18 +328,28 @@ func TestCreateParseHeadersFrame(t *testing.T) {
if !reflect.DeepEqual(headersFrame, *parsedHeadersFrame) { if !reflect.DeepEqual(headersFrame, *parsedHeadersFrame) {
t.Fatal("got: ", *parsedHeadersFrame, "\nwant: ", headersFrame) t.Fatal("got: ", *parsedHeadersFrame, "\nwant: ", headersFrame)
} }
}
// Test again with compression func TestCreateParseHeadersFrameCompressionEnable(t *testing.T) {
buffer.Reset() buffer := new(bytes.Buffer)
framer, err = NewFramer(buffer, buffer) headersFrame := HeadersFrame{
CFHeader: ControlFrameHeader{
version: Version,
frameType: TypeHeaders,
},
StreamId: 2,
}
headersFrame.Headers = HeadersFixture
framer, err := NewFramer(buffer, buffer)
if err := framer.WriteFrame(&headersFrame); err != nil { if err := framer.WriteFrame(&headersFrame); err != nil {
t.Fatal("WriteFrame with compression:", err) t.Fatal("WriteFrame with compression:", err)
} }
frame, err = framer.ReadFrame() frame, err := framer.ReadFrame()
if err != nil { if err != nil {
t.Fatal("ReadFrame with compression:", err) t.Fatal("ReadFrame with compression:", err)
} }
parsedHeadersFrame, ok = frame.(*HeadersFrame) parsedHeadersFrame, ok := frame.(*HeadersFrame)
if !ok { if !ok {
t.Fatal("Parsed incorrect frame type:", frame) t.Fatal("Parsed incorrect frame type:", frame)
} }
...@@ -351,6 +358,48 @@ func TestCreateParseHeadersFrame(t *testing.T) { ...@@ -351,6 +358,48 @@ func TestCreateParseHeadersFrame(t *testing.T) {
} }
} }
func TestCreateParseWindowUpdateFrame(t *testing.T) {
buffer := new(bytes.Buffer)
framer, err := NewFramer(buffer, buffer)
if err != nil {
t.Fatal("Failed to create new framer:", err)
}
windowUpdateFrame := WindowUpdateFrame{
CFHeader: ControlFrameHeader{
version: Version,
frameType: TypeWindowUpdate,
},
StreamId: 31337,
DeltaWindowSize: 1,
}
if err := framer.WriteFrame(&windowUpdateFrame); err != nil {
t.Fatal("WriteFrame:", err)
}
if windowUpdateFrame.CFHeader.Flags != 0 {
t.Fatal("Incorrect frame type:", windowUpdateFrame)
}
if windowUpdateFrame.CFHeader.length != 8 {
t.Fatal("Incorrect frame type:", windowUpdateFrame)
}
frame, err := framer.ReadFrame()
if err != nil {
t.Fatal("ReadFrame:", err)
}
parsedWindowUpdateFrame, ok := frame.(*WindowUpdateFrame)
if !ok {
t.Fatal("Parsed incorrect frame type:", frame)
}
if parsedWindowUpdateFrame.CFHeader.Flags != 0 {
t.Fatal("Incorrect frame type:", parsedWindowUpdateFrame)
}
if parsedWindowUpdateFrame.CFHeader.length != 8 {
t.Fatal("Incorrect frame type:", parsedWindowUpdateFrame)
}
if !reflect.DeepEqual(windowUpdateFrame, *parsedWindowUpdateFrame) {
t.Fatal("got: ", *parsedWindowUpdateFrame, "\nwant: ", windowUpdateFrame)
}
}
func TestCreateParseDataFrame(t *testing.T) { func TestCreateParseDataFrame(t *testing.T) {
buffer := new(bytes.Buffer) buffer := new(bytes.Buffer)
framer, err := NewFramer(buffer, buffer) framer, err := NewFramer(buffer, buffer)
...@@ -389,21 +438,26 @@ func TestCompressionContextAcrossFrames(t *testing.T) { ...@@ -389,21 +438,26 @@ func TestCompressionContextAcrossFrames(t *testing.T) {
frameType: TypeHeaders, frameType: TypeHeaders,
}, },
StreamId: 2, StreamId: 2,
Headers: http.Header{ Headers: HeadersFixture,
"Url": []string{"http://www.google.com/"},
"Method": []string{"get"},
"Version": []string{"http/1.1"},
},
} }
if err := framer.WriteFrame(&headersFrame); err != nil { if err := framer.WriteFrame(&headersFrame); err != nil {
t.Fatal("WriteFrame (HEADERS):", err) t.Fatal("WriteFrame (HEADERS):", err)
} }
synStreamFrame := SynStreamFrame{ControlFrameHeader{Version, TypeSynStream, 0, 0}, 2, 0, 0, nil} synStreamFrame := SynStreamFrame{
synStreamFrame.Headers = http.Header{ ControlFrameHeader{
"Url": []string{"http://www.google.com/"}, Version,
"Method": []string{"get"}, TypeSynStream,
"Version": []string{"http/1.1"}, 0, // Flags
0, // length
},
2, // StreamId
0, // AssociatedTOStreamID
0, // Priority
1, // Slot
nil, // Headers
} }
synStreamFrame.Headers = HeadersFixture
if err := framer.WriteFrame(&synStreamFrame); err != nil { if err := framer.WriteFrame(&synStreamFrame); err != nil {
t.Fatal("WriteFrame (SYN_STREAM):", err) t.Fatal("WriteFrame (SYN_STREAM):", err)
} }
...@@ -451,11 +505,7 @@ func TestMultipleSPDYFrames(t *testing.T) { ...@@ -451,11 +505,7 @@ func TestMultipleSPDYFrames(t *testing.T) {
frameType: TypeHeaders, frameType: TypeHeaders,
}, },
StreamId: 2, StreamId: 2,
Headers: http.Header{ Headers: HeadersFixture,
"Url": []string{"http://www.google.com/"},
"Method": []string{"get"},
"Version": []string{"http/1.1"},
},
} }
synStreamFrame := SynStreamFrame{ synStreamFrame := SynStreamFrame{
CFHeader: ControlFrameHeader{ CFHeader: ControlFrameHeader{
...@@ -463,11 +513,7 @@ func TestMultipleSPDYFrames(t *testing.T) { ...@@ -463,11 +513,7 @@ func TestMultipleSPDYFrames(t *testing.T) {
frameType: TypeSynStream, frameType: TypeSynStream,
}, },
StreamId: 2, StreamId: 2,
Headers: http.Header{ Headers: HeadersFixture,
"Url": []string{"http://www.google.com/"},
"Method": []string{"get"},
"Version": []string{"http/1.1"},
},
} }
// Start the goroutines to write the frames. // Start the goroutines to write the frames.
...@@ -530,6 +576,8 @@ func TestReadMalformedZlibHeader(t *testing.T) { ...@@ -530,6 +576,8 @@ func TestReadMalformedZlibHeader(t *testing.T) {
} }
} }
// TODO: these tests are too weak for updating SPDY spec. Fix me.
type zeroStream struct { type zeroStream struct {
frame Frame frame Frame
encoded string encoded string
...@@ -563,6 +611,9 @@ var streamIdZeroFrames = map[string]zeroStream{ ...@@ -563,6 +611,9 @@ var streamIdZeroFrames = map[string]zeroStream{
} }
func TestNoZeroStreamId(t *testing.T) { func TestNoZeroStreamId(t *testing.T) {
t.Log("skipping") // TODO: update to work with SPDY3
return
for name, f := range streamIdZeroFrames { for name, f := range streamIdZeroFrames {
b, err := base64.StdEncoding.DecodeString(f.encoded) b, err := base64.StdEncoding.DecodeString(f.encoded)
if err != nil { if err != nil {
......
spdy/types.go
View file @ 10d81ae2
...@@ -2,10 +2,8 @@ ...@@ -2,10 +2,8 @@
// Use of this source code is governed by a BSD-style // Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file. // license that can be found in the LICENSE file.
// Package spdy implements SPDY protocol which is described in // Package spdy implements the SPDY protocol (currently SPDY/3), described in
// draft-mbelshe-httpbis-spdy-00. // http://www.chromium.org/spdy/spdy-protocol/spdy-protocol-draft3.
//
// http://tools.ietf.org/html/draft-mbelshe-httpbis-spdy-00
package spdy package spdy
import ( import (
...@@ -15,128 +13,17 @@ import ( ...@@ -15,128 +13,17 @@ import (
"net/http" "net/http"
) )
// Data Frame Format
// +----------------------------------+
// |0| Stream-ID (31bits) |
// +----------------------------------+
// | flags (8) | Length (24 bits) |
// +----------------------------------+
// | Data |
// +----------------------------------+
//
// Control Frame Format
// +----------------------------------+
// |1| Version(15bits) | Type(16bits) |
// +----------------------------------+
// | flags (8) | Length (24 bits) |
// +----------------------------------+
// | Data |
// +----------------------------------+
//
// Control Frame: SYN_STREAM
// +----------------------------------+
// |1|000000000000001|0000000000000001|
// +----------------------------------+
// | flags (8) | Length (24 bits) | >= 12
// +----------------------------------+
// |X| Stream-ID(31bits) |
// +----------------------------------+
// |X|Associated-To-Stream-ID (31bits)|
// +----------------------------------+
// |Pri| unused | Length (16bits)|
// +----------------------------------+
//
// Control Frame: SYN_REPLY
// +----------------------------------+
// |1|000000000000001|0000000000000010|
// +----------------------------------+
// | flags (8) | Length (24 bits) | >= 8
// +----------------------------------+
// |X| Stream-ID(31bits) |
// +----------------------------------+
// | unused (16 bits)| Length (16bits)|
// +----------------------------------+
//
// Control Frame: RST_STREAM
// +----------------------------------+
// |1|000000000000001|0000000000000011|
// +----------------------------------+
// | flags (8) | Length (24 bits) | >= 4
// +----------------------------------+
// |X| Stream-ID(31bits) |
// +----------------------------------+
// | Status code (32 bits) |
// +----------------------------------+
//
// Control Frame: SETTINGS
// +----------------------------------+
// |1|000000000000001|0000000000000100|
// +----------------------------------+
// | flags (8) | Length (24 bits) |
// +----------------------------------+
// | # of entries (32) |
// +----------------------------------+
//
// Control Frame: NOOP
// +----------------------------------+
// |1|000000000000001|0000000000000101|
// +----------------------------------+
// | flags (8) | Length (24 bits) | = 0
// +----------------------------------+
//
// Control Frame: PING
// +----------------------------------+
// |1|000000000000001|0000000000000110|
// +----------------------------------+
// | flags (8) | Length (24 bits) | = 4
// +----------------------------------+
// | Unique id (32 bits) |
// +----------------------------------+
//
// Control Frame: GOAWAY
// +----------------------------------+
// |1|000000000000001|0000000000000111|
// +----------------------------------+
// | flags (8) | Length (24 bits) | = 4
// +----------------------------------+
// |X| Last-accepted-stream-id |
// +----------------------------------+
//
// Control Frame: HEADERS
// +----------------------------------+
// |1|000000000000001|0000000000001000|
// +----------------------------------+
// | flags (8) | Length (24 bits) | >= 8
// +----------------------------------+
// |X| Stream-ID (31 bits) |
// +----------------------------------+
// | unused (16 bits)| Length (16bits)|
// +----------------------------------+
//
// Control Frame: WINDOW_UPDATE
// +----------------------------------+
// |1|000000000000001|0000000000001001|
// +----------------------------------+
// | flags (8) | Length (24 bits) | = 8
// +----------------------------------+
// |X| Stream-ID (31 bits) |
// +----------------------------------+
// | Delta-Window-Size (32 bits) |
// +----------------------------------+
// Version is the protocol version number that this package implements. // Version is the protocol version number that this package implements.
const Version = 2 const Version = 3
// ControlFrameType stores the type field in a control frame header. // ControlFrameType stores the type field in a control frame header.
type ControlFrameType uint16 type ControlFrameType uint16
// Control frame type constants
const ( const (
TypeSynStream ControlFrameType = 0x0001 TypeSynStream ControlFrameType = 0x0001
TypeSynReply = 0x0002 TypeSynReply = 0x0002
TypeRstStream = 0x0003 TypeRstStream = 0x0003
TypeSettings = 0x0004 TypeSettings = 0x0004
TypeNoop = 0x0005
TypePing = 0x0006 TypePing = 0x0006
TypeGoAway = 0x0007 TypeGoAway = 0x0007
TypeHeaders = 0x0008 TypeHeaders = 0x0008
...@@ -147,20 +34,24 @@ const ( ...@@ -147,20 +34,24 @@ const (
type ControlFlags uint8 type ControlFlags uint8
const ( const (
ControlFlagFin ControlFlags = 0x01 ControlFlagFin ControlFlags = 0x01
ControlFlagUnidirectional = 0x02
ControlFlagSettingsClearSettings = 0x01
) )
// DataFlags are the flags that can be set on a data frame. // DataFlags are the flags that can be set on a data frame.
type DataFlags uint8 type DataFlags uint8
const ( const (
DataFlagFin DataFlags = 0x01 DataFlagFin DataFlags = 0x01
DataFlagCompressed = 0x02
) )
// MaxDataLength is the maximum number of bytes that can be stored in one frame. // MaxDataLength is the maximum number of bytes that can be stored in one frame.
const MaxDataLength = 1<<24 - 1 const MaxDataLength = 1<<24 - 1
// headerValueSepator separates multiple header values.
const headerValueSeparator = "\x00"
// Frame is a single SPDY frame in its unpacked in-memory representation. Use // Frame is a single SPDY frame in its unpacked in-memory representation. Use
// Framer to read and write it. // Framer to read and write it.
type Frame interface { type Frame interface {
...@@ -171,10 +62,10 @@ type Frame interface { ...@@ -171,10 +62,10 @@ type Frame interface {
// in its unpacked in-memory representation. // in its unpacked in-memory representation.
type ControlFrameHeader struct { type ControlFrameHeader struct {
// Note, high bit is the "Control" bit. // Note, high bit is the "Control" bit.
version uint16 version uint16 // spdy version number
frameType ControlFrameType frameType ControlFrameType
Flags ControlFlags Flags ControlFlags
length uint32 length uint32 // length of data field
} }
type controlFrame interface { type controlFrame interface {
...@@ -182,44 +73,50 @@ type controlFrame interface { ...@@ -182,44 +73,50 @@ type controlFrame interface {
read(h ControlFrameHeader, f *Framer) error read(h ControlFrameHeader, f *Framer) error
} }
// StreamId represents a 31-bit value identifying the stream.
type StreamId uint32
// SynStreamFrame is the unpacked, in-memory representation of a SYN_STREAM // SynStreamFrame is the unpacked, in-memory representation of a SYN_STREAM
// frame. // frame.
type SynStreamFrame struct { type SynStreamFrame struct {
CFHeader ControlFrameHeader CFHeader ControlFrameHeader
StreamId uint32 StreamId StreamId
AssociatedToStreamId uint32 AssociatedToStreamId StreamId // stream id for a stream which this stream is associated to
// Note, only 2 highest bits currently used Priority uint8 // priority of this frame (3-bit)
// Rest of Priority is unused. Slot uint8 // index in the server's credential vector of the client certificate
Priority uint16 Headers http.Header
Headers http.Header
} }
// SynReplyFrame is the unpacked, in-memory representation of a SYN_REPLY frame. // SynReplyFrame is the unpacked, in-memory representation of a SYN_REPLY frame.
type SynReplyFrame struct { type SynReplyFrame struct {
CFHeader ControlFrameHeader CFHeader ControlFrameHeader
StreamId uint32 StreamId StreamId
Headers http.Header Headers http.Header
} }
// StatusCode represents the status that led to a RST_STREAM // RstStreamStatus represents the status that led to a RST_STREAM.
type StatusCode uint32 type RstStreamStatus uint32
const ( const (
ProtocolError StatusCode = 1 ProtocolError RstStreamStatus = iota + 1
InvalidStream = 2 InvalidStream
RefusedStream = 3 RefusedStream
UnsupportedVersion = 4 UnsupportedVersion
Cancel = 5 Cancel
InternalError = 6 InternalError
FlowControlError = 7 FlowControlError
StreamInUse
StreamAlreadyClosed
InvalidCredentials
FrameTooLarge
) )
// RstStreamFrame is the unpacked, in-memory representation of a RST_STREAM // RstStreamFrame is the unpacked, in-memory representation of a RST_STREAM
// frame. // frame.
type RstStreamFrame struct { type RstStreamFrame struct {
CFHeader ControlFrameHeader CFHeader ControlFrameHeader
StreamId uint32 StreamId StreamId
Status StatusCode Status RstStreamStatus
} }
// SettingsFlag represents a flag in a SETTINGS frame. // SettingsFlag represents a flag in a SETTINGS frame.
...@@ -234,11 +131,14 @@ const ( ...@@ -234,11 +131,14 @@ const (
type SettingsId uint32 type SettingsId uint32
const ( const (
SettingsUploadBandwidth SettingsId = 1 SettingsUploadBandwidth SettingsId = iota + 1
SettingsDownloadBandwidth = 2 SettingsDownloadBandwidth
SettingsRoundTripTime = 3 SettingsRoundTripTime
SettingsMaxConcurrentStreams = 4 SettingsMaxConcurrentStreams
SettingsCurrentCwnd = 5 SettingsCurrentCwnd
SettingsDownloadRetransRate
SettingsInitialWindowSize
SettingsClientCretificateVectorSize
) )
// SettingsFlagIdValue is the unpacked, in-memory representation of the // SettingsFlagIdValue is the unpacked, in-memory representation of the
...@@ -256,73 +156,72 @@ type SettingsFrame struct { ...@@ -256,73 +156,72 @@ type SettingsFrame struct {
FlagIdValues []SettingsFlagIdValue FlagIdValues []SettingsFlagIdValue
} }
// NoopFrame is the unpacked, in-memory representation of a NOOP frame.
type NoopFrame struct {
CFHeader ControlFrameHeader
}
// PingFrame is the unpacked, in-memory representation of a PING frame. // PingFrame is the unpacked, in-memory representation of a PING frame.
type PingFrame struct { type PingFrame struct {
CFHeader ControlFrameHeader CFHeader ControlFrameHeader
Id uint32 Id uint32 // unique id for this ping, from server is even, from client is odd.
} }
// GoAwayStatus represents the status in a GoAwayFrame.
type GoAwayStatus uint32
const (
GoAwayOK GoAwayStatus = iota
GoAwayProtocolError
GoAwayInternalError
)
// GoAwayFrame is the unpacked, in-memory representation of a GOAWAY frame. // GoAwayFrame is the unpacked, in-memory representation of a GOAWAY frame.
type GoAwayFrame struct { type GoAwayFrame struct {
CFHeader ControlFrameHeader CFHeader ControlFrameHeader
LastGoodStreamId uint32 LastGoodStreamId StreamId // last stream id which was accepted by sender
Status GoAwayStatus
} }
// HeadersFrame is the unpacked, in-memory representation of a HEADERS frame. // HeadersFrame is the unpacked, in-memory representation of a HEADERS frame.
type HeadersFrame struct { type HeadersFrame struct {
CFHeader ControlFrameHeader CFHeader ControlFrameHeader
StreamId uint32 StreamId StreamId
Headers http.Header Headers http.Header
} }
// WindowUpdateFrame is the unpacked, in-memory representation of a
// WINDOW_UPDATE frame.
type WindowUpdateFrame struct {
CFHeader ControlFrameHeader
StreamId StreamId
DeltaWindowSize uint32 // additional number of bytes to existing window size
}
// TODO: Implement credential frame and related methods.
// DataFrame is the unpacked, in-memory representation of a DATA frame. // DataFrame is the unpacked, in-memory representation of a DATA frame.
type DataFrame struct { type DataFrame struct {
// Note, high bit is the "Control" bit. Should be 0 for data frames. // Note, high bit is the "Control" bit. Should be 0 for data frames.
StreamId uint32 StreamId StreamId
Flags DataFlags Flags DataFlags
Data []byte Data []byte // payload data of this frame
} }
// HeaderDictionary is the dictionary sent to the zlib compressor/decompressor.
// Even though the specification states there is no null byte at the end, Chrome sends it.
const HeaderDictionary = "optionsgetheadpostputdeletetrace" +
"acceptaccept-charsetaccept-encodingaccept-languageauthorizationexpectfromhost" +
"if-modified-sinceif-matchif-none-matchif-rangeif-unmodifiedsince" +
"max-forwardsproxy-authorizationrangerefererteuser-agent" +
"100101200201202203204205206300301302303304305306307400401402403404405406407408409410411412413414415416417500501502503504505" +
"accept-rangesageetaglocationproxy-authenticatepublicretry-after" +
"servervarywarningwww-authenticateallowcontent-basecontent-encodingcache-control" +
"connectiondatetrailertransfer-encodingupgradeviawarning" +
"content-languagecontent-lengthcontent-locationcontent-md5content-rangecontent-typeetagexpireslast-modifiedset-cookie" +
"MondayTuesdayWednesdayThursdayFridaySaturdaySunday" +
"JanFebMarAprMayJunJulAugSepOctNovDec" +
"chunkedtext/htmlimage/pngimage/jpgimage/gifapplication/xmlapplication/xhtmltext/plainpublicmax-age" +
"charset=iso-8859-1utf-8gzipdeflateHTTP/1.1statusversionurl\x00"
// A SPDY specific error. // A SPDY specific error.
type ErrorCode string type ErrorCode string
const ( const (
UnlowercasedHeaderName ErrorCode = "header was not lowercased" UnlowercasedHeaderName ErrorCode = "header was not lowercased"
DuplicateHeaders ErrorCode = "multiple headers with same name" DuplicateHeaders = "multiple headers with same name"
WrongCompressedPayloadSize ErrorCode = "compressed payload size was incorrect" WrongCompressedPayloadSize = "compressed payload size was incorrect"
UnknownFrameType ErrorCode = "unknown frame type" UnknownFrameType = "unknown frame type"
InvalidControlFrame ErrorCode = "invalid control frame" InvalidControlFrame = "invalid control frame"
InvalidDataFrame ErrorCode = "invalid data frame" InvalidDataFrame = "invalid data frame"
InvalidHeaderPresent ErrorCode = "frame contained invalid header" InvalidHeaderPresent = "frame contained invalid header"
ZeroStreamId ErrorCode = "stream id zero is disallowed" ZeroStreamId = "stream id zero is disallowed"
) )
// Error contains both the type of error and additional values. StreamId is 0 // Error contains both the type of error and additional values. StreamId is 0
// if Error is not associated with a stream. // if Error is not associated with a stream.
type Error struct { type Error struct {
Err ErrorCode Err ErrorCode
StreamId uint32 StreamId StreamId
} }
func (e *Error) Error() string { func (e *Error) Error() string {
...@@ -331,6 +230,7 @@ func (e *Error) Error() string { ...@@ -331,6 +230,7 @@ func (e *Error) Error() string {
var invalidReqHeaders = map[string]bool{ var invalidReqHeaders = map[string]bool{
"Connection": true, "Connection": true,
"Host": true,
"Keep-Alive": true, "Keep-Alive": true,
"Proxy-Connection": true, "Proxy-Connection": true,
"Transfer-Encoding": true, "Transfer-Encoding": true,
...@@ -339,6 +239,7 @@ var invalidReqHeaders = map[string]bool{ ...@@ -339,6 +239,7 @@ var invalidReqHeaders = map[string]bool{
var invalidRespHeaders = map[string]bool{ var invalidRespHeaders = map[string]bool{
"Connection": true, "Connection": true,
"Keep-Alive": true, "Keep-Alive": true,
"Proxy-Connection": true,
"Transfer-Encoding": true, "Transfer-Encoding": true,
} }
...@@ -360,7 +261,7 @@ type Framer struct { ...@@ -360,7 +261,7 @@ type Framer struct {
// buffered implementation to optimize performance. // buffered implementation to optimize performance.
func NewFramer(w io.Writer, r io.Reader) (*Framer, error) { func NewFramer(w io.Writer, r io.Reader) (*Framer, error) {
compressBuf := new(bytes.Buffer) compressBuf := new(bytes.Buffer)
compressor, err := zlib.NewWriterLevelDict(compressBuf, zlib.BestCompression, []byte(HeaderDictionary)) compressor, err := zlib.NewWriterLevelDict(compressBuf, zlib.BestCompression, []byte(headerDictionary))
if err != nil { if err != nil {
return nil, err return nil, err
} }
......
spdy/write.go
View file @ 10d81ae2
...@@ -25,15 +25,19 @@ func (frame *RstStreamFrame) write(f *Framer) (err error) { ...@@ -25,15 +25,19 @@ func (frame *RstStreamFrame) write(f *Framer) (err error) {
} }
frame.CFHeader.version = Version frame.CFHeader.version = Version
frame.CFHeader.frameType = TypeRstStream frame.CFHeader.frameType = TypeRstStream
frame.CFHeader.Flags = 0
frame.CFHeader.length = 8 frame.CFHeader.length = 8
// Serialize frame to Writer // Serialize frame to Writer.
if err = writeControlFrameHeader(f.w, frame.CFHeader); err != nil { if err = writeControlFrameHeader(f.w, frame.CFHeader); err != nil {
return return
} }
if err = binary.Write(f.w, binary.BigEndian, frame.StreamId); err != nil { if err = binary.Write(f.w, binary.BigEndian, frame.StreamId); err != nil {
return return
} }
if frame.Status == 0 {
return &Error{InvalidControlFrame, frame.StreamId}
}
if err = binary.Write(f.w, binary.BigEndian, frame.Status); err != nil { if err = binary.Write(f.w, binary.BigEndian, frame.Status); err != nil {
return return
} }
...@@ -45,7 +49,7 @@ func (frame *SettingsFrame) write(f *Framer) (err error) { ...@@ -45,7 +49,7 @@ func (frame *SettingsFrame) write(f *Framer) (err error) {
frame.CFHeader.frameType = TypeSettings frame.CFHeader.frameType = TypeSettings
frame.CFHeader.length = uint32(len(frame.FlagIdValues)*8 + 4) frame.CFHeader.length = uint32(len(frame.FlagIdValues)*8 + 4)
// Serialize frame to Writer // Serialize frame to Writer.
if err = writeControlFrameHeader(f.w, frame.CFHeader); err != nil { if err = writeControlFrameHeader(f.w, frame.CFHeader); err != nil {
return return
} }
...@@ -53,7 +57,7 @@ func (frame *SettingsFrame) write(f *Framer) (err error) { ...@@ -53,7 +57,7 @@ func (frame *SettingsFrame) write(f *Framer) (err error) {
return return
} }
for _, flagIdValue := range frame.FlagIdValues { for _, flagIdValue := range frame.FlagIdValues {
flagId := (uint32(flagIdValue.Flag) << 24) | uint32(flagIdValue.Id) flagId := uint32(flagIdValue.Flag)<<24 | uint32(flagIdValue.Id)
if err = binary.Write(f.w, binary.BigEndian, flagId); err != nil { if err = binary.Write(f.w, binary.BigEndian, flagId); err != nil {
return return
} }
...@@ -64,23 +68,16 @@ func (frame *SettingsFrame) write(f *Framer) (err error) { ...@@ -64,23 +68,16 @@ func (frame *SettingsFrame) write(f *Framer) (err error) {
return return
} }
func (frame *NoopFrame) write(f *Framer) error {
frame.CFHeader.version = Version
frame.CFHeader.frameType = TypeNoop
// Serialize frame to Writer
return writeControlFrameHeader(f.w, frame.CFHeader)
}
func (frame *PingFrame) write(f *Framer) (err error) { func (frame *PingFrame) write(f *Framer) (err error) {
if frame.Id == 0 { if frame.Id == 0 {
return &Error{ZeroStreamId, 0} return &Error{ZeroStreamId, 0}
} }
frame.CFHeader.version = Version frame.CFHeader.version = Version
frame.CFHeader.frameType = TypePing frame.CFHeader.frameType = TypePing
frame.CFHeader.Flags = 0
frame.CFHeader.length = 4 frame.CFHeader.length = 4
// Serialize frame to Writer // Serialize frame to Writer.
if err = writeControlFrameHeader(f.w, frame.CFHeader); err != nil { if err = writeControlFrameHeader(f.w, frame.CFHeader); err != nil {
return return
} }
...@@ -93,29 +90,46 @@ func (frame *PingFrame) write(f *Framer) (err error) { ...@@ -93,29 +90,46 @@ func (frame *PingFrame) write(f *Framer) (err error) {
func (frame *GoAwayFrame) write(f *Framer) (err error) { func (frame *GoAwayFrame) write(f *Framer) (err error) {
frame.CFHeader.version = Version frame.CFHeader.version = Version
frame.CFHeader.frameType = TypeGoAway frame.CFHeader.frameType = TypeGoAway
frame.CFHeader.length = 4 frame.CFHeader.Flags = 0
frame.CFHeader.length = 8
// Serialize frame to Writer // Serialize frame to Writer.
if err = writeControlFrameHeader(f.w, frame.CFHeader); err != nil { if err = writeControlFrameHeader(f.w, frame.CFHeader); err != nil {
return return
} }
if err = binary.Write(f.w, binary.BigEndian, frame.LastGoodStreamId); err != nil { if err = binary.Write(f.w, binary.BigEndian, frame.LastGoodStreamId); err != nil {
return return
} }
if err = binary.Write(f.w, binary.BigEndian, frame.Status); err != nil {
return
}
return nil return nil
} }
func (frame *HeadersFrame) write(f *Framer) error { func (frame *HeadersFrame) write(f *Framer) error {
if frame.StreamId == 0 {
return &Error{ZeroStreamId, 0}
}
return f.writeHeadersFrame(frame) return f.writeHeadersFrame(frame)
} }
func (frame *DataFrame) write(f *Framer) error { func (frame *WindowUpdateFrame) write(f *Framer) (err error) {
if frame.StreamId == 0 { frame.CFHeader.version = Version
return &Error{ZeroStreamId, 0} frame.CFHeader.frameType = TypeWindowUpdate
frame.CFHeader.Flags = 0
frame.CFHeader.length = 8
// Serialize frame to Writer.
if err = writeControlFrameHeader(f.w, frame.CFHeader); err != nil {
return
} }
if err = binary.Write(f.w, binary.BigEndian, frame.StreamId); err != nil {
return
}
if err = binary.Write(f.w, binary.BigEndian, frame.DeltaWindowSize); err != nil {
return
}
return nil
}
func (frame *DataFrame) write(f *Framer) error {
return f.writeDataFrame(frame) return f.writeDataFrame(frame)
} }
...@@ -131,7 +145,7 @@ func writeControlFrameHeader(w io.Writer, h ControlFrameHeader) error { ...@@ -131,7 +145,7 @@ func writeControlFrameHeader(w io.Writer, h ControlFrameHeader) error {
if err := binary.Write(w, binary.BigEndian, h.frameType); err != nil { if err := binary.Write(w, binary.BigEndian, h.frameType); err != nil {
return err return err
} }
flagsAndLength := (uint32(h.Flags) << 24) | h.length flagsAndLength := uint32(h.Flags)<<24 | h.length
if err := binary.Write(w, binary.BigEndian, flagsAndLength); err != nil { if err := binary.Write(w, binary.BigEndian, flagsAndLength); err != nil {
return err return err
} }
...@@ -140,12 +154,12 @@ func writeControlFrameHeader(w io.Writer, h ControlFrameHeader) error { ...@@ -140,12 +154,12 @@ func writeControlFrameHeader(w io.Writer, h ControlFrameHeader) error {
func writeHeaderValueBlock(w io.Writer, h http.Header) (n int, err error) { func writeHeaderValueBlock(w io.Writer, h http.Header) (n int, err error) {
n = 0 n = 0
if err = binary.Write(w, binary.BigEndian, uint16(len(h))); err != nil { if err = binary.Write(w, binary.BigEndian, uint32(len(h))); err != nil {
return return
} }
n += 2 n += 2
for name, values := range h { for name, values := range h {
if err = binary.Write(w, binary.BigEndian, uint16(len(name))); err != nil { if err = binary.Write(w, binary.BigEndian, uint32(len(name))); err != nil {
return return
} }
n += 2 n += 2
...@@ -154,8 +168,8 @@ func writeHeaderValueBlock(w io.Writer, h http.Header) (n int, err error) { ...@@ -154,8 +168,8 @@ func writeHeaderValueBlock(w io.Writer, h http.Header) (n int, err error) {
return return
} }
n += len(name) n += len(name)
v := strings.Join(values, "\x00") v := strings.Join(values, headerValueSeparator)
if err = binary.Write(w, binary.BigEndian, uint16(len(v))); err != nil { if err = binary.Write(w, binary.BigEndian, uint32(len(v))); err != nil {
return return
} }
n += 2 n += 2
...@@ -183,12 +197,12 @@ func (f *Framer) writeSynStreamFrame(frame *SynStreamFrame) (err error) { ...@@ -183,12 +197,12 @@ func (f *Framer) writeSynStreamFrame(frame *SynStreamFrame) (err error) {
f.headerCompressor.Flush() f.headerCompressor.Flush()
} }
// Set ControlFrameHeader // Set ControlFrameHeader.
frame.CFHeader.version = Version frame.CFHeader.version = Version
frame.CFHeader.frameType = TypeSynStream frame.CFHeader.frameType = TypeSynStream
frame.CFHeader.length = uint32(len(f.headerBuf.Bytes()) + 10) frame.CFHeader.length = uint32(len(f.headerBuf.Bytes()) + 10)
// Serialize frame to Writer // Serialize frame to Writer.
if err = writeControlFrameHeader(f.w, frame.CFHeader); err != nil { if err = writeControlFrameHeader(f.w, frame.CFHeader); err != nil {
return err return err
} }
...@@ -198,7 +212,10 @@ func (f *Framer) writeSynStreamFrame(frame *SynStreamFrame) (err error) { ...@@ -198,7 +212,10 @@ func (f *Framer) writeSynStreamFrame(frame *SynStreamFrame) (err error) {
if err = binary.Write(f.w, binary.BigEndian, frame.AssociatedToStreamId); err != nil { if err = binary.Write(f.w, binary.BigEndian, frame.AssociatedToStreamId); err != nil {
return err return err
} }
if err = binary.Write(f.w, binary.BigEndian, frame.Priority<<14); err != nil { if err = binary.Write(f.w, binary.BigEndian, frame.Priority<<5); err != nil {
return err
}
if err = binary.Write(f.w, binary.BigEndian, frame.Slot); err != nil {
return err return err
} }
if _, err = f.w.Write(f.headerBuf.Bytes()); err != nil { if _, err = f.w.Write(f.headerBuf.Bytes()); err != nil {
...@@ -224,21 +241,18 @@ func (f *Framer) writeSynReplyFrame(frame *SynReplyFrame) (err error) { ...@@ -224,21 +241,18 @@ func (f *Framer) writeSynReplyFrame(frame *SynReplyFrame) (err error) {
f.headerCompressor.Flush() f.headerCompressor.Flush()
} }
// Set ControlFrameHeader // Set ControlFrameHeader.
frame.CFHeader.version = Version frame.CFHeader.version = Version
frame.CFHeader.frameType = TypeSynReply frame.CFHeader.frameType = TypeSynReply
frame.CFHeader.length = uint32(len(f.headerBuf.Bytes()) + 6) frame.CFHeader.length = uint32(len(f.headerBuf.Bytes()) + 4)
// Serialize frame to Writer // Serialize frame to Writer.
if err = writeControlFrameHeader(f.w, frame.CFHeader); err != nil { if err = writeControlFrameHeader(f.w, frame.CFHeader); err != nil {
return return
} }
if err = binary.Write(f.w, binary.BigEndian, frame.StreamId); err != nil { if err = binary.Write(f.w, binary.BigEndian, frame.StreamId); err != nil {
return return
} }
if err = binary.Write(f.w, binary.BigEndian, uint16(0)); err != nil {
return
}
if _, err = f.w.Write(f.headerBuf.Bytes()); err != nil { if _, err = f.w.Write(f.headerBuf.Bytes()); err != nil {
return return
} }
...@@ -247,6 +261,9 @@ func (f *Framer) writeSynReplyFrame(frame *SynReplyFrame) (err error) { ...@@ -247,6 +261,9 @@ func (f *Framer) writeSynReplyFrame(frame *SynReplyFrame) (err error) {
} }
func (f *Framer) writeHeadersFrame(frame *HeadersFrame) (err error) { func (f *Framer) writeHeadersFrame(frame *HeadersFrame) (err error) {
if frame.StreamId == 0 {
return &Error{ZeroStreamId, 0}
}
// Marshal the headers. // Marshal the headers.
var writer io.Writer = f.headerBuf var writer io.Writer = f.headerBuf
if !f.headerCompressionDisabled { if !f.headerCompressionDisabled {
...@@ -259,21 +276,18 @@ func (f *Framer) writeHeadersFrame(frame *HeadersFrame) (err error) { ...@@ -259,21 +276,18 @@ func (f *Framer) writeHeadersFrame(frame *HeadersFrame) (err error) {
f.headerCompressor.Flush() f.headerCompressor.Flush()
} }
// Set ControlFrameHeader // Set ControlFrameHeader.
frame.CFHeader.version = Version frame.CFHeader.version = Version
frame.CFHeader.frameType = TypeHeaders frame.CFHeader.frameType = TypeHeaders
frame.CFHeader.length = uint32(len(f.headerBuf.Bytes()) + 6) frame.CFHeader.length = uint32(len(f.headerBuf.Bytes()) + 4)
// Serialize frame to Writer // Serialize frame to Writer.
if err = writeControlFrameHeader(f.w, frame.CFHeader); err != nil { if err = writeControlFrameHeader(f.w, frame.CFHeader); err != nil {
return return
} }
if err = binary.Write(f.w, binary.BigEndian, frame.StreamId); err != nil { if err = binary.Write(f.w, binary.BigEndian, frame.StreamId); err != nil {
return return
} }
if err = binary.Write(f.w, binary.BigEndian, uint16(0)); err != nil {
return
}
if _, err = f.w.Write(f.headerBuf.Bytes()); err != nil { if _, err = f.w.Write(f.headerBuf.Bytes()); err != nil {
return return
} }
...@@ -282,22 +296,23 @@ func (f *Framer) writeHeadersFrame(frame *HeadersFrame) (err error) { ...@@ -282,22 +296,23 @@ func (f *Framer) writeHeadersFrame(frame *HeadersFrame) (err error) {
} }
func (f *Framer) writeDataFrame(frame *DataFrame) (err error) { func (f *Framer) writeDataFrame(frame *DataFrame) (err error) {
// Validate DataFrame if frame.StreamId == 0 {
return &Error{ZeroStreamId, 0}
}
if frame.StreamId&0x80000000 != 0 || len(frame.Data) >= 0x0f000000 { if frame.StreamId&0x80000000 != 0 || len(frame.Data) >= 0x0f000000 {
return &Error{InvalidDataFrame, frame.StreamId} return &Error{InvalidDataFrame, frame.StreamId}
} }
// Serialize frame to Writer // Serialize frame to Writer.
if err = binary.Write(f.w, binary.BigEndian, frame.StreamId); err != nil { if err = binary.Write(f.w, binary.BigEndian, frame.StreamId); err != nil {
return return
} }
flagsAndLength := (uint32(frame.Flags) << 24) | uint32(len(frame.Data)) flagsAndLength := uint32(frame.Flags)<<24 | uint32(len(frame.Data))
if err = binary.Write(f.w, binary.BigEndian, flagsAndLength); err != nil { if err = binary.Write(f.w, binary.BigEndian, flagsAndLength); err != nil {
return return
} }
if _, err = f.w.Write(frame.Data); err != nil { if _, err = f.w.Write(frame.Data); err != nil {
return return
} }
return nil return nil
} }
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment