[net] x/net/http2: Respect peer's SETTINGS_MAX_HEADER_LIST

Mike Appleby (Gerrit)

unread,

Sep 15, 2016, 7:42:32 PM9/15/16

to Ian Lance Taylor, golang-co...@googlegroups.com

Mike Appleby uploaded a change:
https://go-review.googlesource.com/29243

x/net/http2: Respect peer's SETTINGS_MAX_HEADER_LIST_SIZE in ClientConn.

Add a new PeerMaxHeaderListSize() method to ClientConn which reports the
SETTINGS_MAX_HEADER_LIST_SIZE requested by the client's peer, and
respect this limit in (*ClientConn) encodeHeaders / encodeTrailers.

Attempting to send more than PeerMaxHeaderListSize bytes of headers or
trailers will result in RoundTrip returning errRequestHeaderListSize.

Updates golang/go#13959

Change-Id: Ic707179782acdf8ae543429ea1af7f4f30e67e59
---
M http2/http2.go
M http2/transport.go
M http2/transport_test.go
M http2/write.go
4 files changed, 319 insertions(+), 43 deletions(-)

diff --git a/http2/http2.go b/http2/http2.go
index 2e27b09..ae8ef10 100644
--- a/http2/http2.go
+++ b/http2/http2.go
@@ -22,6 +22,7 @@
"errors"
"fmt"
"io"
+ "log"
"net/http"
"os"
"sort"
@@ -69,6 +70,13 @@
initialWindowSize = 65535 // 6.9.2 Initial Flow Control Window Size

defaultMaxReadFrameSize = 1 << 20
+
+ // MaxHeaderListSizeUnlimited represents the "unlimited" value
+ // for SETTINGS_MAX_HEADER_LIST_SIZE. On the wire, the
+ // unlimited value is represented as 0. Within the Go APIs,
+ // the zero value is sometimes used to provide a more sensible
+ // default, so "unlimited" is represented here as UINT32_MAX.
+ MaxHeaderListSizeUnlimited = 0xffffffff
)

var (
@@ -363,3 +371,9 @@
func validPseudoPath(v string) bool {
return (len(v) > 0 && v[0] == '/' && (len(v) == 1 || v[1] != '/')) || v
== "*"
}
+
+func logHeader(from, name, value string) {
+ if VerboseLogs {
+ log.Printf("http2: %s encoding header %q = %q", from, name, value)
+ }
+}
diff --git a/http2/transport.go b/http2/transport.go
index 42c73bd..c89f7cc 100644
--- a/http2/transport.go
+++ b/http2/transport.go
@@ -85,11 +85,10 @@

// MaxHeaderListSize is the http2 SETTINGS_MAX_HEADER_LIST_SIZE to
// send in the initial settings frame. It is how many bytes
- // of response headers are allow. Unlike the http2 spec, zero here
+ // of response headers are allowed. Unlike the http2 spec, zero here
// means to use a default limit (currently 10MB). If you actually
- // want to advertise an ulimited value to the peer, Transport
- // interprets the highest possible value here (0xffffffff or 1<<32-1)
- // to mean no limit.
+ // want to advertise an ulimited value to the peer, set this to
+ // MaxHeaderListSizeUnlimited.
MaxHeaderListSize uint32

// t1, if non-nil, is the standard library Transport using
@@ -105,7 +104,7 @@
if t.MaxHeaderListSize == 0 {
return 10 << 20
}
- if t.MaxHeaderListSize == 0xffffffff {
+ if t.MaxHeaderListSize == MaxHeaderListSizeUnlimited {
return 0
}
return t.MaxHeaderListSize
@@ -165,9 +164,10 @@
fr *Framer
lastActive time.Time
// Settings from peer: (also guarded by mu)
- maxFrameSize uint32
- maxConcurrentStreams uint32
- initialWindowSize uint32
+ maxFrameSize uint32
+ maxConcurrentStreams uint32
+ peerMaxHeaderListSize uint32
+ initialWindowSize uint32

hbuf bytes.Buffer // HPACK encoder writes into this
henc *hpack.Encoder
@@ -934,7 +934,11 @@
if hasTrailers {
cc.mu.Lock()
defer cc.mu.Unlock()
- trls = cc.encodeTrailers(req)
+ trls, err = cc.encodeTrailers(req)
+ if err != nil {
+ cc.writeStreamReset(cs.ID, ErrCodeInternal, err)
+ return err
+ }
}

cc.wmu.Lock()
@@ -987,6 +991,17 @@
}
}

