Fix deflate extension negotation

nhooyr · nhooyr · commit 0fb0a6b6e1f5 · 2020-02-16T02:39:18.000-05:00
diff --git a/accept.go b/accept.go
@@ -209,7 +209,7 @@ func acceptCompression(r *http.Request, w http.ResponseWriter, mode CompressionM
 
 func acceptDeflate(w http.ResponseWriter, ext websocketExtension, mode CompressionMode) (*compressionOptions, error) {
 	copts := mode.opts()
-	copts.serverMaxWindowBits = 8
+	copts.serverMaxWindowBits = 13
 
 	for _, p := range ext.params {
 		switch p {
@@ -222,26 +222,30 @@ func acceptDeflate(w http.ResponseWriter, ext websocketExtension, mode Compressi
 		}
 
 		if strings.HasPrefix(p, "client_max_window_bits") {
+			if p == "client_max_window_bits" {
+				copts.clientMaxWindowBits = 15
+				continue
+			}
+			bits, ok := parseExtensionParameter(p)
+			if !ok || bits < 8 || bits > 16 {
+				err := fmt.Errorf("invalid client_max_window_bits: %q", p)
+				http.Error(w, err.Error(), http.StatusBadRequest)
+				return nil, err
+			}
+			copts.clientMaxWindowBits = bits
 			continue
-
-			// bits, ok := parseExtensionParameter(p, 15)
-			// if !ok || bits < 8 || bits > 16 {
-			// 	err := fmt.Errorf("invalid client_max_window_bits: %q", p)
-			// 	http.Error(w, err.Error(), http.StatusBadRequest)
-			// 	return nil, err
-			// }
-			// copts.clientMaxWindowBits = bits
-			// continue
 		}
 
-		if false && strings.HasPrefix(p, "server_max_window_bits") {
-			// We always send back 8 but make sure to validate.
-			bits, ok := parseExtensionParameter(p, 0)
+		if strings.HasPrefix(p, "server_max_window_bits") {
+			bits, ok := parseExtensionParameter(p)
 			if !ok || bits < 8 || bits > 16 {
 				err := fmt.Errorf("invalid server_max_window_bits: %q", p)
 				http.Error(w, err.Error(), http.StatusBadRequest)
 				return nil, err
 			}
+			if copts.serverMaxWindowBits > bits {
+				copts.serverMaxWindowBits = bits
+			}
 			continue
 		}
 
@@ -256,14 +260,9 @@ func acceptDeflate(w http.ResponseWriter, ext websocketExtension, mode Compressi
 }
 
 // parseExtensionParameter parses the value in the extension parameter p.
-// It falls back to defaultVal if there is no value.
-// If defaultVal == 0, then ok == false if there is no value.
-func parseExtensionParameter(p string, defaultVal int) (int, bool) {
+func parseExtensionParameter(p string) (int, bool) {
 	ps := strings.Split(p, "=")
 	if len(ps) == 1 {
-		if defaultVal > 0 {
-			return defaultVal, true
-		}
 		return 0, false
 	}
 	i, e := strconv.Atoi(strings.Trim(ps[1], `"`))
diff --git a/accept_test.go b/accept_test.go
@@ -323,11 +323,12 @@ func Test_acceptCompression(t *testing.T) {
 			name:                       "permessage-deflate",
 			mode:                       CompressionNoContextTakeover,
 			reqSecWebSocketExtensions:  "permessage-deflate; client_max_window_bits",
-			respSecWebSocketExtensions: "permessage-deflate; client_no_context_takeover; server_no_context_takeover",
+			respSecWebSocketExtensions: "permessage-deflate; client_no_context_takeover; server_no_context_takeover; server_max_window_bits=8; client_max_window_bits=15",
 			expCopts: &compressionOptions{
 				clientNoContextTakeover: true,
 				serverNoContextTakeover: true,
 				serverMaxWindowBits:     8,
+				clientMaxWindowBits: 15,
 			},
 		},
 		{
diff --git a/autobahn_test.go b/autobahn_test.go
@@ -28,6 +28,7 @@ var excludedAutobahnCases = []string{
 
 	// We skip the tests related to requestMaxWindowBits as that is unimplemented due
 	// to limitations in compress/flate. See https://github.com/golang/go/issues/3155
+	// Same with klauspost/compress which doesn't allow adjusting the sliding window size.
 	"13.3.*", "13.4.*", "13.5.*", "13.6.*",
 }
 
diff --git a/compress_notjs.go b/compress_notjs.go
@@ -34,10 +34,10 @@ func (copts *compressionOptions) setHeader(h http.Header) {
 	if copts.serverNoContextTakeover {
 		s += "; server_no_context_takeover"
 	}
-	if false && copts.serverMaxWindowBits > 0 {
+	if copts.serverMaxWindowBits > 0 {
 		s += fmt.Sprintf("; server_max_window_bits=%v", copts.serverMaxWindowBits)
 	}
-	if false && copts.clientMaxWindowBits > 0 {
+	if copts.clientMaxWindowBits > 0 {
 		s += fmt.Sprintf("; client_max_window_bits=%v", copts.clientMaxWindowBits)
 	}
 	h.Set("Sec-WebSocket-Extensions", s)
@@ -147,6 +147,10 @@ func (sw *slidingWindow) init(n int) {
 		return
 	}
 
+	if n == 0 {
+		n = 32768
+	}
+
 	p := slidingWindowPool(n)
 	buf, ok := p.Get().([]byte)
 	if ok {
diff --git a/dial.go b/dial.go
@@ -82,7 +82,13 @@ func dial(ctx context.Context, urls string, opts *DialOptions, rand io.Reader) (
 		return nil, nil, fmt.Errorf("failed to generate Sec-WebSocket-Key: %w", err)
 	}
 
-	resp, err := handshakeRequest(ctx, urls, opts, secWebSocketKey)
+	var copts *compressionOptions
+	if opts.CompressionMode != CompressionDisabled {
+		copts = opts.CompressionMode.opts()
+		copts.clientMaxWindowBits = 13
+	}
+
+	resp, err := handshakeRequest(ctx, urls, opts, copts, secWebSocketKey)
 	if err != nil {
 		return nil, resp, err
 	}
@@ -104,7 +110,7 @@ func dial(ctx context.Context, urls string, opts *DialOptions, rand io.Reader) (
 		}
 	}()
 
-	copts, err := verifyServerResponse(opts, secWebSocketKey, resp)
+	err = verifyServerResponse(opts, copts, secWebSocketKey, resp)
 	if err != nil {
 		return nil, resp, err
 	}
@@ -125,7 +131,7 @@ func dial(ctx context.Context, urls string, opts *DialOptions, rand io.Reader) (
 	}), resp, nil
 }
 
-func handshakeRequest(ctx context.Context, urls string, opts *DialOptions, secWebSocketKey string) (*http.Response, error) {
+func handshakeRequest(ctx context.Context, urls string, opts *DialOptions, copts *compressionOptions, secWebSocketKey string) (*http.Response, error) {
 	if opts.HTTPClient.Timeout > 0 {
 		return nil, errors.New("use context for cancellation instead of http.Client.Timeout; see https://github.com/nhooyr/websocket/issues/67")
 	}
@@ -153,9 +159,7 @@ func handshakeRequest(ctx context.Context, urls string, opts *DialOptions, secWe
 	if len(opts.Subprotocols) > 0 {
 		req.Header.Set("Sec-WebSocket-Protocol", strings.Join(opts.Subprotocols, ","))
 	}
-	if opts.CompressionMode != CompressionDisabled {
-		copts := opts.CompressionMode.opts()
-		copts.clientMaxWindowBits = 8
+	if copts != nil {
 		copts.setHeader(req.Header)
 	}
 
@@ -178,32 +182,32 @@ func secWebSocketKey(rr io.Reader) (string, error) {
 	return base64.StdEncoding.EncodeToString(b), nil
 }
 
-func verifyServerResponse(opts *DialOptions, secWebSocketKey string, resp *http.Response) (*compressionOptions, error) {
+func verifyServerResponse(opts *DialOptions, copts *compressionOptions, secWebSocketKey string, resp *http.Response) error {
 	if resp.StatusCode != http.StatusSwitchingProtocols {
-		return nil, fmt.Errorf("expected handshake response status code %v but got %v", http.StatusSwitchingProtocols, resp.StatusCode)
+		return fmt.Errorf("expected handshake response status code %v but got %v", http.StatusSwitchingProtocols, resp.StatusCode)
 	}
 
 	if !headerContainsToken(resp.Header, "Connection", "Upgrade") {
-		return nil, fmt.Errorf("WebSocket protocol violation: Connection header %q does not contain Upgrade", resp.Header.Get("Connection"))
+		return fmt.Errorf("WebSocket protocol violation: Connection header %q does not contain Upgrade", resp.Header.Get("Connection"))
 	}
 
 	if !headerContainsToken(resp.Header, "Upgrade", "WebSocket") {
-		return nil, fmt.Errorf("WebSocket protocol violation: Upgrade header %q does not contain websocket", resp.Header.Get("Upgrade"))
+		return fmt.Errorf("WebSocket protocol violation: Upgrade header %q does not contain websocket", resp.Header.Get("Upgrade"))
 	}
 
 	if resp.Header.Get("Sec-WebSocket-Accept") != secWebSocketAccept(secWebSocketKey) {
-		return nil, fmt.Errorf("WebSocket protocol violation: invalid Sec-WebSocket-Accept %q, key %q",
+		return fmt.Errorf("WebSocket protocol violation: invalid Sec-WebSocket-Accept %q, key %q",
 			resp.Header.Get("Sec-WebSocket-Accept"),
 			secWebSocketKey,
 		)
 	}
 
 	err := verifySubprotocol(opts.Subprotocols, resp)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
-	return verifyServerExtensions(resp.Header)
+	return verifyServerExtensions(copts, resp.Header)
 }
 
 func verifySubprotocol(subprotos []string, resp *http.Response) error {
@@ -221,19 +225,20 @@ func verifySubprotocol(subprotos []string, resp *http.Response) error {
 	return fmt.Errorf("WebSocket protocol violation: unexpected Sec-WebSocket-Protocol from server: %q", proto)
 }
 
-func verifyServerExtensions(h http.Header) (*compressionOptions, error) {
+func verifyServerExtensions(copts *compressionOptions, h http.Header) error {
 	exts := websocketExtensions(h)
 	if len(exts) == 0 {
-		return nil, nil
+		return nil
 	}
 
 	ext := exts[0]
-	if ext.name != "permessage-deflate" || len(exts) > 1 {
-		return nil, fmt.Errorf("WebSocket protcol violation: unsupported extensions from server: %+v", exts[1:])
+	if ext.name != "permessage-deflate" || len(exts) > 1 || copts == nil {
+		return fmt.Errorf("WebSocket protcol violation: unsupported extensions from server: %+v", exts[1:])
 	}
 
-	copts := &compressionOptions{}
-	copts.clientMaxWindowBits = 8
+	// Let the server decide its context takeover.
+	copts.serverNoContextTakeover = false
+
 	for _, p := range ext.params {
 		switch p {
 		case "client_no_context_takeover":
@@ -244,28 +249,30 @@ func verifyServerExtensions(h http.Header) (*compressionOptions, error) {
 			continue
 		}
 
-		if false && strings.HasPrefix(p, "server_max_window_bits") {
-			bits, ok := parseExtensionParameter(p, 0)
+		if strings.HasPrefix(p, "server_max_window_bits") {
+			bits, ok := parseExtensionParameter(p)
 			if !ok || bits < 8 || bits > 16 {
-				return nil, fmt.Errorf("invalid server_max_window_bits: %q", p)
+				return fmt.Errorf("invalid server_max_window_bits: %q", p)
 			}
 			copts.serverMaxWindowBits = bits
 			continue
 		}
 
-		if false && strings.HasPrefix(p, "client_max_window_bits") {
-			bits, ok := parseExtensionParameter(p, 0)
+		if strings.HasPrefix(p, "client_max_window_bits") {
+			bits, ok := parseExtensionParameter(p)
 			if !ok || bits < 8 || bits > 16 {
-				return nil, fmt.Errorf("invalid client_max_window_bits: %q", p)
+				return fmt.Errorf("invalid client_max_window_bits: %q", p)
+			}
+			if copts.clientMaxWindowBits > bits {
+				copts.clientMaxWindowBits = bits
 			}
-			copts.clientMaxWindowBits = 8
 			continue
 		}
 
-		return nil, fmt.Errorf("unsupported permessage-deflate parameter: %q", p)
+		return fmt.Errorf("unsupported permessage-deflate parameter: %q", p)
 	}
 
-	return copts, nil
+	return nil
 }
 
 var readerPool sync.Pool
diff --git a/dial_test.go b/dial_test.go
@@ -221,7 +221,7 @@ func Test_verifyServerHandshake(t *testing.T) {
 			opts := &DialOptions{
 				Subprotocols: strings.Split(r.Header.Get("Sec-WebSocket-Protocol"), ","),
 			}
-			_, err = verifyServerResponse(opts, key, resp)
+			err = verifyServerResponse(opts, opts.CompressionMode.opts(), key, resp)
 			if tc.success {
 				assert.Success(t, err)
 			} else {
diff --git a/read.go b/read.go
@@ -88,9 +88,16 @@ func newMsgReader(c *Conn) *msgReader {
 	return mr
 }
 
+func (mr *msgReader) maxWindowBits() int {
+	if mr.c.client {
+		return mr.c.copts.serverMaxWindowBits
+	}
+	return mr.c.copts.clientMaxWindowBits
+}
+
 func (mr *msgReader) resetFlate() {
 	if mr.flateContextTakeover() {
-		mr.dict.init(32768)
+		mr.dict.init(pow(2, mr.maxWindowBits()))
 	}
 	if mr.flateBufio == nil {
 		mr.flateBufio = getBufioReader(mr.readFunc)
diff --git a/write.go b/write.go
@@ -10,6 +10,7 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"math"
 	"sync"
 	"time"
 
@@ -89,17 +90,28 @@ func newMsgWriterState(c *Conn) *msgWriterState {
 	return mw
 }
 
+func (mw *msgWriterState) maxWindowBits() int {
+	if mw.c.client {
+		return mw.c.copts.clientMaxWindowBits
+	}
+	return mw.c.copts.serverMaxWindowBits
+}
+
 func (mw *msgWriterState) ensureFlate() {
 	if mw.trimWriter == nil {
 		mw.trimWriter = &trimLastFourBytesWriter{
 			w: writerFunc(mw.write),
 		}
 	}
 
-	mw.dict.init(8192)
+	mw.dict.init(pow(2, mw.maxWindowBits()))
 	mw.flate = true
 }
 
+func pow(x, y int) int {
+	return int(math.Pow(float64(x), float64(y)))
+}
+
 func (mw *msgWriterState) flateContextTakeover() bool {
 	if mw.c.client {
 		return !mw.c.copts.clientNoContextTakeover

Original file line number	Diff line number	Diff line change
`@@ -28,6 +28,7 @@ var excludedAutobahnCases = []string{`
`28`	`28`
`29`	`29`	`// We skip the tests related to requestMaxWindowBits as that is unimplemented due`
`30`	`30`	`// to limitations in compress/flate. See https://github.com/golang/go/issues/3155`
	`31`	`+ // Same with klauspost/compress which doesn't allow adjusting the sliding window size.`
`31`	`32`	`"13.3.", "13.4.", "13.5.", "13.6.",`
`32`	`33`	`}`
`33`	`34`
Original file line number	Diff line number	Diff line change
`@@ -34,10 +34,10 @@ func (copts *compressionOptions) setHeader(h http.Header) {`
`34`	`34`	`if copts.serverNoContextTakeover {`
`35`	`35`	`s += "; server_no_context_takeover"`
`36`	`36`	`}`
`37`		`- if false && copts.serverMaxWindowBits > 0 {`
	`37`	`+ if copts.serverMaxWindowBits > 0 {`
`38`	`38`	`s += fmt.Sprintf("; server_max_window_bits=%v", copts.serverMaxWindowBits)`
`39`	`39`	`}`
`40`		`- if false && copts.clientMaxWindowBits > 0 {`
	`40`	`+ if copts.clientMaxWindowBits > 0 {`
`41`	`41`	`s += fmt.Sprintf("; client_max_window_bits=%v", copts.clientMaxWindowBits)`
`42`	`42`	`}`
`43`	`43`	`h.Set("Sec-WebSocket-Extensions", s)`
`@@ -147,6 +147,10 @@ func (sw *slidingWindow) init(n int) {`
`147`	`147`	`return`
`148`	`148`	`}`
`149`	`149`
	`150`	`+ if n == 0 {`
	`151`	`+ n = 32768`
	`152`	`+ }`
	`153`	`+`
`150`	`154`	`p := slidingWindowPool(n)`
`151`	`155`	`buf, ok := p.Get().([]byte)`
`152`	`156`	`if ok {`
Original file line number	Diff line number	Diff line change
`@@ -82,7 +82,13 @@ func dial(ctx context.Context, urls string, opts *DialOptions, rand io.Reader) (`
`82`	`82`	`return nil, nil, fmt.Errorf("failed to generate Sec-WebSocket-Key: %w", err)`
`83`	`83`	`}`
`84`	`84`
`85`		`- resp, err := handshakeRequest(ctx, urls, opts, secWebSocketKey)`
	`85`	`+ var copts *compressionOptions`
	`86`	`+ if opts.CompressionMode != CompressionDisabled {`
	`87`	`+ copts = opts.CompressionMode.opts()`
	`88`	`+ copts.clientMaxWindowBits = 13`
	`89`	`+ }`
	`90`	`+`
	`91`	`+ resp, err := handshakeRequest(ctx, urls, opts, copts, secWebSocketKey)`
`86`	`92`	`if err != nil {`
`87`	`93`	`return nil, resp, err`
`88`	`94`	`}`
`@@ -104,7 +110,7 @@ func dial(ctx context.Context, urls string, opts *DialOptions, rand io.Reader) (`
`104`	`110`	`}`
`105`	`111`	`}()`
`106`	`112`
`107`		`- copts, err := verifyServerResponse(opts, secWebSocketKey, resp)`
	`113`	`+ err = verifyServerResponse(opts, copts, secWebSocketKey, resp)`
`108`	`114`	`if err != nil {`
`109`	`115`	`return nil, resp, err`
`110`	`116`	`}`
`@@ -125,7 +131,7 @@ func dial(ctx context.Context, urls string, opts *DialOptions, rand io.Reader) (`
`125`	`131`	`}), resp, nil`
`126`	`132`	`}`
`127`	`133`
`128`		`-func handshakeRequest(ctx context.Context, urls string, opts DialOptions, secWebSocketKey string) (http.Response, error) {`
	`134`	`+func handshakeRequest(ctx context.Context, urls string, opts DialOptions, copts compressionOptions, secWebSocketKey string) (*http.Response, error) {`
`129`	`135`	`if opts.HTTPClient.Timeout > 0 {`
`130`	`136`	`return nil, errors.New("use context for cancellation instead of http.Client.Timeout; see https://github.com/nhooyr/websocket/issues/67")`
`131`	`137`	`}`
`@@ -153,9 +159,7 @@ func handshakeRequest(ctx context.Context, urls string, opts *DialOptions, secWe`
`153`	`159`	`if len(opts.Subprotocols) > 0 {`
`154`	`160`	`req.Header.Set("Sec-WebSocket-Protocol", strings.Join(opts.Subprotocols, ","))`
`155`	`161`	`}`
`156`		`- if opts.CompressionMode != CompressionDisabled {`
`157`		`- copts := opts.CompressionMode.opts()`
`158`		`- copts.clientMaxWindowBits = 8`
	`162`	`+ if copts != nil {`
`159`	`163`	`copts.setHeader(req.Header)`
`160`	`164`	`}`
`161`	`165`
`@@ -178,32 +182,32 @@ func secWebSocketKey(rr io.Reader) (string, error) {`
`178`	`182`	`return base64.StdEncoding.EncodeToString(b), nil`
`179`	`183`	`}`
`180`	`184`
`181`		`-func verifyServerResponse(opts DialOptions, secWebSocketKey string, resp http.Response) (*compressionOptions, error) {`
	`185`	`+func verifyServerResponse(opts DialOptions, copts compressionOptions, secWebSocketKey string, resp *http.Response) error {`
`182`	`186`	`if resp.StatusCode != http.StatusSwitchingProtocols {`
`183`		`- return nil, fmt.Errorf("expected handshake response status code %v but got %v", http.StatusSwitchingProtocols, resp.StatusCode)`
	`187`	`+ return fmt.Errorf("expected handshake response status code %v but got %v", http.StatusSwitchingProtocols, resp.StatusCode)`
`184`	`188`	`}`
`185`	`189`
`186`	`190`	`if !headerContainsToken(resp.Header, "Connection", "Upgrade") {`
`187`		`- return nil, fmt.Errorf("WebSocket protocol violation: Connection header %q does not contain Upgrade", resp.Header.Get("Connection"))`
	`191`	`+ return fmt.Errorf("WebSocket protocol violation: Connection header %q does not contain Upgrade", resp.Header.Get("Connection"))`
`188`	`192`	`}`
`189`	`193`
`190`	`194`	`if !headerContainsToken(resp.Header, "Upgrade", "WebSocket") {`
`191`		`- return nil, fmt.Errorf("WebSocket protocol violation: Upgrade header %q does not contain websocket", resp.Header.Get("Upgrade"))`
	`195`	`+ return fmt.Errorf("WebSocket protocol violation: Upgrade header %q does not contain websocket", resp.Header.Get("Upgrade"))`
`192`	`196`	`}`
`193`	`197`
`194`	`198`	`if resp.Header.Get("Sec-WebSocket-Accept") != secWebSocketAccept(secWebSocketKey) {`
`195`		`- return nil, fmt.Errorf("WebSocket protocol violation: invalid Sec-WebSocket-Accept %q, key %q",`
	`199`	`+ return fmt.Errorf("WebSocket protocol violation: invalid Sec-WebSocket-Accept %q, key %q",`
`196`	`200`	`resp.Header.Get("Sec-WebSocket-Accept"),`
`197`	`201`	`secWebSocketKey,`
`198`	`202`	`)`
`199`	`203`	`}`
`200`	`204`
`201`	`205`	`err := verifySubprotocol(opts.Subprotocols, resp)`
`202`	`206`	`if err != nil {`
`203`		`- return nil, err`
	`207`	`+ return err`
`204`	`208`	`}`
`205`	`209`
`206`		`- return verifyServerExtensions(resp.Header)`
	`210`	`+ return verifyServerExtensions(copts, resp.Header)`
`207`	`211`	`}`
`208`	`212`
`209`	`213`	`func verifySubprotocol(subprotos []string, resp *http.Response) error {`
`@@ -221,19 +225,20 @@ func verifySubprotocol(subprotos []string, resp *http.Response) error {`
`221`	`225`	`return fmt.Errorf("WebSocket protocol violation: unexpected Sec-WebSocket-Protocol from server: %q", proto)`
`222`	`226`	`}`
`223`	`227`
`224`		`-func verifyServerExtensions(h http.Header) (*compressionOptions, error) {`
	`228`	`+func verifyServerExtensions(copts *compressionOptions, h http.Header) error {`
`225`	`229`	`exts := websocketExtensions(h)`
`226`	`230`	`if len(exts) == 0 {`
`227`		`- return nil, nil`
	`231`	`+ return nil`
`228`	`232`	`}`
`229`	`233`
`230`	`234`	`ext := exts[0]`
`231`		`- if ext.name != "permessage-deflate" \|\| len(exts) > 1 {`
`232`		`- return nil, fmt.Errorf("WebSocket protcol violation: unsupported extensions from server: %+v", exts[1:])`
	`235`	`+ if ext.name != "permessage-deflate" \|\| len(exts) > 1 \|\| copts == nil {`
	`236`	`+ return fmt.Errorf("WebSocket protcol violation: unsupported extensions from server: %+v", exts[1:])`
`233`	`237`	`}`
`234`	`238`
`235`		`- copts := &compressionOptions{}`
`236`		`- copts.clientMaxWindowBits = 8`
	`239`	`+ // Let the server decide its context takeover.`
	`240`	`+ copts.serverNoContextTakeover = false`
	`241`	`+`
`237`	`242`	`for _, p := range ext.params {`
`238`	`243`	`switch p {`
`239`	`244`	`case "client_no_context_takeover":`
`@@ -244,28 +249,30 @@ func verifyServerExtensions(h http.Header) (*compressionOptions, error) {`
`244`	`249`	`continue`
`245`	`250`	`}`
`246`	`251`
`247`		`- if false && strings.HasPrefix(p, "server_max_window_bits") {`
`248`		`- bits, ok := parseExtensionParameter(p, 0)`
	`252`	`+ if strings.HasPrefix(p, "server_max_window_bits") {`
	`253`	`+ bits, ok := parseExtensionParameter(p)`
`249`	`254`	`if !ok \|\| bits < 8 \|\| bits > 16 {`
`250`		`- return nil, fmt.Errorf("invalid server_max_window_bits: %q", p)`
	`255`	`+ return fmt.Errorf("invalid server_max_window_bits: %q", p)`
`251`	`256`	`}`
`252`	`257`	`copts.serverMaxWindowBits = bits`
`253`	`258`	`continue`
`254`	`259`	`}`
`255`	`260`
`256`		`- if false && strings.HasPrefix(p, "client_max_window_bits") {`
`257`		`- bits, ok := parseExtensionParameter(p, 0)`
	`261`	`+ if strings.HasPrefix(p, "client_max_window_bits") {`
	`262`	`+ bits, ok := parseExtensionParameter(p)`
`258`	`263`	`if !ok \|\| bits < 8 \|\| bits > 16 {`
`259`		`- return nil, fmt.Errorf("invalid client_max_window_bits: %q", p)`
	`264`	`+ return fmt.Errorf("invalid client_max_window_bits: %q", p)`
	`265`	`+ }`
	`266`	`+ if copts.clientMaxWindowBits > bits {`
	`267`	`+ copts.clientMaxWindowBits = bits`
`260`	`268`	`}`
`261`		`- copts.clientMaxWindowBits = 8`
`262`	`269`	`continue`
`263`	`270`	`}`
`264`	`271`
`265`		`- return nil, fmt.Errorf("unsupported permessage-deflate parameter: %q", p)`
	`272`	`+ return fmt.Errorf("unsupported permessage-deflate parameter: %q", p)`
`266`	`273`	`}`
`267`	`274`
`268`		`- return copts, nil`
	`275`	`+ return nil`
`269`	`276`	`}`
`270`	`277`
`271`	`278`	`var readerPool sync.Pool`
Original file line number	Diff line number	Diff line change
`@@ -221,7 +221,7 @@ func Test_verifyServerHandshake(t *testing.T) {`
`221`	`221`	`opts := &DialOptions{`
`222`	`222`	`Subprotocols: strings.Split(r.Header.Get("Sec-WebSocket-Protocol"), ","),`
`223`	`223`	`}`
`224`		`- _, err = verifyServerResponse(opts, key, resp)`
	`224`	`+ err = verifyServerResponse(opts, opts.CompressionMode.opts(), key, resp)`
`225`	`225`	`if tc.success {`
`226`	`226`	`assert.Success(t, err)`
`227`	`227`	`} else {`