Add options to customize limits

Guard against oversized SPDY frames

Signed-off-by: Davanum Srinivas <davanum@gmail.com>
Signed-off-by: Sebastiaan van Stijn <github@gone.nl>

Author: dims

connection.go

@@ -224,7 +224,13 @@ type Connection struct {
 // NewConnection creates a new spdy connection from an existing
 // network connection.
 func NewConnection(conn net.Conn, server bool) (*Connection, error) {
-	framer, framerErr := spdy.NewFramer(conn, conn)
+	return NewConnectionWithOptions(conn, server)
+}
+
+// NewConnectionWithOptions creates a new spdy connection and applies frame
+// parsing limits via options.
+func NewConnectionWithOptions(conn net.Conn, server bool, opts ...spdy.FramerOption) (*Connection, error) {
+	framer, framerErr := spdy.NewFramerWithOptions(conn, conn, opts...)
 	if framerErr != nil {
 		return nil, framerErr
 	}

spdy/options.go

@@ -0,0 +1,25 @@
+package spdy
+
+// FramerOption allows callers to customize frame parsing limits.
+type FramerOption func(*Framer)
+
+// WithMaxControlFramePayloadSize sets the control-frame payload limit.
+func WithMaxControlFramePayloadSize(size uint32) FramerOption {
+	return func(f *Framer) {
+		f.maxFrameLength = size
+	}
+}
+
+// WithMaxHeaderFieldSize sets the per-header name/value size limit.
+func WithMaxHeaderFieldSize(size uint32) FramerOption {
+	return func(f *Framer) {
+		f.maxHeaderFieldSize = size
+	}
+}
+
+// WithMaxHeaderCount sets the maximum number of headers in a frame.
+func WithMaxHeaderCount(count uint32) FramerOption {
+	return func(f *Framer) {
+		f.maxHeaderCount = count
+	}
+}

spdy/options_test.go

@@ -0,0 +1,33 @@
+package spdy
+
+import (
+	"net"
+	"testing"
+)
+
+func TestNewFramerWithOptions(t *testing.T) {
+	serverConn, clientConn := net.Pipe()
+	defer func() {
+		_ = clientConn.Close()
+		_ = serverConn.Close()
+	}()
+
+	framer, err := NewFramerWithOptions(clientConn, clientConn,
+		WithMaxControlFramePayloadSize(1024),
+		WithMaxHeaderFieldSize(128),
+		WithMaxHeaderCount(16),
+	)
+	if err != nil {
+		t.Fatalf("Error creating spdy connection with options: %s", err)
+	}
+
+	if got := framer.maxFrameLength; got != 1024 {
+		t.Fatalf("Unexpected MaxControlFramePayloadSize: %d", got)
+	}
+	if got := framer.maxHeaderFieldSize; got != 128 {
+		t.Fatalf("Unexpected MaxHeaderFieldSize: %d", got)
+	}
+	if got := framer.maxHeaderCount; got != 16 {
+		t.Fatalf("Unexpected MaxHeaderCount: %d", got)
+	}
+}

spdy/types.go

@@ -278,6 +278,16 @@ type Framer struct {
 // from/to the Reader and Writer, so the caller should pass in an appropriately
 // buffered implementation to optimize performance.
 func NewFramer(w io.Writer, r io.Reader) (*Framer, error) {
+	return newFramer(w, r)
+}
+
+// NewFramerWithOptions allocates a new Framer for a given SPDY connection and
+// applies frame parsing limits via options.
+func NewFramerWithOptions(w io.Writer, r io.Reader, opts ...FramerOption) (*Framer, error) {
+	return newFramer(w, r, opts...)
+}
+
+func newFramer(w io.Writer, r io.Reader, opts ...FramerOption) (*Framer, error) {
 	compressBuf := new(bytes.Buffer)
 	compressor, err := zlib.NewWriterLevelDict(compressBuf, zlib.BestCompression, []byte(headerDictionary))
 	if err != nil {
@@ -289,5 +299,10 @@ func NewFramer(w io.Writer, r io.Reader) (*Framer, error) {
 		headerCompressor: compressor,
 		r:                r,
 	}
+	for _, opt := range opts {
+		if opt != nil {
+			opt(framer)
+		}
+	}
 	return framer, nil
 }

spdy_test.go

@@ -174,6 +174,25 @@ func TestSpdyStreams(t *testing.T) {
 	wg.Wait()
 }
 
+func TestNewConnectionWithOptions(t *testing.T) {
+	serverConn, clientConn := net.Pipe()
+	defer func() {
+		_ = clientConn.Close()
+		_ = serverConn.Close()
+	}()
+
+	_, err := NewConnectionWithOptions(
+		clientConn,
+		false,
+		spdy.WithMaxControlFramePayloadSize(1024),
+		spdy.WithMaxHeaderFieldSize(128),
+		spdy.WithMaxHeaderCount(16),
+	)
+	if err != nil {
+		t.Fatalf("Error creating spdy connection with options: %s", err)
+	}
+}
+
 func TestPing(t *testing.T) {
 	var wg sync.WaitGroup
 	server, listen, serverErr := runServer(&wg)