+// PeerMaxHeaderListSize returns the SETTINGS_MAX_HEADER_LIST_SIZE
+// requested by the client's peer. The default value of zero means
+// "unlimited", and is represented here as MaxHeaderListSizeUnlimited,
+// i.e. UINT32_MAX. See also Transport.MaxHeaderListSize.
+func (cc *ClientConn) PeerMaxHeaderListSize() uint32 {
+ if cc.peerMaxHeaderListSize == 0 {
+ return MaxHeaderListSizeUnlimited
+ }
+ return cc.peerMaxHeaderListSize
+}
+
type badStringError struct {
what string
str string
@@ -1023,33 +1038,20 @@
}
}

- // Check for any invalid headers and return an error before we
- // potentially pollute our hpack state. (We want to be able to
- // continue to reuse the hpack encoder for future requests)
- for k, vv := range req.Header {
- if !httplex.ValidHeaderFieldName(k) {
- return nil, fmt.Errorf("invalid HTTP header name %q", k)
- }
- for _, v := range vv {
- if !httplex.ValidHeaderFieldValue(v) {
- return nil, fmt.Errorf("invalid HTTP header value %q for header %q",
v, k)
- }
- }
- }
-
// 8.1.2.3 Request Pseudo-Header Fields
// The :path pseudo-header field includes the path and query parts of the
// target URI (the path-absolute production and optionally a '?' character
// followed by the query production (see Sections 3.3 and 3.4 of
// [RFC3986]).
- cc.writeHeader(":authority", host)
- cc.writeHeader(":method", req.Method)
+ hl := hpack.HeaderList{}
+ hl.Append(":authority", host)
+ hl.Append(":method", req.Method)
if req.Method != "CONNECT" {
- cc.writeHeader(":path", path)
- cc.writeHeader(":scheme", "https")
+ hl.Append(":path", path)
+ hl.Append(":scheme", "https")
}
if trailers != "" {
- cc.writeHeader("trailer", trailers)
+ hl.Append("trailer", trailers)
}

var didUA bool
@@ -1079,20 +1081,31 @@
if vv[0] == "" {
continue
}
+ default:
+ if !httplex.ValidHeaderFieldName(lowKey) {
+ return nil, fmt.Errorf("invalid HTTP header name %q", lowKey)
+ }
}
for _, v := range vv {
- cc.writeHeader(lowKey, v)
+ if !httplex.ValidHeaderFieldValue(v) {
+ return nil, fmt.Errorf("invalid HTTP header value %q for header %q",
v, lowKey)
+ }
+ hl.Append(lowKey, v)
}
}
if shouldSendReqContentLength(req.Method, contentLength) {
- cc.writeHeader("content-length", strconv.FormatInt(contentLength, 10))
+ hl.Append("content-length", strconv.FormatInt(contentLength, 10))
}
if addGzipHeader {
- cc.writeHeader("accept-encoding", "gzip")
+ hl.Append("accept-encoding", "gzip")
}
if !didUA {
- cc.writeHeader("user-agent", defaultUserAgent)
+ hl.Append("user-agent", defaultUserAgent)
}
+ if hl.Size() > cc.PeerMaxHeaderListSize() {
+ return nil, errRequestHeaderListSize
+ }
+ cc.writeHeaderList(hl)
return cc.hbuf.Bytes(), nil
}

@@ -1119,24 +1132,28 @@
}

