Upgrade to go 1.19 and update dependencies (#3069)

* Update to go 1.19
* Update dependencies
* Update cross-compile script
* Add missing targets to cross-compile-all
* Update cache action to remove warning

vendor/github.com/gobwas/ws/README.md

@@ -358,7 +358,7 @@ Extension][rfc-pmce].
 
 It provides minimalistic I/O wrappers to be used in conjunction with any
 deflate implementation (for example, the standard library's
-[compress/flate][compress/flate].
+[compress/flate][compress/flate]).
 
 It is also compatible with `wsutil`'s reader and writer by providing
 `wsflate.MessageState` type, which implements `wsutil.SendExtension` and
@@ -453,6 +453,84 @@ func main() {
 }
 ```
 
+You can use compression with `wsutil` package this way:
+
+```go
+	// Upgrade somehow and negotiate compression to get the conn...
+
+	// Initialize flate reader. We are using nil as a source io.Reader because
+	// we will Reset() it in the message i/o loop below.
+	fr := wsflate.NewReader(nil, func(r io.Reader) wsflate.Decompressor {
+		return flate.NewReader(r)
+	})
+	// Initialize flate writer. We are using nil as a destination io.Writer
+	// because we will Reset() it in the message i/o loop below.
+	fw := wsflate.NewWriter(nil, func(w io.Writer) wsflate.Compressor {
+		f, _ := flate.NewWriter(w, 9)
+		return f
+	})
+
+	// Declare compression message state variable.
+	//
+	// It has two goals:
+	// - Allow users to check whether received message is compressed or not.
+	// - Help wsutil.Reader and wsutil.Writer to set/unset appropriate
+	//   WebSocket header bits while writing next frame to the wire (it
+	//   implements wsutil.RecvExtension and wsutil.SendExtension).
+	var msg wsflate.MessageState
+
+	// Initialize WebSocket reader as previously. 
+	// Please note the use of Reader.Extensions field as well as
+	// of ws.StateExtended flag.
+	rd := &wsutil.Reader{
+		Source:     conn,
+		State:      ws.StateServerSide | ws.StateExtended,
+		Extensions: []wsutil.RecvExtension{
+			&msg, 
+		},
+	}
+
+	// Initialize WebSocket writer with ws.StateExtended flag as well.
+	wr := wsutil.NewWriter(conn, ws.StateServerSide|ws.StateExtended, 0)
+	// Use the message state as wsutil.SendExtension.
+	wr.SetExtensions(&msg)
+
+	for {
+		h, err := rd.NextFrame()
+		if err != nil {
+			// handle error.
+		}
+		if h.OpCode.IsControl() {
+			// handle control frame.
+		}
+		if !msg.IsCompressed() {
+			// handle uncompressed frame (skipped for the sake of example
+			// simplicity).
+		}
+
+		// Reset the writer to echo same op code.
+		wr.Reset(h.OpCode)
+
+		// Reset both flate reader and writer to start the new round of i/o.
+		fr.Reset(rd)
+		fw.Reset(wr)
+
+		// Copy whole message from reader to writer decompressing it and
+		// compressing again.
+		if _, err := io.Copy(fw, fr); err != nil {
+			// handle error.
+		}
+		// Flush any remaining buffers from flate writer to WebSocket writer.
+		if err := fw.Close(); err != nil {
+			// handle error.
+		}
+		// Flush the whole WebSocket message to the wire.
+		if err := wr.Flush(); err != nil {
+			// handle error.
+		}
+	}
+```
+
 
 [rfc-url]: https://tools.ietf.org/html/rfc6455
 [rfc-pmce]: https://tools.ietf.org/html/rfc7692#section-7

vendor/github.com/gobwas/ws/errors.go

@@ -2,12 +2,12 @@ package ws
 
 // RejectOption represents an option used to control the way connection is
 // rejected.
-type RejectOption func(*rejectConnectionError)
+type RejectOption func(*ConnectionRejectedError)
 
 // RejectionReason returns an option that makes connection to be rejected with
 // given reason.
 func RejectionReason(reason string) RejectOption {
-	return func(err *rejectConnectionError) {
+	return func(err *ConnectionRejectedError) {
 		err.reason = reason
 	}
 }
@@ -15,7 +15,7 @@ func RejectionReason(reason string) RejectOption {
 // RejectionStatus returns an option that makes connection to be rejected with
 // given HTTP status code.
 func RejectionStatus(code int) RejectOption {
-	return func(err *rejectConnectionError) {
+	return func(err *ConnectionRejectedError) {
 		err.code = code
 	}
 }
@@ -23,32 +23,37 @@ func RejectionStatus(code int) RejectOption {
 // RejectionHeader returns an option that makes connection to be rejected with
 // given HTTP headers.
 func RejectionHeader(h HandshakeHeader) RejectOption {
-	return func(err *rejectConnectionError) {
+	return func(err *ConnectionRejectedError) {
 		err.header = h
 	}
 }
 
-// RejectConnectionError constructs an error that could be used to control the way
-// handshake is rejected by Upgrader.
+// RejectConnectionError constructs an error that could be used to control the
+// way handshake is rejected by Upgrader.
 func RejectConnectionError(options ...RejectOption) error {
-	err := new(rejectConnectionError)
+	err := new(ConnectionRejectedError)
 	for _, opt := range options {
 		opt(err)
 	}
 	return err
 }
 
-// rejectConnectionError represents a rejection of upgrade error.
+// ConnectionRejectedError represents a rejection of connection during
+// WebSocket handshake error.
 //
-// It can be returned by Upgrader's On* hooks to control the way WebSocket
-// handshake is rejected.
-type rejectConnectionError struct {
+// It can be returned by Upgrader's On* hooks to indicate that WebSocket
+// handshake should be rejected.
+type ConnectionRejectedError struct {
 	reason string
 	code   int
 	header HandshakeHeader
 }
 
 // Error implements error interface.
-func (r *rejectConnectionError) Error() string {
+func (r *ConnectionRejectedError) Error() string {
 	return r.reason
 }
+
+func (r *ConnectionRejectedError) StatusCode() int {
+	return r.code
+}

vendor/github.com/gobwas/ws/server.go

@@ -251,7 +251,7 @@ func (u HTTPUpgrader) Upgrade(r *http.Request, w http.ResponseWriter) (conn net.
 		err = rw.Writer.Flush()
 	} else {
 		var code int
-		if rej, ok := err.(*rejectConnectionError); ok {
+		if rej, ok := err.(*ConnectionRejectedError); ok {
 			code = rej.code
 			header[1] = rej.header
 		}
@@ -260,7 +260,7 @@ func (u HTTPUpgrader) Upgrade(r *http.Request, w http.ResponseWriter) (conn net.
 		}
 		httpWriteResponseError(rw.Writer, err, code, header.WriteTo)
 		// Do not store Flush() error to not override already existing one.
-		rw.Writer.Flush()
+		_ = rw.Writer.Flush()
 	}
 	return
 }
@@ -630,7 +630,7 @@ func (u Upgrader) Upgrade(conn io.ReadWriter) (hs Handshake, err error) {
 	}
 	if err != nil {
 		var code int
-		if rej, ok := err.(*rejectConnectionError); ok {
+		if rej, ok := err.(*ConnectionRejectedError); ok {
 			code = rej.code
 			header[1] = rej.header
 		}
@@ -639,7 +639,7 @@ func (u Upgrader) Upgrade(conn io.ReadWriter) (hs Handshake, err error) {
 		}
 		httpWriteResponseError(bw, err, code, header.WriteTo)
 		// Do not store Flush() error to not override already existing one.
-		bw.Flush()
+		_ = bw.Flush()
 		return
 	}
 

vendor/github.com/gobwas/ws/wsutil/writer.go

@@ -290,7 +290,7 @@ func (w *Writer) Write(p []byte) (n int, err error) {
 	var nn int
 	for len(p) > w.Available() && w.err == nil {
 		if w.noFlush {
-			w.Grow(len(p) - w.Available())
+			w.Grow(len(p))
 			continue
 		}
 		if w.Buffered() == 0 {
@@ -336,18 +336,42 @@ func ceilPowerOfTwo(n int) int {
 	return n
 }
 
+// Grow grows Writer's internal buffer capacity to guarantee space for another
+// n bytes of _payload_ -- that is, frame header is not included in n.
 func (w *Writer) Grow(n int) {
+	// NOTE: we must respect the possibility of header reserved bytes grow.
 	var (
-		offset = len(w.raw) - len(w.buf)
-		size   = ceilPowerOfTwo(offset + w.n + n)
+		size       = len(w.raw)
+		prevOffset = len(w.raw) - len(w.buf)
+		nextOffset = len(w.raw) - len(w.buf)
+		buffered   = w.Buffered()
 	)
-	if size <= len(w.raw) {
+	for cap := size - nextOffset - buffered; cap < n; {
+		// This loop runs twice only at split cases, when reservation of raw
+		// buffer space for the header shrinks capacity of new buffer such that
+		// it still less than n.
+		//
+		// Loop is safe here because:
+		// - (offset + buffered + n) is greater than size, otherwise (cap < n)
+		//   would be false:
+		//   size  = offset + buffered + freeSpace (cap)
+		//   size' = offset + buffered + wantSpace (n)
+		//   Since (cap < n) is true in the loop condition, size' is guaranteed
+		//   to be greater => no infinite loop.
+		size = ceilPowerOfTwo(nextOffset + buffered + n)
+		nextOffset = reserve(w.state, size)
+		cap = size - nextOffset - buffered
+	}
+	if size < len(w.raw) {
 		panic("wsutil: buffer grow leads to its reduce")
 	}
+	if size == len(w.raw) {
+		return
+	}
 	p := make([]byte, size)
-	copy(p, w.raw[:offset+w.n])
+	copy(p[nextOffset-prevOffset:], w.raw[:prevOffset+buffered])
 	w.raw = p
-	w.buf = w.raw[offset:]
+	w.buf = w.raw[nextOffset:]
 }
 
 // WriteThrough writes data bypassing the buffer.
@@ -546,12 +570,15 @@ func writeFrame(w io.Writer, s ws.State, op ws.OpCode, fin bool, p []byte) error
 	return ws.WriteFrame(w, frame)
 }
 
+// reserve calculates number of bytes need to be reserved for frame header.
+//
+// Note that instead of ws.HeaderSize() it does calculation based on the buffer
+// size, not the payload size.
 func reserve(state ws.State, n int) (offset int) {
 	var mask int
 	if state.ClientSide() {
 		mask = 4
 	}
-
 	switch {
 	case n <= int(len7)+mask+2:
 		return mask + 2