// requires cc.mu be held.
-func (cc *ClientConn) encodeTrailers(req *http.Request) []byte {
+func (cc *ClientConn) encodeTrailers(req *http.Request) ([]byte, error) {
cc.hbuf.Reset()
+ hl := hpack.HeaderList{}
for k, vv := range req.Trailer {
// Transfer-Encoding, etc.. have already been filter at the
// start of RoundTrip
lowKey := strings.ToLower(k)
for _, v := range vv {
- cc.writeHeader(lowKey, v)
+ hl.Append(lowKey, v)
}
}
- return cc.hbuf.Bytes()
+ if hl.Size() > cc.PeerMaxHeaderListSize() {
+ return nil, errRequestHeaderListSize
+ }
+ return cc.hbuf.Bytes(), nil
}

-func (cc *ClientConn) writeHeader(name, value string) {
- if VerboseLogs {
- log.Printf("http2: Transport encoding header %q = %q", name, value)
+func (cc *ClientConn) writeHeaderList(hl hpack.HeaderList) {
+ for _, hf := range hl.Fields() {
+ logHeader("transport", hf.Name, hf.Value)
+ cc.henc.WriteField(hf)
}
- cc.henc.WriteField(hpack.HeaderField{Name: name, Value: value})
}

type resAndError struct {
@@ -1734,6 +1751,8 @@
cc.maxFrameSize = s.Val
case SettingMaxConcurrentStreams:
cc.maxConcurrentStreams = s.Val
+ case SettingMaxHeaderListSize:
+ cc.peerMaxHeaderListSize = s.Val
case SettingInitialWindowSize:
// Values above the maximum flow-control
// window size of 2^31-1 MUST be treated as a
@@ -1854,6 +1873,7 @@

var (
errResponseHeaderListSize = errors.New("http2: response header list
larger than advertised limit")
+ errRequestHeaderListSize = errors.New("http2: request header list larger
than peer's advertised limit")
errPseudoTrailers = errors.New("http2: invalid pseudo header in
trailers")
)

diff --git a/http2/transport_test.go b/http2/transport_test.go
index 96d0a08..df1edb5 100644
--- a/http2/transport_test.go
+++ b/http2/transport_test.go
@@ -16,6 +16,7 @@
"math/rand"
"net"
"net/http"
+ "net/http/httptest"
"net/url"
"os"
"reflect"
@@ -1315,6 +1316,250 @@
ct.run()
}

+// topUpHeadersKey is the name of a key which the topUpHeaders
+// function uses for the last few bytes of filler. See comments for
+// topUpHeaders, below.
+const topUpHeadersKey = "Top-Up"
+
+// topUpHeaders adds data to an http.Header until hl.Size() == limit. Due
+// to the way HeaderField sizes are calculated, topUpHeaders cannot add
+// fewer than len(topUpHeadersKey) + 32 bytes to hl, and will call t.Fatal
+// if asked to do so. TopUpHeaders adds as many copies of filler as
+// possible. Any remaining bytes necessary to push hl.Size() up to limit
+// are added to h[topUpHeadersKey]. Thus, the caller can later delete
+// topUpHeadersKey from the header to return it to a state that contains
+// fewer than limit bytes.
+func topUpHeaders(t *testing.T, h http.Header, hl *hpack.HeaderList, limit
uint32, filler string) {
+ emptyTopUp := hpack.HeaderField{
+ Name: topUpHeadersKey,
+ Value: "",
+ }
+ minTopUpSize := emptyTopUp.Size()
+
+ minlimit := hl.Size() + minTopUpSize
+ if limit < minlimit {
+ t.Fatalf("topUpHeaders: limit %v < %v", limit, minlimit)
+ }
+
+ // Use a fixed-width format for name so that fieldSize
+ // remains constant.
+ nameFmt := "Top-Up-Filler-%06d"
+ hf := hpack.HeaderField{
+ Name: fmt.Sprintf(nameFmt, 1),
+ Value: filler,
+ }
+ fieldSize := hf.Size()
+
+ // Add as many complete filler values as possible, leaving
+ // room for at least one empty topUpHeaders key.
+ limit = limit - minTopUpSize
+ for i := 0; hl.Size()+fieldSize < limit; i++ {
+ name := fmt.Sprintf(nameFmt, i)
+ h.Add(name, filler)
+ hl.Append(name, filler)
+ }
+
+ // Add enough bytes to reach limit.
+ remain := limit - hl.Size()
+ lastValue := strings.Repeat("*", int(remain))
+ h.Add(topUpHeadersKey, lastValue)
+ hl.Append(topUpHeadersKey, lastValue)
+}
+
+// Probably a bad sign when your tests need tests...
+func TestTopUpHeaders(t *testing.T) {
+ check := func(h http.Header, hl *hpack.HeaderList, limit uint32, flen
int) {
+ if h == nil {
+ h = make(http.Header)
+ }
+ if hl == nil {
+ hl = new(hpack.HeaderList)
+ }
+ filler := strings.Repeat("v", flen)
+ topUpHeaders(t, h, hl, limit, filler)
+ if hl.Size() != limit {
+ t.Errorf("hl.Size() = %v; want %v", hl.Size(), limit)
+ }
+ }
+ // Try all possible combinations for small flen and limit.
+ minLimit := uint32(len(topUpHeadersKey) + 32)
+ for flen := 0; flen <= 10; flen++ {
+ for limit := minLimit; limit <= 128; limit++ {
+ check(nil, nil, limit, flen)
+ }
+ }
+
+ // Try a few with a larger limits, plus cumulative tests.
+ tests := []struct {
+ flen int
+ limit uint32
+ }{
+ {
+ flen: 64,
+ limit: 1024,
+ },
+ {
+ flen: 1024,
+ limit: 1286,
+ },
+ {
+ flen: 256,
+ limit: 2048,
+ },
+ {
+ flen: 1024,
+ limit: 10 * 1024,
+ },
+ {
+ flen: 1024,
+ limit: 100 * 1024,
+ },
+ }
+ h := make(http.Header)
+ hl := new(hpack.HeaderList)
+ for _, tc := range tests {
+ check(nil, nil, tc.limit, tc.flen)
+ check(h, hl, tc.limit, tc.flen)
+ }
+}
+
+func TestTransportChecksRequestHeaderListSize(t *testing.T) {
+ const kb = 1 << 10
+ const responseBody = "hi"
+ st := newServerTester(t,
+ func(w http.ResponseWriter, r *http.Request) {
+ io.WriteString(w, responseBody)
+ },
+ func(ts *httptest.Server) {
+ ts.Config.MaxHeaderBytes = 500 * kb
+ },
+ optOnlyServer,
+ optQuiet,
+ )
+ defer st.Close()
+
+ tr := &Transport{TLSClientConfig: tlsConfigInsecure}
+ defer tr.CloseIdleConnections()
+
+ // Body must be non-nil to enable writing trailers.
+ body := strings.NewReader("hello")
+ req, err := http.NewRequest("GET", st.ts.URL, body)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ // Get the ClientConn associated with this request so we can
+ // validate it's PeerMaxHeaderListSize.
+ addr := authorityAddr(req.URL.Scheme, req.URL.Host)
+ cc, err := tr.connPool().GetClientConn(req, addr)
+ if err != nil {
+ t.Errorf("Failed to get ClientConn. Err = %v", err)
+ }
+
+ if cc.PeerMaxHeaderListSize() != MaxHeaderListSizeUnlimited {
+ t.Errorf("PeerMaxHeaderListSize = %v; want %v",
cc.PeerMaxHeaderListSize(), MaxHeaderListSizeUnlimited)
+ }
+
+ checkResponseOK := func(res *http.Response, desc string) {
+ if res == nil {
+ t.Errorf("%v: response nil; want non-nil.", desc)
+ return
+ }
+ defer res.Body.Close()
+ if res.StatusCode != http.StatusOK {
+ t.Errorf("%v: response status = %v; want %v", desc, res.StatusCode,
http.StatusOK)
+ }
+ body, err := ioutil.ReadAll(res.Body)
+ if err != nil {
+ t.Errorf("%v: error reading response body: %v", desc, err)
+ }
+ if string(body) != responseBody {
+ t.Errorf("%v: response body = %q; want %q", desc, body, responseBody)
+ }
+ }
+ checkRoundTrip := func(req *http.Request, expectErr error, desc string) {
+ res, err := tr.RoundTrip(req)
+ if err != expectErr {
+ if res != nil {
+ res.Body.Close()
+ }
+ t.Errorf("%v: RoundTrip err = %v; want %v", desc, err, expectErr)
+ return
+ }
+ if err == nil {
+ checkResponseOK(res, desc)
+ return
+ }
+ if res != nil {
+ t.Errorf("%v: RoundTrip err = %v but response non-nil", desc, err)
+ }
+ }
+
+ // Make an arbitrary request, just to get the server's settings
+ // frame and initialize PeerMaxHeaderListSize.
+ checkRoundTrip(req, nil, "Initial request")
+
+ // PeerMaxHeaderListSize should now be set to the value
+ // requested by our peer.
+ peerSize := cc.PeerMaxHeaderListSize()
+ wantSize := st.sc.maxHeaderListSize()
+ if peerSize != wantSize {
+ t.Errorf("PeerMaxHeaderListSize = %v; want %v", peerSize, wantSize)
+ }
+
+ // Sanity check peerSize. It should be close to the limit we
+ // set for MaxHeaderBytes, above.
+ if peerSize > uint32(kb+st.ts.Config.MaxHeaderBytes) {
+ t.Errorf("PeerMaxHeaderListSize = %v is unexpectedly large.", peerSize)
+ }
+
+ // Fill trailers right up to the limit.
+ filler := strings.Repeat("*", kb)
+ tl := new(hpack.HeaderList)
+ req.Trailer = make(http.Header)
+ topUpHeaders(t, req.Trailer, tl, peerSize, filler)
+
+ // Fill headers. The transport sets a handful of default
+ // headers for us, so we need to leave room for those, plus
+ // the size of the "trailer" field that will be added for us.
+ trailers, err := commaSeparatedTrailers(req)
+ if err != nil {
+ t.Errorf("Unable to generate trailers list. Err = %v", err)
+ }
+ trailerField := hpack.HeaderField{
+ Name: "trailer",
+ Value: trailers,
+ }
+ trailerSize := trailerField.Size()
+ hl := new(hpack.HeaderList)
+ topUpHeaders(t, req.Header, hl, peerSize-trailerSize-400, filler)
+ checkRoundTrip(req, nil, "Headers & Trailers under limit")
+
+ // Add enough header bytes to push us over peerSize.
+ topUpHeaders(t, req.Header, hl, peerSize-trailerSize, filler)
+ checkRoundTrip(req, errRequestHeaderListSize, "Headers over limit")
+
+ // Delete some bytes from header. Request should now succeed.
+ req.Header.Del(topUpHeadersKey)
+ checkRoundTrip(req, nil, "Headers back under limit")
+
+ // Push trailers one byte over the limit.
+ tl = new(hpack.HeaderList)
+ req.Trailer = make(http.Header)
+ topUpHeaders(t, req.Trailer, tl, peerSize+1, filler)
+ checkRoundTrip(req, errRequestHeaderListSize, "Trailers over limit")
+
+ // Send headers/trailers with a single large value.
+ req.Header = make(http.Header)
+ req.Trailer = make(http.Header)
+ filler = strings.Repeat("*", int(peerSize))
+ req.Header.Set("Big", filler)
+ checkRoundTrip(req, errRequestHeaderListSize, "Single large header")
+ req.Header.Del("Big")
+ req.Trailer.Set("Big", filler)
+ checkRoundTrip(req, errRequestHeaderListSize, "Single large trailer")
+}
+
func TestTransportChecksResponseHeaderListSize(t *testing.T) {
ct := newClientTester(t)
ct.client = func() error {
diff --git a/http2/write.go b/http2/write.go
index 27ef0dd..6aa18a6 100644
--- a/http2/write.go
+++ b/http2/write.go
@@ -7,7 +7,6 @@
import (
"bytes"
"fmt"
- "log"
"net/http"
"time"

@@ -138,9 +137,7 @@
}

func encKV(enc *hpack.Encoder, k, v string) {
- if VerboseLogs {
- log.Printf("http2: server encoding header %q = %q", k, v)
- }
+ logHeader("server", k, v)
enc.WriteField(hpack.HeaderField{Name: k, Value: v})
}

--
https://go-review.googlesource.com/29243

Mike Appleby (Gerrit)

unread,

Sep 15, 2016, 8:03:06 PM9/15/16

to golang-co...@googlegroups.com

Mike Appleby has posted comments on this change.

x/net/http2: Respect peer's SETTINGS_MAX_HEADER_LIST_SIZE in ClientConn.

Patch Set 1:

(1 comment)

https://go-review.googlesource.com/#/c/29243/1/http2/transport.go
File http2/transport.go:

Line 1000: return MaxHeaderListSizeUnlimited
I did this for symmetry with how Transport.MaxHeaderListSize is handled. We
could just as well return the unmodified value here, and leave it up to the
caller to interpret 0 as "unlimited." The downside of doing it this way is
that if the peer requests a limit of UINT32_MAX bytes, the client will not
be able to distinguish that from "unlimited."

--
https://go-review.googlesource.com/29243
Gerrit-Reviewer: Mike Appleby <mi...@app.leby.org>
Gerrit-HasComments: Yes

Mike Appleby (Gerrit)

unread,

Sep 18, 2016, 2:58:20 PM9/18/16

to golang-co...@googlegroups.com

Mike Appleby uploaded a new patch set:

https://go-review.googlesource.com/29243

x/net/http2: Respect peer's SETTINGS_MAX_HEADER_LIST_SIZE in ClientConn.

Add a new PeerMaxHeaderListSize() method to ClientConn which reports the
SETTINGS_MAX_HEADER_LIST_SIZE requested by the client's peer, and
respect this limit in (*ClientConn) encodeHeaders / encodeTrailers.

Attempting to send more than PeerMaxHeaderListSize bytes of headers or
trailers will result in RoundTrip returning errRequestHeaderListSize.

Updates golang/go#13959

Change-Id: Ic707179782acdf8ae543429ea1af7f4f30e67e59
---
M http2/http2.go
M http2/transport.go
M http2/transport_test.go

3 files changed, 389 insertions(+), 37 deletions(-)

Mike Appleby (Gerrit)

unread,

Sep 18, 2016, 3:16:19 PM9/18/16

to golang-co...@googlegroups.com

Mike Appleby has posted comments on this change.

x/net/http2: Respect peer's SETTINGS_MAX_HEADER_LIST_SIZE in ClientConn.

Patch Set 3:

(2 comments)

Benchcmp results comparing patch set 3 and patch set 1 to tip.

https://gist.github.com/appleby/cf50bc81fa87f0bbbf1b483628200cd0

Patch set 3 trades a little readability and cpu for a reduction in bytes
allocated vs. patch set 1.

Unfortunately, patch set 3 actually increases the total number of
allocations due to the need to normalize header keys when checking to
see if the caller provided a user-agent header. See my comment in
transport.go for more info.

https://go-review.googlesource.com/#/c/29243/3/http2/transport.go

File http2/transport.go:

Line 1000: return MaxHeaderListSizeUnlimited

Copy/pasting a comment from patch set 1:

I did this for symmetry with how Transport.MaxHeaderListSize is handled. We
could just as well return the unmodified value here, and leave it up to the

caller to interpret 0 as "unlimited." The downside of returning
MaxHeaderListSizeUnlimited here is that if the peer requests a limit of

UINT32_MAX bytes, the client will not be able to distinguish that
from "unlimited."

Line 1083: if strings.ToLower(k) == "user-agent" {
If we replace this line with something like

if k == "User-Agent" || k == "user-agent" {

we can reduce allocations further at the cost of being wrong when
req.Header contains something weird like "uSeR-aGeNt".

The allocations here are small and the bytes are ephemeral, and in the
common case where req.Header contains only a few headers, the cost is
small, so I opted for correctness & compatibility with the previous
behavior over shaving the allocations down further. Mentioning it here in
case we don't care about odd cases.

The result of being wrong here is that we would encode the user-agent
header twice, first with the value the caller provided in req.Header, and
then again with our default value from postHeaders.

Benchmp results showing the effect of avoiding normalization here:

https://gist.github.com/appleby/b3e47d78b4252d0611ba75c8277bfbf5

--
https://go-review.googlesource.com/29243
Gerrit-Reviewer: Mike Appleby <mi...@app.leby.org>

Gerrit-HasComments: Yes

Mike Appleby (Gerrit)

unread,

Sep 22, 2016, 2:35:27 PM9/22/16

to golang-co...@googlegroups.com

Mike Appleby uploaded a new patch set:
https://go-review.googlesource.com/29243

http2: Respect peer's SETTINGS_MAX_HEADER_LIST_SIZE in ClientConn.

Add a new PeerMaxHeaderListSize() method to ClientConn which reports the
SETTINGS_MAX_HEADER_LIST_SIZE requested by the client's peer, and
respect this limit in (*ClientConn) encodeHeaders / encodeTrailers.

Attempting to send more than PeerMaxHeaderListSize bytes of headers or
trailers will result in RoundTrip returning errRequestHeaderListSize.

Updates golang/go#13959

Change-Id: Ic707179782acdf8ae543429ea1af7f4f30e67e59
---
M http2/http2.go
M http2/transport.go
M http2/transport_test.go

3 files changed, 389 insertions(+), 37 deletions(-)

Mike Appleby (Gerrit)

unread,

Sep 22, 2016, 2:42:11 PM9/22/16

to golang-co...@googlegroups.com

Mike Appleby has posted comments on this change.

http2: Respect peer's SETTINGS_MAX_HEADER_LIST_SIZE in ClientConn.

Patch Set 4:

Patch set 4 is just a rebase onto the latest commits in master. I also
changed the package tagline in the commit message from x/net/http2 to just
http2.

--
https://go-review.googlesource.com/29243
Gerrit-Reviewer: Mike Appleby <mi...@app.leby.org>

Gerrit-HasComments: No

Mike Appleby (Gerrit)

unread,

Oct 1, 2016, 3:40:25 PM10/1/16

to golang-co...@googlegroups.com

Mike Appleby uploaded a new patch set:
https://go-review.googlesource.com/29243

http2: Respect peer's SETTINGS_MAX_HEADER_LIST_SIZE in ClientConn.

Add a new PeerMaxHeaderListSize() method to ClientConn which reports the
SETTINGS_MAX_HEADER_LIST_SIZE requested by the client's peer, and
respect this limit in (*ClientConn) encodeHeaders / encodeTrailers.

Attempting to send more than PeerMaxHeaderListSize bytes of headers or
trailers will result in RoundTrip returning errRequestHeaderListSize.

Updates golang/go#13959

Change-Id: Ic707179782acdf8ae543429ea1af7f4f30e67e59
---
M http2/http2.go
M http2/transport.go
M http2/transport_test.go

3 files changed, 389 insertions(+), 37 deletions(-)

Mike Appleby (Gerrit)

unread,

Oct 1, 2016, 3:52:14 PM10/1/16

to golang-co...@googlegroups.com

Mike Appleby uploaded a new patch set:
https://go-review.googlesource.com/29243

http2: Respect peer's SETTINGS_MAX_HEADER_LIST_SIZE in ClientConn

Add a new PeerMaxHeaderListSize() method to ClientConn which reports the
SETTINGS_MAX_HEADER_LIST_SIZE requested by the client's peer, and
respect this limit in (*ClientConn) encodeHeaders / encodeTrailers.

Attempting to send more than PeerMaxHeaderListSize bytes of headers or
trailers will result in RoundTrip returning errRequestHeaderListSize.

Updates golang/go#13959

Change-Id: Ic707179782acdf8ae543429ea1af7f4f30e67e59
---
M http2/http2.go
M http2/transport.go
M http2/transport_test.go

Mike Appleby (Gerrit)

unread,

Oct 1, 2016, 3:57:10 PM10/1/16

to golang-co...@googlegroups.com

Mike Appleby has posted comments on this change.

http2: Respect peer's SETTINGS_MAX_HEADER_LIST_SIZE in ClientConn

Patch Set 6:

Patch set 5 was a rebase onto master.

Patch set 6 fixes formatting of the commit message, and changes the request
type in the test from GET to POST. For the purposes of the test, the
request does not matter, and it's weird to include a body and trailers in a
GET request.

--
https://go-review.googlesource.com/29243
Gerrit-Reviewer: Mike Appleby <mi...@app.leby.org>

Gerrit-HasComments: No

Brad Fitzpatrick (Gerrit)

unread,

Nov 2, 2016, 1:59:02 AM11/2/16

to Mike Appleby, golang-co...@googlegroups.com, Brad Fitzpatrick

Brad Fitzpatrick posted comments on http2: Respect peer's SETTINGS_MAX_HEADER_LIST_SIZE in ClientConn.

[net] x/net/http2: Respect peer's SETTINGS_MAX_HEADER_LIST_SIZE in ClientConn.

Mike Appleby (Gerrit)

Mike Appleby (Gerrit)

Mike Appleby (Gerrit)

Mike Appleby (Gerrit)

Mike Appleby (Gerrit)

Mike Appleby (Gerrit)

Mike Appleby (Gerrit)

Mike Appleby (Gerrit)

Mike Appleby (Gerrit)

Brad Fitzpatrick (Gerrit)

Mike Appleby (Gerrit)

Brad Fitzpatrick (Gerrit)

Mike Appleby (Gerrit)

Mike Appleby (Gerrit)

Brad Fitzpatrick (Gerrit)

Mike Appleby (Gerrit)

Mike Appleby (Gerrit)

Mike Appleby (Gerrit)

Mike Appleby (Gerrit)

Brad Fitzpatrick (Gerrit)

Mike Appleby (Gerrit)

Mike Appleby (Gerrit)

Mike Appleby (Gerrit)

Mike Appleby (Gerrit)

Tom Bergan (Gerrit)

Mike Appleby (Gerrit)

Tom Bergan (Gerrit)

Mike Appleby (Gerrit)

Mike Appleby (Gerrit)

Mike Appleby (Gerrit)

Mike Appleby (Gerrit)

Tom Bergan (Gerrit)

Tom Bergan (Gerrit)

Mike Appleby (Gerrit)

Tom Bergan (Gerrit)

Mike Appleby (Gerrit)

Mike Appleby (Gerrit)

Tom Bergan (Gerrit)

Gobot Gobot (Gerrit)

Gobot Gobot (Gerrit)

Mike Appleby (Gerrit)

Tom Bergan (Gerrit)

Mike Appleby (Gerrit)

Tom Bergan (Gerrit)

Mike Appleby (Gerrit)

Mike Appleby (Gerrit)

Mike Appleby (Gerrit)

Tom Bergan (Gerrit)

Gobot Gobot (Gerrit)

Gobot Gobot (Gerrit)

Mike Appleby (Gerrit)

Tom Bergan (Gerrit)

Mike Appleby (Gerrit)

Mike Appleby (Gerrit)

Tom Bergan (Gerrit)

Gobot Gobot (Gerrit)

Gobot Gobot (Gerrit)

Mike Appleby (Gerrit)

Tom Bergan (Gerrit)

Mike Appleby (Gerrit)

Tom Bergan (Gerrit)

Gobot Gobot (Gerrit)

Mike Appleby (Gerrit)

Gobot Gobot (Gerrit)

Tom Bergan (Gerrit)

Tom Bergan (Gerrit)