diff --git a/projects/kubernetes-csi/livenessprobe/1-29/patches/0001-Address-CVE-2024-45338.patch b/projects/kubernetes-csi/livenessprobe/1-29/patches/0001-Address-CVE-2024-45338.patch new file mode 100644 index 000000000..d284d9f1d --- /dev/null +++ b/projects/kubernetes-csi/livenessprobe/1-29/patches/0001-Address-CVE-2024-45338.patch @@ -0,0 +1,5325 @@ +From f846b95fea50c3bbb26a8702870a4c2979e671fe Mon Sep 17 00:00:00 2001 +From: torredil +Date: Mon, 23 Dec 2024 18:55:24 +0000 +Subject: [PATCH] Address CVE-2024-45338 + +Signed-off-by: torredil +--- + go.mod | 6 +- + go.sum | 12 +- + .../x/net/http2/client_conn_pool.go | 8 +- + vendor/golang.org/x/net/http2/config.go | 122 +++++ + vendor/golang.org/x/net/http2/config_go124.go | 61 +++ + .../x/net/http2/config_pre_go124.go | 16 + + vendor/golang.org/x/net/http2/frame.go | 4 +- + vendor/golang.org/x/net/http2/http2.go | 95 +++- + vendor/golang.org/x/net/http2/server.go | 244 ++++++--- + vendor/golang.org/x/net/http2/transport.go | 516 ++++++++++++------ + vendor/golang.org/x/net/http2/unencrypted.go | 32 ++ + vendor/golang.org/x/net/http2/write.go | 10 + + vendor/golang.org/x/sys/unix/README.md | 2 +- + vendor/golang.org/x/sys/unix/ioctl_linux.go | 96 ++++ + vendor/golang.org/x/sys/unix/mkerrors.sh | 17 +- + vendor/golang.org/x/sys/unix/syscall_aix.go | 2 +- + .../golang.org/x/sys/unix/syscall_darwin.go | 37 ++ + vendor/golang.org/x/sys/unix/syscall_hurd.go | 1 + + vendor/golang.org/x/sys/unix/syscall_linux.go | 64 ++- + .../x/sys/unix/syscall_linux_arm64.go | 2 + + .../x/sys/unix/syscall_linux_loong64.go | 2 + + .../x/sys/unix/syscall_linux_riscv64.go | 2 + + .../x/sys/unix/syscall_zos_s390x.go | 104 +++- + .../golang.org/x/sys/unix/vgetrandom_linux.go | 13 + + .../x/sys/unix/vgetrandom_unsupported.go | 11 + + .../x/sys/unix/zerrors_darwin_amd64.go | 7 + + .../x/sys/unix/zerrors_darwin_arm64.go | 7 + + vendor/golang.org/x/sys/unix/zerrors_linux.go | 44 +- + .../x/sys/unix/zerrors_linux_386.go | 25 + + .../x/sys/unix/zerrors_linux_amd64.go | 25 + + .../x/sys/unix/zerrors_linux_arm.go | 25 + + .../x/sys/unix/zerrors_linux_arm64.go | 26 + + .../x/sys/unix/zerrors_linux_loong64.go | 25 + + .../x/sys/unix/zerrors_linux_mips.go | 25 + + .../x/sys/unix/zerrors_linux_mips64.go | 25 + + .../x/sys/unix/zerrors_linux_mips64le.go | 25 + + .../x/sys/unix/zerrors_linux_mipsle.go | 25 + + .../x/sys/unix/zerrors_linux_ppc.go | 25 + + .../x/sys/unix/zerrors_linux_ppc64.go | 25 + + .../x/sys/unix/zerrors_linux_ppc64le.go | 25 + + .../x/sys/unix/zerrors_linux_riscv64.go | 25 + + .../x/sys/unix/zerrors_linux_s390x.go | 25 + + .../x/sys/unix/zerrors_linux_sparc64.go | 25 + + .../x/sys/unix/zerrors_zos_s390x.go | 2 + + .../x/sys/unix/zsyscall_darwin_amd64.go | 20 + + .../x/sys/unix/zsyscall_darwin_amd64.s | 5 + + .../x/sys/unix/zsyscall_darwin_arm64.go | 20 + + .../x/sys/unix/zsyscall_darwin_arm64.s | 5 + + .../golang.org/x/sys/unix/zsyscall_linux.go | 27 +- + .../x/sys/unix/zsysnum_linux_amd64.go | 1 + + .../x/sys/unix/zsysnum_linux_arm64.go | 2 +- + .../x/sys/unix/zsysnum_linux_loong64.go | 2 + + .../x/sys/unix/zsysnum_linux_riscv64.go | 2 +- + .../x/sys/unix/ztypes_darwin_amd64.go | 73 +++ + .../x/sys/unix/ztypes_darwin_arm64.go | 73 +++ + .../x/sys/unix/ztypes_freebsd_386.go | 1 + + .../x/sys/unix/ztypes_freebsd_amd64.go | 1 + + .../x/sys/unix/ztypes_freebsd_arm.go | 1 + + .../x/sys/unix/ztypes_freebsd_arm64.go | 1 + + .../x/sys/unix/ztypes_freebsd_riscv64.go | 1 + + vendor/golang.org/x/sys/unix/ztypes_linux.go | 227 ++++++-- + .../x/sys/unix/ztypes_linux_riscv64.go | 33 ++ + .../golang.org/x/sys/unix/ztypes_zos_s390x.go | 6 + + .../golang.org/x/sys/windows/dll_windows.go | 2 +- + .../x/sys/windows/syscall_windows.go | 40 +- + .../golang.org/x/sys/windows/types_windows.go | 172 ++++++ + .../x/sys/windows/zsyscall_windows.go | 109 ++++ + vendor/modules.txt | 6 +- + 68 files changed, 2370 insertions(+), 375 deletions(-) + create mode 100644 vendor/golang.org/x/net/http2/config.go + create mode 100644 vendor/golang.org/x/net/http2/config_go124.go + create mode 100644 vendor/golang.org/x/net/http2/config_pre_go124.go + create mode 100644 vendor/golang.org/x/net/http2/unencrypted.go + create mode 100644 vendor/golang.org/x/sys/unix/vgetrandom_linux.go + create mode 100644 vendor/golang.org/x/sys/unix/vgetrandom_unsupported.go + +diff --git a/go.mod b/go.mod +index 235ec1f..b8ded7e 100644 +--- a/go.mod ++++ b/go.mod +@@ -42,9 +42,9 @@ require ( + go.opentelemetry.io/otel/trace v1.28.0 // indirect + go.uber.org/multierr v1.11.0 // indirect + go.uber.org/zap v1.27.0 // indirect +- golang.org/x/net v0.28.0 // indirect +- golang.org/x/sys v0.23.0 // indirect +- golang.org/x/text v0.17.0 // indirect ++ golang.org/x/net v0.33.0 // indirect ++ golang.org/x/sys v0.28.0 // indirect ++ golang.org/x/text v0.21.0 // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20240701130421-f6361c86f094 // indirect + google.golang.org/grpc v1.65.0 // indirect + google.golang.org/protobuf v1.34.2 // indirect +diff --git a/go.sum b/go.sum +index 4a2470f..db27122 100644 +--- a/go.sum ++++ b/go.sum +@@ -109,8 +109,8 @@ golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLL + golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= + golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= + golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= +-golang.org/x/net v0.28.0 h1:a9JDOJc5GMUJ0+UDqmLT86WiEy7iWyIhz8gz8E4e5hE= +-golang.org/x/net v0.28.0/go.mod h1:yqtgsTWOOnlGLG9GFRrK3++bGOUEkNBoHZc8MEDWPNg= ++golang.org/x/net v0.33.0 h1:74SYHlV8BIgHIFC/LrYkOGIwL19eTYXQ5wc6TBuO36I= ++golang.org/x/net v0.33.0/go.mod h1:HXLR5J+9DxmrqMwG9qjGCxZ+zKXxBru04zlTvWlWuN4= + golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= + golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= + golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +@@ -121,13 +121,13 @@ golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7w + golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= + golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= + golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +-golang.org/x/sys v0.23.0 h1:YfKFowiIMvtgl1UERQoTPPToxltDeZfbj4H7dVUCwmM= +-golang.org/x/sys v0.23.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= ++golang.org/x/sys v0.28.0 h1:Fksou7UEQUWlKvIdsqzJmUmCX3cZuD2+P3XyyzwMhlA= ++golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= + golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= + golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= + golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +-golang.org/x/text v0.17.0 h1:XtiM5bkSOt+ewxlOE/aE/AKEHibwj/6gvWMl9Rsh0Qc= +-golang.org/x/text v0.17.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY= ++golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo= ++golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ= + golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= + golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= + golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +diff --git a/vendor/golang.org/x/net/http2/client_conn_pool.go b/vendor/golang.org/x/net/http2/client_conn_pool.go +index 780968d..e81b73e 100644 +--- a/vendor/golang.org/x/net/http2/client_conn_pool.go ++++ b/vendor/golang.org/x/net/http2/client_conn_pool.go +@@ -8,8 +8,8 @@ package http2 + + import ( + "context" +- "crypto/tls" + "errors" ++ "net" + "net/http" + "sync" + ) +@@ -158,7 +158,7 @@ func (c *dialCall) dial(ctx context.Context, addr string) { + // This code decides which ones live or die. + // The return value used is whether c was used. + // c is never closed. +-func (p *clientConnPool) addConnIfNeeded(key string, t *Transport, c *tls.Conn) (used bool, err error) { ++func (p *clientConnPool) addConnIfNeeded(key string, t *Transport, c net.Conn) (used bool, err error) { + p.mu.Lock() + for _, cc := range p.conns[key] { + if cc.CanTakeNewRequest() { +@@ -194,8 +194,8 @@ type addConnCall struct { + err error + } + +-func (c *addConnCall) run(t *Transport, key string, tc *tls.Conn) { +- cc, err := t.NewClientConn(tc) ++func (c *addConnCall) run(t *Transport, key string, nc net.Conn) { ++ cc, err := t.NewClientConn(nc) + + p := c.p + p.mu.Lock() +diff --git a/vendor/golang.org/x/net/http2/config.go b/vendor/golang.org/x/net/http2/config.go +new file mode 100644 +index 0000000..de58dfb +--- /dev/null ++++ b/vendor/golang.org/x/net/http2/config.go +@@ -0,0 +1,122 @@ ++// Copyright 2024 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 http2 ++ ++import ( ++ "math" ++ "net/http" ++ "time" ++) ++ ++// http2Config is a package-internal version of net/http.HTTP2Config. ++// ++// http.HTTP2Config was added in Go 1.24. ++// When running with a version of net/http that includes HTTP2Config, ++// we merge the configuration with the fields in Transport or Server ++// to produce an http2Config. ++// ++// Zero valued fields in http2Config are interpreted as in the ++// net/http.HTTPConfig documentation. ++// ++// Precedence order for reconciling configurations is: ++// ++// - Use the net/http.{Server,Transport}.HTTP2Config value, when non-zero. ++// - Otherwise use the http2.{Server.Transport} value. ++// - If the resulting value is zero or out of range, use a default. ++type http2Config struct { ++ MaxConcurrentStreams uint32 ++ MaxDecoderHeaderTableSize uint32 ++ MaxEncoderHeaderTableSize uint32 ++ MaxReadFrameSize uint32 ++ MaxUploadBufferPerConnection int32 ++ MaxUploadBufferPerStream int32 ++ SendPingTimeout time.Duration ++ PingTimeout time.Duration ++ WriteByteTimeout time.Duration ++ PermitProhibitedCipherSuites bool ++ CountError func(errType string) ++} ++ ++// configFromServer merges configuration settings from ++// net/http.Server.HTTP2Config and http2.Server. ++func configFromServer(h1 *http.Server, h2 *Server) http2Config { ++ conf := http2Config{ ++ MaxConcurrentStreams: h2.MaxConcurrentStreams, ++ MaxEncoderHeaderTableSize: h2.MaxEncoderHeaderTableSize, ++ MaxDecoderHeaderTableSize: h2.MaxDecoderHeaderTableSize, ++ MaxReadFrameSize: h2.MaxReadFrameSize, ++ MaxUploadBufferPerConnection: h2.MaxUploadBufferPerConnection, ++ MaxUploadBufferPerStream: h2.MaxUploadBufferPerStream, ++ SendPingTimeout: h2.ReadIdleTimeout, ++ PingTimeout: h2.PingTimeout, ++ WriteByteTimeout: h2.WriteByteTimeout, ++ PermitProhibitedCipherSuites: h2.PermitProhibitedCipherSuites, ++ CountError: h2.CountError, ++ } ++ fillNetHTTPServerConfig(&conf, h1) ++ setConfigDefaults(&conf, true) ++ return conf ++} ++ ++// configFromServer merges configuration settings from h2 and h2.t1.HTTP2 ++// (the net/http Transport). ++func configFromTransport(h2 *Transport) http2Config { ++ conf := http2Config{ ++ MaxEncoderHeaderTableSize: h2.MaxEncoderHeaderTableSize, ++ MaxDecoderHeaderTableSize: h2.MaxDecoderHeaderTableSize, ++ MaxReadFrameSize: h2.MaxReadFrameSize, ++ SendPingTimeout: h2.ReadIdleTimeout, ++ PingTimeout: h2.PingTimeout, ++ WriteByteTimeout: h2.WriteByteTimeout, ++ } ++ ++ // Unlike most config fields, where out-of-range values revert to the default, ++ // Transport.MaxReadFrameSize clips. ++ if conf.MaxReadFrameSize < minMaxFrameSize { ++ conf.MaxReadFrameSize = minMaxFrameSize ++ } else if conf.MaxReadFrameSize > maxFrameSize { ++ conf.MaxReadFrameSize = maxFrameSize ++ } ++ ++ if h2.t1 != nil { ++ fillNetHTTPTransportConfig(&conf, h2.t1) ++ } ++ setConfigDefaults(&conf, false) ++ return conf ++} ++ ++func setDefault[T ~int | ~int32 | ~uint32 | ~int64](v *T, minval, maxval, defval T) { ++ if *v < minval || *v > maxval { ++ *v = defval ++ } ++} ++ ++func setConfigDefaults(conf *http2Config, server bool) { ++ setDefault(&conf.MaxConcurrentStreams, 1, math.MaxUint32, defaultMaxStreams) ++ setDefault(&conf.MaxEncoderHeaderTableSize, 1, math.MaxUint32, initialHeaderTableSize) ++ setDefault(&conf.MaxDecoderHeaderTableSize, 1, math.MaxUint32, initialHeaderTableSize) ++ if server { ++ setDefault(&conf.MaxUploadBufferPerConnection, initialWindowSize, math.MaxInt32, 1<<20) ++ } else { ++ setDefault(&conf.MaxUploadBufferPerConnection, initialWindowSize, math.MaxInt32, transportDefaultConnFlow) ++ } ++ if server { ++ setDefault(&conf.MaxUploadBufferPerStream, 1, math.MaxInt32, 1<<20) ++ } else { ++ setDefault(&conf.MaxUploadBufferPerStream, 1, math.MaxInt32, transportDefaultStreamFlow) ++ } ++ setDefault(&conf.MaxReadFrameSize, minMaxFrameSize, maxFrameSize, defaultMaxReadFrameSize) ++ setDefault(&conf.PingTimeout, 1, math.MaxInt64, 15*time.Second) ++} ++ ++// adjustHTTP1MaxHeaderSize converts a limit in bytes on the size of an HTTP/1 header ++// to an HTTP/2 MAX_HEADER_LIST_SIZE value. ++func adjustHTTP1MaxHeaderSize(n int64) int64 { ++ // http2's count is in a slightly different unit and includes 32 bytes per pair. ++ // So, take the net/http.Server value and pad it up a bit, assuming 10 headers. ++ const perFieldOverhead = 32 // per http2 spec ++ const typicalHeaders = 10 // conservative ++ return n + typicalHeaders*perFieldOverhead ++} +diff --git a/vendor/golang.org/x/net/http2/config_go124.go b/vendor/golang.org/x/net/http2/config_go124.go +new file mode 100644 +index 0000000..e378412 +--- /dev/null ++++ b/vendor/golang.org/x/net/http2/config_go124.go +@@ -0,0 +1,61 @@ ++// Copyright 2024 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. ++ ++//go:build go1.24 ++ ++package http2 ++ ++import "net/http" ++ ++// fillNetHTTPServerConfig sets fields in conf from srv.HTTP2. ++func fillNetHTTPServerConfig(conf *http2Config, srv *http.Server) { ++ fillNetHTTPConfig(conf, srv.HTTP2) ++} ++ ++// fillNetHTTPServerConfig sets fields in conf from tr.HTTP2. ++func fillNetHTTPTransportConfig(conf *http2Config, tr *http.Transport) { ++ fillNetHTTPConfig(conf, tr.HTTP2) ++} ++ ++func fillNetHTTPConfig(conf *http2Config, h2 *http.HTTP2Config) { ++ if h2 == nil { ++ return ++ } ++ if h2.MaxConcurrentStreams != 0 { ++ conf.MaxConcurrentStreams = uint32(h2.MaxConcurrentStreams) ++ } ++ if h2.MaxEncoderHeaderTableSize != 0 { ++ conf.MaxEncoderHeaderTableSize = uint32(h2.MaxEncoderHeaderTableSize) ++ } ++ if h2.MaxDecoderHeaderTableSize != 0 { ++ conf.MaxDecoderHeaderTableSize = uint32(h2.MaxDecoderHeaderTableSize) ++ } ++ if h2.MaxConcurrentStreams != 0 { ++ conf.MaxConcurrentStreams = uint32(h2.MaxConcurrentStreams) ++ } ++ if h2.MaxReadFrameSize != 0 { ++ conf.MaxReadFrameSize = uint32(h2.MaxReadFrameSize) ++ } ++ if h2.MaxReceiveBufferPerConnection != 0 { ++ conf.MaxUploadBufferPerConnection = int32(h2.MaxReceiveBufferPerConnection) ++ } ++ if h2.MaxReceiveBufferPerStream != 0 { ++ conf.MaxUploadBufferPerStream = int32(h2.MaxReceiveBufferPerStream) ++ } ++ if h2.SendPingTimeout != 0 { ++ conf.SendPingTimeout = h2.SendPingTimeout ++ } ++ if h2.PingTimeout != 0 { ++ conf.PingTimeout = h2.PingTimeout ++ } ++ if h2.WriteByteTimeout != 0 { ++ conf.WriteByteTimeout = h2.WriteByteTimeout ++ } ++ if h2.PermitProhibitedCipherSuites { ++ conf.PermitProhibitedCipherSuites = true ++ } ++ if h2.CountError != nil { ++ conf.CountError = h2.CountError ++ } ++} +diff --git a/vendor/golang.org/x/net/http2/config_pre_go124.go b/vendor/golang.org/x/net/http2/config_pre_go124.go +new file mode 100644 +index 0000000..060fd6c +--- /dev/null ++++ b/vendor/golang.org/x/net/http2/config_pre_go124.go +@@ -0,0 +1,16 @@ ++// Copyright 2024 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. ++ ++//go:build !go1.24 ++ ++package http2 ++ ++import "net/http" ++ ++// Pre-Go 1.24 fallback. ++// The Server.HTTP2 and Transport.HTTP2 config fields were added in Go 1.24. ++ ++func fillNetHTTPServerConfig(conf *http2Config, srv *http.Server) {} ++ ++func fillNetHTTPTransportConfig(conf *http2Config, tr *http.Transport) {} +diff --git a/vendor/golang.org/x/net/http2/frame.go b/vendor/golang.org/x/net/http2/frame.go +index 105c3b2..81faec7 100644 +--- a/vendor/golang.org/x/net/http2/frame.go ++++ b/vendor/golang.org/x/net/http2/frame.go +@@ -1490,7 +1490,7 @@ func (mh *MetaHeadersFrame) checkPseudos() error { + pf := mh.PseudoFields() + for i, hf := range pf { + switch hf.Name { +- case ":method", ":path", ":scheme", ":authority": ++ case ":method", ":path", ":scheme", ":authority", ":protocol": + isRequest = true + case ":status": + isResponse = true +@@ -1498,7 +1498,7 @@ func (mh *MetaHeadersFrame) checkPseudos() error { + return pseudoHeaderError(hf.Name) + } + // Check for duplicates. +- // This would be a bad algorithm, but N is 4. ++ // This would be a bad algorithm, but N is 5. + // And this doesn't allocate. + for _, hf2 := range pf[:i] { + if hf.Name == hf2.Name { +diff --git a/vendor/golang.org/x/net/http2/http2.go b/vendor/golang.org/x/net/http2/http2.go +index 003e649..c7601c9 100644 +--- a/vendor/golang.org/x/net/http2/http2.go ++++ b/vendor/golang.org/x/net/http2/http2.go +@@ -19,8 +19,9 @@ import ( + "bufio" + "context" + "crypto/tls" ++ "errors" + "fmt" +- "io" ++ "net" + "net/http" + "os" + "sort" +@@ -33,10 +34,11 @@ import ( + ) + + var ( +- VerboseLogs bool +- logFrameWrites bool +- logFrameReads bool +- inTests bool ++ VerboseLogs bool ++ logFrameWrites bool ++ logFrameReads bool ++ inTests bool ++ disableExtendedConnectProtocol bool + ) + + func init() { +@@ -49,6 +51,9 @@ func init() { + logFrameWrites = true + logFrameReads = true + } ++ if strings.Contains(e, "http2xconnect=0") { ++ disableExtendedConnectProtocol = true ++ } + } + + const ( +@@ -140,6 +145,10 @@ func (s Setting) Valid() error { + if s.Val < 16384 || s.Val > 1<<24-1 { + return ConnectionError(ErrCodeProtocol) + } ++ case SettingEnableConnectProtocol: ++ if s.Val != 1 && s.Val != 0 { ++ return ConnectionError(ErrCodeProtocol) ++ } + } + return nil + } +@@ -149,21 +158,23 @@ func (s Setting) Valid() error { + type SettingID uint16 + + const ( +- SettingHeaderTableSize SettingID = 0x1 +- SettingEnablePush SettingID = 0x2 +- SettingMaxConcurrentStreams SettingID = 0x3 +- SettingInitialWindowSize SettingID = 0x4 +- SettingMaxFrameSize SettingID = 0x5 +- SettingMaxHeaderListSize SettingID = 0x6 ++ SettingHeaderTableSize SettingID = 0x1 ++ SettingEnablePush SettingID = 0x2 ++ SettingMaxConcurrentStreams SettingID = 0x3 ++ SettingInitialWindowSize SettingID = 0x4 ++ SettingMaxFrameSize SettingID = 0x5 ++ SettingMaxHeaderListSize SettingID = 0x6 ++ SettingEnableConnectProtocol SettingID = 0x8 + ) + + var settingName = map[SettingID]string{ +- SettingHeaderTableSize: "HEADER_TABLE_SIZE", +- SettingEnablePush: "ENABLE_PUSH", +- SettingMaxConcurrentStreams: "MAX_CONCURRENT_STREAMS", +- SettingInitialWindowSize: "INITIAL_WINDOW_SIZE", +- SettingMaxFrameSize: "MAX_FRAME_SIZE", +- SettingMaxHeaderListSize: "MAX_HEADER_LIST_SIZE", ++ SettingHeaderTableSize: "HEADER_TABLE_SIZE", ++ SettingEnablePush: "ENABLE_PUSH", ++ SettingMaxConcurrentStreams: "MAX_CONCURRENT_STREAMS", ++ SettingInitialWindowSize: "INITIAL_WINDOW_SIZE", ++ SettingMaxFrameSize: "MAX_FRAME_SIZE", ++ SettingMaxHeaderListSize: "MAX_HEADER_LIST_SIZE", ++ SettingEnableConnectProtocol: "ENABLE_CONNECT_PROTOCOL", + } + + func (s SettingID) String() string { +@@ -237,13 +248,19 @@ func (cw closeWaiter) Wait() { + // Its buffered writer is lazily allocated as needed, to minimize + // idle memory usage with many connections. + type bufferedWriter struct { +- _ incomparable +- w io.Writer // immutable +- bw *bufio.Writer // non-nil when data is buffered ++ _ incomparable ++ group synctestGroupInterface // immutable ++ conn net.Conn // immutable ++ bw *bufio.Writer // non-nil when data is buffered ++ byteTimeout time.Duration // immutable, WriteByteTimeout + } + +-func newBufferedWriter(w io.Writer) *bufferedWriter { +- return &bufferedWriter{w: w} ++func newBufferedWriter(group synctestGroupInterface, conn net.Conn, timeout time.Duration) *bufferedWriter { ++ return &bufferedWriter{ ++ group: group, ++ conn: conn, ++ byteTimeout: timeout, ++ } + } + + // bufWriterPoolBufferSize is the size of bufio.Writer's +@@ -270,7 +287,7 @@ func (w *bufferedWriter) Available() int { + func (w *bufferedWriter) Write(p []byte) (n int, err error) { + if w.bw == nil { + bw := bufWriterPool.Get().(*bufio.Writer) +- bw.Reset(w.w) ++ bw.Reset((*bufferedWriterTimeoutWriter)(w)) + w.bw = bw + } + return w.bw.Write(p) +@@ -288,6 +305,38 @@ func (w *bufferedWriter) Flush() error { + return err + } + ++type bufferedWriterTimeoutWriter bufferedWriter ++ ++func (w *bufferedWriterTimeoutWriter) Write(p []byte) (n int, err error) { ++ return writeWithByteTimeout(w.group, w.conn, w.byteTimeout, p) ++} ++ ++// writeWithByteTimeout writes to conn. ++// If more than timeout passes without any bytes being written to the connection, ++// the write fails. ++func writeWithByteTimeout(group synctestGroupInterface, conn net.Conn, timeout time.Duration, p []byte) (n int, err error) { ++ if timeout <= 0 { ++ return conn.Write(p) ++ } ++ for { ++ var now time.Time ++ if group == nil { ++ now = time.Now() ++ } else { ++ now = group.Now() ++ } ++ conn.SetWriteDeadline(now.Add(timeout)) ++ nn, err := conn.Write(p[n:]) ++ n += nn ++ if n == len(p) || nn == 0 || !errors.Is(err, os.ErrDeadlineExceeded) { ++ // Either we finished the write, made no progress, or hit the deadline. ++ // Whichever it is, we're done now. ++ conn.SetWriteDeadline(time.Time{}) ++ return n, err ++ } ++ } ++} ++ + func mustUint31(v int32) uint32 { + if v < 0 || v > 2147483647 { + panic("out of range") +diff --git a/vendor/golang.org/x/net/http2/server.go b/vendor/golang.org/x/net/http2/server.go +index 6c349f3..b55547a 100644 +--- a/vendor/golang.org/x/net/http2/server.go ++++ b/vendor/golang.org/x/net/http2/server.go +@@ -29,6 +29,7 @@ import ( + "bufio" + "bytes" + "context" ++ "crypto/rand" + "crypto/tls" + "errors" + "fmt" +@@ -52,10 +53,14 @@ import ( + ) + + const ( +- prefaceTimeout = 10 * time.Second +- firstSettingsTimeout = 2 * time.Second // should be in-flight with preface anyway +- handlerChunkWriteSize = 4 << 10 +- defaultMaxStreams = 250 // TODO: make this 100 as the GFE seems to? ++ prefaceTimeout = 10 * time.Second ++ firstSettingsTimeout = 2 * time.Second // should be in-flight with preface anyway ++ handlerChunkWriteSize = 4 << 10 ++ defaultMaxStreams = 250 // TODO: make this 100 as the GFE seems to? ++ ++ // maxQueuedControlFrames is the maximum number of control frames like ++ // SETTINGS, PING and RST_STREAM that will be queued for writing before ++ // the connection is closed to prevent memory exhaustion attacks. + maxQueuedControlFrames = 10000 + ) + +@@ -127,6 +132,22 @@ type Server struct { + // If zero or negative, there is no timeout. + IdleTimeout time.Duration + ++ // ReadIdleTimeout is the timeout after which a health check using a ping ++ // frame will be carried out if no frame is received on the connection. ++ // If zero, no health check is performed. ++ ReadIdleTimeout time.Duration ++ ++ // PingTimeout is the timeout after which the connection will be closed ++ // if a response to a ping is not received. ++ // If zero, a default of 15 seconds is used. ++ PingTimeout time.Duration ++ ++ // WriteByteTimeout is the timeout after which a connection will be ++ // closed if no data can be written to it. The timeout begins when data is ++ // available to write, and is extended whenever any bytes are written. ++ // If zero or negative, there is no timeout. ++ WriteByteTimeout time.Duration ++ + // MaxUploadBufferPerConnection is the size of the initial flow + // control window for each connections. The HTTP/2 spec does not + // allow this to be smaller than 65535 or larger than 2^32-1. +@@ -189,57 +210,6 @@ func (s *Server) afterFunc(d time.Duration, f func()) timer { + return timeTimer{time.AfterFunc(d, f)} + } + +-func (s *Server) initialConnRecvWindowSize() int32 { +- if s.MaxUploadBufferPerConnection >= initialWindowSize { +- return s.MaxUploadBufferPerConnection +- } +- return 1 << 20 +-} +- +-func (s *Server) initialStreamRecvWindowSize() int32 { +- if s.MaxUploadBufferPerStream > 0 { +- return s.MaxUploadBufferPerStream +- } +- return 1 << 20 +-} +- +-func (s *Server) maxReadFrameSize() uint32 { +- if v := s.MaxReadFrameSize; v >= minMaxFrameSize && v <= maxFrameSize { +- return v +- } +- return defaultMaxReadFrameSize +-} +- +-func (s *Server) maxConcurrentStreams() uint32 { +- if v := s.MaxConcurrentStreams; v > 0 { +- return v +- } +- return defaultMaxStreams +-} +- +-func (s *Server) maxDecoderHeaderTableSize() uint32 { +- if v := s.MaxDecoderHeaderTableSize; v > 0 { +- return v +- } +- return initialHeaderTableSize +-} +- +-func (s *Server) maxEncoderHeaderTableSize() uint32 { +- if v := s.MaxEncoderHeaderTableSize; v > 0 { +- return v +- } +- return initialHeaderTableSize +-} +- +-// maxQueuedControlFrames is the maximum number of control frames like +-// SETTINGS, PING and RST_STREAM that will be queued for writing before +-// the connection is closed to prevent memory exhaustion attacks. +-func (s *Server) maxQueuedControlFrames() int { +- // TODO: if anybody asks, add a Server field, and remember to define the +- // behavior of negative values. +- return maxQueuedControlFrames +-} +- + type serverInternalState struct { + mu sync.Mutex + activeConns map[*serverConn]struct{} +@@ -336,7 +306,7 @@ func ConfigureServer(s *http.Server, conf *Server) error { + if s.TLSNextProto == nil { + s.TLSNextProto = map[string]func(*http.Server, *tls.Conn, http.Handler){} + } +- protoHandler := func(hs *http.Server, c *tls.Conn, h http.Handler) { ++ protoHandler := func(hs *http.Server, c net.Conn, h http.Handler, sawClientPreface bool) { + if testHookOnConn != nil { + testHookOnConn() + } +@@ -353,12 +323,31 @@ func ConfigureServer(s *http.Server, conf *Server) error { + ctx = bc.BaseContext() + } + conf.ServeConn(c, &ServeConnOpts{ +- Context: ctx, +- Handler: h, +- BaseConfig: hs, ++ Context: ctx, ++ Handler: h, ++ BaseConfig: hs, ++ SawClientPreface: sawClientPreface, + }) + } +- s.TLSNextProto[NextProtoTLS] = protoHandler ++ s.TLSNextProto[NextProtoTLS] = func(hs *http.Server, c *tls.Conn, h http.Handler) { ++ protoHandler(hs, c, h, false) ++ } ++ // The "unencrypted_http2" TLSNextProto key is used to pass off non-TLS HTTP/2 conns. ++ // ++ // A connection passed in this method has already had the HTTP/2 preface read from it. ++ s.TLSNextProto[nextProtoUnencryptedHTTP2] = func(hs *http.Server, c *tls.Conn, h http.Handler) { ++ nc, err := unencryptedNetConnFromTLSConn(c) ++ if err != nil { ++ if lg := hs.ErrorLog; lg != nil { ++ lg.Print(err) ++ } else { ++ log.Print(err) ++ } ++ go c.Close() ++ return ++ } ++ protoHandler(hs, nc, h, true) ++ } + return nil + } + +@@ -440,13 +429,15 @@ func (s *Server) serveConn(c net.Conn, opts *ServeConnOpts, newf func(*serverCon + baseCtx, cancel := serverConnBaseContext(c, opts) + defer cancel() + ++ http1srv := opts.baseConfig() ++ conf := configFromServer(http1srv, s) + sc := &serverConn{ + srv: s, +- hs: opts.baseConfig(), ++ hs: http1srv, + conn: c, + baseCtx: baseCtx, + remoteAddrStr: c.RemoteAddr().String(), +- bw: newBufferedWriter(c), ++ bw: newBufferedWriter(s.group, c, conf.WriteByteTimeout), + handler: opts.handler(), + streams: make(map[uint32]*stream), + readFrameCh: make(chan readFrameResult), +@@ -456,9 +447,12 @@ func (s *Server) serveConn(c net.Conn, opts *ServeConnOpts, newf func(*serverCon + bodyReadCh: make(chan bodyReadMsg), // buffering doesn't matter either way + doneServing: make(chan struct{}), + clientMaxStreams: math.MaxUint32, // Section 6.5.2: "Initially, there is no limit to this value" +- advMaxStreams: s.maxConcurrentStreams(), ++ advMaxStreams: conf.MaxConcurrentStreams, + initialStreamSendWindowSize: initialWindowSize, ++ initialStreamRecvWindowSize: conf.MaxUploadBufferPerStream, + maxFrameSize: initialMaxFrameSize, ++ pingTimeout: conf.PingTimeout, ++ countErrorFunc: conf.CountError, + serveG: newGoroutineLock(), + pushEnabled: true, + sawClientPreface: opts.SawClientPreface, +@@ -491,15 +485,15 @@ func (s *Server) serveConn(c net.Conn, opts *ServeConnOpts, newf func(*serverCon + sc.flow.add(initialWindowSize) + sc.inflow.init(initialWindowSize) + sc.hpackEncoder = hpack.NewEncoder(&sc.headerWriteBuf) +- sc.hpackEncoder.SetMaxDynamicTableSizeLimit(s.maxEncoderHeaderTableSize()) ++ sc.hpackEncoder.SetMaxDynamicTableSizeLimit(conf.MaxEncoderHeaderTableSize) + + fr := NewFramer(sc.bw, c) +- if s.CountError != nil { +- fr.countError = s.CountError ++ if conf.CountError != nil { ++ fr.countError = conf.CountError + } +- fr.ReadMetaHeaders = hpack.NewDecoder(s.maxDecoderHeaderTableSize(), nil) ++ fr.ReadMetaHeaders = hpack.NewDecoder(conf.MaxDecoderHeaderTableSize, nil) + fr.MaxHeaderListSize = sc.maxHeaderListSize() +- fr.SetMaxReadFrameSize(s.maxReadFrameSize()) ++ fr.SetMaxReadFrameSize(conf.MaxReadFrameSize) + sc.framer = fr + + if tc, ok := c.(connectionStater); ok { +@@ -532,7 +526,7 @@ func (s *Server) serveConn(c net.Conn, opts *ServeConnOpts, newf func(*serverCon + // So for now, do nothing here again. + } + +- if !s.PermitProhibitedCipherSuites && isBadCipher(sc.tlsState.CipherSuite) { ++ if !conf.PermitProhibitedCipherSuites && isBadCipher(sc.tlsState.CipherSuite) { + // "Endpoints MAY choose to generate a connection error + // (Section 5.4.1) of type INADEQUATE_SECURITY if one of + // the prohibited cipher suites are negotiated." +@@ -569,7 +563,7 @@ func (s *Server) serveConn(c net.Conn, opts *ServeConnOpts, newf func(*serverCon + opts.UpgradeRequest = nil + } + +- sc.serve() ++ sc.serve(conf) + } + + func serverConnBaseContext(c net.Conn, opts *ServeConnOpts) (ctx context.Context, cancel func()) { +@@ -609,6 +603,7 @@ type serverConn struct { + tlsState *tls.ConnectionState // shared by all handlers, like net/http + remoteAddrStr string + writeSched WriteScheduler ++ countErrorFunc func(errType string) + + // Everything following is owned by the serve loop; use serveG.check(): + serveG goroutineLock // used to verify funcs are on serve() +@@ -628,6 +623,7 @@ type serverConn struct { + streams map[uint32]*stream + unstartedHandlers []unstartedHandler + initialStreamSendWindowSize int32 ++ initialStreamRecvWindowSize int32 + maxFrameSize int32 + peerMaxHeaderListSize uint32 // zero means unknown (default) + canonHeader map[string]string // http2-lower-case -> Go-Canonical-Case +@@ -638,9 +634,14 @@ type serverConn struct { + inGoAway bool // we've started to or sent GOAWAY + inFrameScheduleLoop bool // whether we're in the scheduleFrameWrite loop + needToSendGoAway bool // we need to schedule a GOAWAY frame write ++ pingSent bool ++ sentPingData [8]byte + goAwayCode ErrCode + shutdownTimer timer // nil until used + idleTimer timer // nil if unused ++ readIdleTimeout time.Duration ++ pingTimeout time.Duration ++ readIdleTimer timer // nil if unused + + // Owned by the writeFrameAsync goroutine: + headerWriteBuf bytes.Buffer +@@ -655,11 +656,7 @@ func (sc *serverConn) maxHeaderListSize() uint32 { + if n <= 0 { + n = http.DefaultMaxHeaderBytes + } +- // http2's count is in a slightly different unit and includes 32 bytes per pair. +- // So, take the net/http.Server value and pad it up a bit, assuming 10 headers. +- const perFieldOverhead = 32 // per http2 spec +- const typicalHeaders = 10 // conservative +- return uint32(n + typicalHeaders*perFieldOverhead) ++ return uint32(adjustHTTP1MaxHeaderSize(int64(n))) + } + + func (sc *serverConn) curOpenStreams() uint32 { +@@ -923,7 +920,7 @@ func (sc *serverConn) notePanic() { + } + } + +-func (sc *serverConn) serve() { ++func (sc *serverConn) serve(conf http2Config) { + sc.serveG.check() + defer sc.notePanic() + defer sc.conn.Close() +@@ -935,20 +932,24 @@ func (sc *serverConn) serve() { + sc.vlogf("http2: server connection from %v on %p", sc.conn.RemoteAddr(), sc.hs) + } + ++ settings := writeSettings{ ++ {SettingMaxFrameSize, conf.MaxReadFrameSize}, ++ {SettingMaxConcurrentStreams, sc.advMaxStreams}, ++ {SettingMaxHeaderListSize, sc.maxHeaderListSize()}, ++ {SettingHeaderTableSize, conf.MaxDecoderHeaderTableSize}, ++ {SettingInitialWindowSize, uint32(sc.initialStreamRecvWindowSize)}, ++ } ++ if !disableExtendedConnectProtocol { ++ settings = append(settings, Setting{SettingEnableConnectProtocol, 1}) ++ } + sc.writeFrame(FrameWriteRequest{ +- write: writeSettings{ +- {SettingMaxFrameSize, sc.srv.maxReadFrameSize()}, +- {SettingMaxConcurrentStreams, sc.advMaxStreams}, +- {SettingMaxHeaderListSize, sc.maxHeaderListSize()}, +- {SettingHeaderTableSize, sc.srv.maxDecoderHeaderTableSize()}, +- {SettingInitialWindowSize, uint32(sc.srv.initialStreamRecvWindowSize())}, +- }, ++ write: settings, + }) + sc.unackedSettings++ + + // Each connection starts with initialWindowSize inflow tokens. + // If a higher value is configured, we add more tokens. +- if diff := sc.srv.initialConnRecvWindowSize() - initialWindowSize; diff > 0 { ++ if diff := conf.MaxUploadBufferPerConnection - initialWindowSize; diff > 0 { + sc.sendWindowUpdate(nil, int(diff)) + } + +@@ -968,11 +969,18 @@ func (sc *serverConn) serve() { + defer sc.idleTimer.Stop() + } + ++ if conf.SendPingTimeout > 0 { ++ sc.readIdleTimeout = conf.SendPingTimeout ++ sc.readIdleTimer = sc.srv.afterFunc(conf.SendPingTimeout, sc.onReadIdleTimer) ++ defer sc.readIdleTimer.Stop() ++ } ++ + go sc.readFrames() // closed by defer sc.conn.Close above + + settingsTimer := sc.srv.afterFunc(firstSettingsTimeout, sc.onSettingsTimer) + defer settingsTimer.Stop() + ++ lastFrameTime := sc.srv.now() + loopNum := 0 + for { + loopNum++ +@@ -986,6 +994,7 @@ func (sc *serverConn) serve() { + case res := <-sc.wroteFrameCh: + sc.wroteFrame(res) + case res := <-sc.readFrameCh: ++ lastFrameTime = sc.srv.now() + // Process any written frames before reading new frames from the client since a + // written frame could have triggered a new stream to be started. + if sc.writingFrameAsync { +@@ -1017,6 +1026,8 @@ func (sc *serverConn) serve() { + case idleTimerMsg: + sc.vlogf("connection is idle") + sc.goAway(ErrCodeNo) ++ case readIdleTimerMsg: ++ sc.handlePingTimer(lastFrameTime) + case shutdownTimerMsg: + sc.vlogf("GOAWAY close timer fired; closing conn from %v", sc.conn.RemoteAddr()) + return +@@ -1039,7 +1050,7 @@ func (sc *serverConn) serve() { + // If the peer is causing us to generate a lot of control frames, + // but not reading them from us, assume they are trying to make us + // run out of memory. +- if sc.queuedControlFrames > sc.srv.maxQueuedControlFrames() { ++ if sc.queuedControlFrames > maxQueuedControlFrames { + sc.vlogf("http2: too many control frames in send queue, closing connection") + return + } +@@ -1055,12 +1066,39 @@ func (sc *serverConn) serve() { + } + } + ++func (sc *serverConn) handlePingTimer(lastFrameReadTime time.Time) { ++ if sc.pingSent { ++ sc.vlogf("timeout waiting for PING response") ++ sc.conn.Close() ++ return ++ } ++ ++ pingAt := lastFrameReadTime.Add(sc.readIdleTimeout) ++ now := sc.srv.now() ++ if pingAt.After(now) { ++ // We received frames since arming the ping timer. ++ // Reset it for the next possible timeout. ++ sc.readIdleTimer.Reset(pingAt.Sub(now)) ++ return ++ } ++ ++ sc.pingSent = true ++ // Ignore crypto/rand.Read errors: It generally can't fail, and worse case if it does ++ // is we send a PING frame containing 0s. ++ _, _ = rand.Read(sc.sentPingData[:]) ++ sc.writeFrame(FrameWriteRequest{ ++ write: &writePing{data: sc.sentPingData}, ++ }) ++ sc.readIdleTimer.Reset(sc.pingTimeout) ++} ++ + type serverMessage int + + // Message values sent to serveMsgCh. + var ( + settingsTimerMsg = new(serverMessage) + idleTimerMsg = new(serverMessage) ++ readIdleTimerMsg = new(serverMessage) + shutdownTimerMsg = new(serverMessage) + gracefulShutdownMsg = new(serverMessage) + handlerDoneMsg = new(serverMessage) +@@ -1068,6 +1106,7 @@ var ( + + func (sc *serverConn) onSettingsTimer() { sc.sendServeMsg(settingsTimerMsg) } + func (sc *serverConn) onIdleTimer() { sc.sendServeMsg(idleTimerMsg) } ++func (sc *serverConn) onReadIdleTimer() { sc.sendServeMsg(readIdleTimerMsg) } + func (sc *serverConn) onShutdownTimer() { sc.sendServeMsg(shutdownTimerMsg) } + + func (sc *serverConn) sendServeMsg(msg interface{}) { +@@ -1320,6 +1359,10 @@ func (sc *serverConn) wroteFrame(res frameWriteResult) { + sc.writingFrame = false + sc.writingFrameAsync = false + ++ if res.err != nil { ++ sc.conn.Close() ++ } ++ + wr := res.wr + + if writeEndsStream(wr.write) { +@@ -1594,6 +1637,11 @@ func (sc *serverConn) processFrame(f Frame) error { + func (sc *serverConn) processPing(f *PingFrame) error { + sc.serveG.check() + if f.IsAck() { ++ if sc.pingSent && sc.sentPingData == f.Data { ++ // This is a response to a PING we sent. ++ sc.pingSent = false ++ sc.readIdleTimer.Reset(sc.readIdleTimeout) ++ } + // 6.7 PING: " An endpoint MUST NOT respond to PING frames + // containing this flag." + return nil +@@ -1757,6 +1805,9 @@ func (sc *serverConn) processSetting(s Setting) error { + sc.maxFrameSize = int32(s.Val) // the maximum valid s.Val is < 2^31 + case SettingMaxHeaderListSize: + sc.peerMaxHeaderListSize = s.Val ++ case SettingEnableConnectProtocol: ++ // Receipt of this parameter by a server does not ++ // have any impact + default: + // Unknown setting: "An endpoint that receives a SETTINGS + // frame with any unknown or unsupported identifier MUST +@@ -2160,7 +2211,7 @@ func (sc *serverConn) newStream(id, pusherID uint32, state streamState) *stream + st.cw.Init() + st.flow.conn = &sc.flow // link to conn-level counter + st.flow.add(sc.initialStreamSendWindowSize) +- st.inflow.init(sc.srv.initialStreamRecvWindowSize()) ++ st.inflow.init(sc.initialStreamRecvWindowSize) + if sc.hs.WriteTimeout > 0 { + st.writeDeadline = sc.srv.afterFunc(sc.hs.WriteTimeout, st.onWriteTimeout) + } +@@ -2187,11 +2238,17 @@ func (sc *serverConn) newWriterAndRequest(st *stream, f *MetaHeadersFrame) (*res + scheme: f.PseudoValue("scheme"), + authority: f.PseudoValue("authority"), + path: f.PseudoValue("path"), ++ protocol: f.PseudoValue("protocol"), ++ } ++ ++ // extended connect is disabled, so we should not see :protocol ++ if disableExtendedConnectProtocol && rp.protocol != "" { ++ return nil, nil, sc.countError("bad_connect", streamError(f.StreamID, ErrCodeProtocol)) + } + + isConnect := rp.method == "CONNECT" + if isConnect { +- if rp.path != "" || rp.scheme != "" || rp.authority == "" { ++ if rp.protocol == "" && (rp.path != "" || rp.scheme != "" || rp.authority == "") { + return nil, nil, sc.countError("bad_connect", streamError(f.StreamID, ErrCodeProtocol)) + } + } else if rp.method == "" || rp.path == "" || (rp.scheme != "https" && rp.scheme != "http") { +@@ -2215,6 +2272,9 @@ func (sc *serverConn) newWriterAndRequest(st *stream, f *MetaHeadersFrame) (*res + if rp.authority == "" { + rp.authority = rp.header.Get("Host") + } ++ if rp.protocol != "" { ++ rp.header.Set(":protocol", rp.protocol) ++ } + + rw, req, err := sc.newWriterAndRequestNoBody(st, rp) + if err != nil { +@@ -2241,6 +2301,7 @@ func (sc *serverConn) newWriterAndRequest(st *stream, f *MetaHeadersFrame) (*res + type requestParam struct { + method string + scheme, authority, path string ++ protocol string + header http.Header + } + +@@ -2282,7 +2343,7 @@ func (sc *serverConn) newWriterAndRequestNoBody(st *stream, rp requestParam) (*r + + var url_ *url.URL + var requestURI string +- if rp.method == "CONNECT" { ++ if rp.method == "CONNECT" && rp.protocol == "" { + url_ = &url.URL{Host: rp.authority} + requestURI = rp.authority // mimic HTTP/1 server behavior + } else { +@@ -2855,6 +2916,11 @@ func (w *responseWriter) SetWriteDeadline(deadline time.Time) error { + return nil + } + ++func (w *responseWriter) EnableFullDuplex() error { ++ // We always support full duplex responses, so this is a no-op. ++ return nil ++} ++ + func (w *responseWriter) Flush() { + w.FlushError() + } +@@ -3301,7 +3367,7 @@ func (sc *serverConn) countError(name string, err error) error { + if sc == nil || sc.srv == nil { + return err + } +- f := sc.srv.CountError ++ f := sc.countErrorFunc + if f == nil { + return err + } +diff --git a/vendor/golang.org/x/net/http2/transport.go b/vendor/golang.org/x/net/http2/transport.go +index 61f511f..090d0e1 100644 +--- a/vendor/golang.org/x/net/http2/transport.go ++++ b/vendor/golang.org/x/net/http2/transport.go +@@ -25,7 +25,6 @@ import ( + "net/http" + "net/http/httptrace" + "net/textproto" +- "os" + "sort" + "strconv" + "strings" +@@ -203,6 +202,20 @@ func (t *Transport) markNewGoroutine() { + } + } + ++func (t *Transport) now() time.Time { ++ if t != nil && t.transportTestHooks != nil { ++ return t.transportTestHooks.group.Now() ++ } ++ return time.Now() ++} ++ ++func (t *Transport) timeSince(when time.Time) time.Duration { ++ if t != nil && t.transportTestHooks != nil { ++ return t.now().Sub(when) ++ } ++ return time.Since(when) ++} ++ + // newTimer creates a new time.Timer, or a synthetic timer in tests. + func (t *Transport) newTimer(d time.Duration) timer { + if t.transportTestHooks != nil { +@@ -227,40 +240,26 @@ func (t *Transport) contextWithTimeout(ctx context.Context, d time.Duration) (co + } + + func (t *Transport) maxHeaderListSize() uint32 { +- if t.MaxHeaderListSize == 0 { ++ n := int64(t.MaxHeaderListSize) ++ if t.t1 != nil && t.t1.MaxResponseHeaderBytes != 0 { ++ n = t.t1.MaxResponseHeaderBytes ++ if n > 0 { ++ n = adjustHTTP1MaxHeaderSize(n) ++ } ++ } ++ if n <= 0 { + return 10 << 20 + } +- if t.MaxHeaderListSize == 0xffffffff { ++ if n >= 0xffffffff { + return 0 + } +- return t.MaxHeaderListSize +-} +- +-func (t *Transport) maxFrameReadSize() uint32 { +- if t.MaxReadFrameSize == 0 { +- return 0 // use the default provided by the peer +- } +- if t.MaxReadFrameSize < minMaxFrameSize { +- return minMaxFrameSize +- } +- if t.MaxReadFrameSize > maxFrameSize { +- return maxFrameSize +- } +- return t.MaxReadFrameSize ++ return uint32(n) + } + + func (t *Transport) disableCompression() bool { + return t.DisableCompression || (t.t1 != nil && t.t1.DisableCompression) + } + +-func (t *Transport) pingTimeout() time.Duration { +- if t.PingTimeout == 0 { +- return 15 * time.Second +- } +- return t.PingTimeout +- +-} +- + // ConfigureTransport configures a net/http HTTP/1 Transport to use HTTP/2. + // It returns an error if t1 has already been HTTP/2-enabled. + // +@@ -296,8 +295,8 @@ func configureTransports(t1 *http.Transport) (*Transport, error) { + if !strSliceContains(t1.TLSClientConfig.NextProtos, "http/1.1") { + t1.TLSClientConfig.NextProtos = append(t1.TLSClientConfig.NextProtos, "http/1.1") + } +- upgradeFn := func(authority string, c *tls.Conn) http.RoundTripper { +- addr := authorityAddr("https", authority) ++ upgradeFn := func(scheme, authority string, c net.Conn) http.RoundTripper { ++ addr := authorityAddr(scheme, authority) + if used, err := connPool.addConnIfNeeded(addr, t2, c); err != nil { + go c.Close() + return erringRoundTripper{err} +@@ -308,18 +307,37 @@ func configureTransports(t1 *http.Transport) (*Transport, error) { + // was unknown) + go c.Close() + } ++ if scheme == "http" { ++ return (*unencryptedTransport)(t2) ++ } + return t2 + } +- if m := t1.TLSNextProto; len(m) == 0 { +- t1.TLSNextProto = map[string]func(string, *tls.Conn) http.RoundTripper{ +- "h2": upgradeFn, ++ if t1.TLSNextProto == nil { ++ t1.TLSNextProto = make(map[string]func(string, *tls.Conn) http.RoundTripper) ++ } ++ t1.TLSNextProto[NextProtoTLS] = func(authority string, c *tls.Conn) http.RoundTripper { ++ return upgradeFn("https", authority, c) ++ } ++ // The "unencrypted_http2" TLSNextProto key is used to pass off non-TLS HTTP/2 conns. ++ t1.TLSNextProto[nextProtoUnencryptedHTTP2] = func(authority string, c *tls.Conn) http.RoundTripper { ++ nc, err := unencryptedNetConnFromTLSConn(c) ++ if err != nil { ++ go c.Close() ++ return erringRoundTripper{err} + } +- } else { +- m["h2"] = upgradeFn ++ return upgradeFn("http", authority, nc) + } + return t2, nil + } + ++// unencryptedTransport is a Transport with a RoundTrip method that ++// always permits http:// URLs. ++type unencryptedTransport Transport ++ ++func (t *unencryptedTransport) RoundTrip(req *http.Request) (*http.Response, error) { ++ return (*Transport)(t).RoundTripOpt(req, RoundTripOpt{allowHTTP: true}) ++} ++ + func (t *Transport) connPool() ClientConnPool { + t.connPoolOnce.Do(t.initConnPool) + return t.connPoolOrDef +@@ -339,7 +357,7 @@ type ClientConn struct { + t *Transport + tconn net.Conn // usually *tls.Conn, except specialized impls + tlsState *tls.ConnectionState // nil only for specialized impls +- reused uint32 // whether conn is being reused; atomic ++ atomicReused uint32 // whether conn is being reused; atomic + singleUse bool // whether being used for a single http.Request + getConnCalled bool // used by clientConnPool + +@@ -350,31 +368,54 @@ type ClientConn struct { + idleTimeout time.Duration // or 0 for never + idleTimer timer + +- mu sync.Mutex // guards following +- cond *sync.Cond // hold mu; broadcast on flow/closed changes +- flow outflow // our conn-level flow control quota (cs.outflow is per stream) +- inflow inflow // peer's conn-level flow control +- doNotReuse bool // whether conn is marked to not be reused for any future requests +- closing bool +- closed bool +- seenSettings bool // true if we've seen a settings frame, false otherwise +- wantSettingsAck bool // we sent a SETTINGS frame and haven't heard back +- goAway *GoAwayFrame // if non-nil, the GoAwayFrame we received +- goAwayDebug string // goAway frame's debug data, retained as a string +- streams map[uint32]*clientStream // client-initiated +- streamsReserved int // incr by ReserveNewRequest; decr on RoundTrip +- nextStreamID uint32 +- pendingRequests int // requests blocked and waiting to be sent because len(streams) == maxConcurrentStreams +- pings map[[8]byte]chan struct{} // in flight ping data to notification channel +- br *bufio.Reader +- lastActive time.Time +- lastIdle time.Time // time last idle ++ mu sync.Mutex // guards following ++ cond *sync.Cond // hold mu; broadcast on flow/closed changes ++ flow outflow // our conn-level flow control quota (cs.outflow is per stream) ++ inflow inflow // peer's conn-level flow control ++ doNotReuse bool // whether conn is marked to not be reused for any future requests ++ closing bool ++ closed bool ++ seenSettings bool // true if we've seen a settings frame, false otherwise ++ seenSettingsChan chan struct{} // closed when seenSettings is true or frame reading fails ++ wantSettingsAck bool // we sent a SETTINGS frame and haven't heard back ++ goAway *GoAwayFrame // if non-nil, the GoAwayFrame we received ++ goAwayDebug string // goAway frame's debug data, retained as a string ++ streams map[uint32]*clientStream // client-initiated ++ streamsReserved int // incr by ReserveNewRequest; decr on RoundTrip ++ nextStreamID uint32 ++ pendingRequests int // requests blocked and waiting to be sent because len(streams) == maxConcurrentStreams ++ pings map[[8]byte]chan struct{} // in flight ping data to notification channel ++ br *bufio.Reader ++ lastActive time.Time ++ lastIdle time.Time // time last idle + // Settings from peer: (also guarded by wmu) +- maxFrameSize uint32 +- maxConcurrentStreams uint32 +- peerMaxHeaderListSize uint64 +- peerMaxHeaderTableSize uint32 +- initialWindowSize uint32 ++ maxFrameSize uint32 ++ maxConcurrentStreams uint32 ++ peerMaxHeaderListSize uint64 ++ peerMaxHeaderTableSize uint32 ++ initialWindowSize uint32 ++ initialStreamRecvWindowSize int32 ++ readIdleTimeout time.Duration ++ pingTimeout time.Duration ++ extendedConnectAllowed bool ++ ++ // rstStreamPingsBlocked works around an unfortunate gRPC behavior. ++ // gRPC strictly limits the number of PING frames that it will receive. ++ // The default is two pings per two hours, but the limit resets every time ++ // the gRPC endpoint sends a HEADERS or DATA frame. See golang/go#70575. ++ // ++ // rstStreamPingsBlocked is set after receiving a response to a PING frame ++ // bundled with an RST_STREAM (see pendingResets below), and cleared after ++ // receiving a HEADERS or DATA frame. ++ rstStreamPingsBlocked bool ++ ++ // pendingResets is the number of RST_STREAM frames we have sent to the peer, ++ // without confirming that the peer has received them. When we send a RST_STREAM, ++ // we bundle it with a PING frame, unless a PING is already in flight. We count ++ // the reset stream against the connection's concurrency limit until we get ++ // a PING response. This limits the number of requests we'll try to send to a ++ // completely unresponsive connection. ++ pendingResets int + + // reqHeaderMu is a 1-element semaphore channel controlling access to sending new requests. + // Write to reqHeaderMu to lock it, read from it to unlock. +@@ -432,12 +473,12 @@ type clientStream struct { + sentHeaders bool + + // owned by clientConnReadLoop: +- firstByte bool // got the first response byte +- pastHeaders bool // got first MetaHeadersFrame (actual headers) +- pastTrailers bool // got optional second MetaHeadersFrame (trailers) +- num1xx uint8 // number of 1xx responses seen +- readClosed bool // peer sent an END_STREAM flag +- readAborted bool // read loop reset the stream ++ firstByte bool // got the first response byte ++ pastHeaders bool // got first MetaHeadersFrame (actual headers) ++ pastTrailers bool // got optional second MetaHeadersFrame (trailers) ++ readClosed bool // peer sent an END_STREAM flag ++ readAborted bool // read loop reset the stream ++ totalHeaderSize int64 // total size of 1xx headers seen + + trailer http.Header // accumulated trailers + resTrailer *http.Header // client's Response.Trailer +@@ -499,6 +540,7 @@ func (cs *clientStream) closeReqBodyLocked() { + } + + type stickyErrWriter struct { ++ group synctestGroupInterface + conn net.Conn + timeout time.Duration + err *error +@@ -508,22 +550,9 @@ func (sew stickyErrWriter) Write(p []byte) (n int, err error) { + if *sew.err != nil { + return 0, *sew.err + } +- for { +- if sew.timeout != 0 { +- sew.conn.SetWriteDeadline(time.Now().Add(sew.timeout)) +- } +- nn, err := sew.conn.Write(p[n:]) +- n += nn +- if n < len(p) && nn > 0 && errors.Is(err, os.ErrDeadlineExceeded) { +- // Keep extending the deadline so long as we're making progress. +- continue +- } +- if sew.timeout != 0 { +- sew.conn.SetWriteDeadline(time.Time{}) +- } +- *sew.err = err +- return n, err +- } ++ n, err = writeWithByteTimeout(sew.group, sew.conn, sew.timeout, p) ++ *sew.err = err ++ return n, err + } + + // noCachedConnError is the concrete type of ErrNoCachedConn, which +@@ -554,6 +583,8 @@ type RoundTripOpt struct { + // no cached connection is available, RoundTripOpt + // will return ErrNoCachedConn. + OnlyCachedConn bool ++ ++ allowHTTP bool // allow http:// URLs + } + + func (t *Transport) RoundTrip(req *http.Request) (*http.Response, error) { +@@ -586,7 +617,14 @@ func authorityAddr(scheme string, authority string) (addr string) { + + // RoundTripOpt is like RoundTrip, but takes options. + func (t *Transport) RoundTripOpt(req *http.Request, opt RoundTripOpt) (*http.Response, error) { +- if !(req.URL.Scheme == "https" || (req.URL.Scheme == "http" && t.AllowHTTP)) { ++ switch req.URL.Scheme { ++ case "https": ++ // Always okay. ++ case "http": ++ if !t.AllowHTTP && !opt.allowHTTP { ++ return nil, errors.New("http2: unencrypted HTTP/2 not enabled") ++ } ++ default: + return nil, errors.New("http2: unsupported scheme") + } + +@@ -597,7 +635,7 @@ func (t *Transport) RoundTripOpt(req *http.Request, opt RoundTripOpt) (*http.Res + t.vlogf("http2: Transport failed to get client conn for %s: %v", addr, err) + return nil, err + } +- reused := !atomic.CompareAndSwapUint32(&cc.reused, 0, 1) ++ reused := !atomic.CompareAndSwapUint32(&cc.atomicReused, 0, 1) + traceGotConn(req, cc, reused) + res, err := cc.RoundTrip(req) + if err != nil && retry <= 6 { +@@ -622,6 +660,22 @@ func (t *Transport) RoundTripOpt(req *http.Request, opt RoundTripOpt) (*http.Res + } + } + } ++ if err == errClientConnNotEstablished { ++ // This ClientConn was created recently, ++ // this is the first request to use it, ++ // and the connection is closed and not usable. ++ // ++ // In this state, cc.idleTimer will remove the conn from the pool ++ // when it fires. Stop the timer and remove it here so future requests ++ // won't try to use this connection. ++ // ++ // If the timer has already fired and we're racing it, the redundant ++ // call to MarkDead is harmless. ++ if cc.idleTimer != nil { ++ cc.idleTimer.Stop() ++ } ++ t.connPool().MarkDead(cc) ++ } + if err != nil { + t.vlogf("RoundTrip failure: %v", err) + return nil, err +@@ -640,9 +694,10 @@ func (t *Transport) CloseIdleConnections() { + } + + var ( +- errClientConnClosed = errors.New("http2: client conn is closed") +- errClientConnUnusable = errors.New("http2: client conn not usable") +- errClientConnGotGoAway = errors.New("http2: Transport received Server's graceful shutdown GOAWAY") ++ errClientConnClosed = errors.New("http2: client conn is closed") ++ errClientConnUnusable = errors.New("http2: client conn not usable") ++ errClientConnNotEstablished = errors.New("http2: client conn could not be established") ++ errClientConnGotGoAway = errors.New("http2: Transport received Server's graceful shutdown GOAWAY") + ) + + // shouldRetryRequest is called by RoundTrip when a request fails to get +@@ -758,44 +813,38 @@ func (t *Transport) expectContinueTimeout() time.Duration { + return t.t1.ExpectContinueTimeout + } + +-func (t *Transport) maxDecoderHeaderTableSize() uint32 { +- if v := t.MaxDecoderHeaderTableSize; v > 0 { +- return v +- } +- return initialHeaderTableSize +-} +- +-func (t *Transport) maxEncoderHeaderTableSize() uint32 { +- if v := t.MaxEncoderHeaderTableSize; v > 0 { +- return v +- } +- return initialHeaderTableSize +-} +- + func (t *Transport) NewClientConn(c net.Conn) (*ClientConn, error) { + return t.newClientConn(c, t.disableKeepAlives()) + } + + func (t *Transport) newClientConn(c net.Conn, singleUse bool) (*ClientConn, error) { ++ conf := configFromTransport(t) + cc := &ClientConn{ +- t: t, +- tconn: c, +- readerDone: make(chan struct{}), +- nextStreamID: 1, +- maxFrameSize: 16 << 10, // spec default +- initialWindowSize: 65535, // spec default +- maxConcurrentStreams: initialMaxConcurrentStreams, // "infinite", per spec. Use a smaller value until we have received server settings. +- peerMaxHeaderListSize: 0xffffffffffffffff, // "infinite", per spec. Use 2^64-1 instead. +- streams: make(map[uint32]*clientStream), +- singleUse: singleUse, +- wantSettingsAck: true, +- pings: make(map[[8]byte]chan struct{}), +- reqHeaderMu: make(chan struct{}, 1), +- } ++ t: t, ++ tconn: c, ++ readerDone: make(chan struct{}), ++ nextStreamID: 1, ++ maxFrameSize: 16 << 10, // spec default ++ initialWindowSize: 65535, // spec default ++ initialStreamRecvWindowSize: conf.MaxUploadBufferPerStream, ++ maxConcurrentStreams: initialMaxConcurrentStreams, // "infinite", per spec. Use a smaller value until we have received server settings. ++ peerMaxHeaderListSize: 0xffffffffffffffff, // "infinite", per spec. Use 2^64-1 instead. ++ streams: make(map[uint32]*clientStream), ++ singleUse: singleUse, ++ seenSettingsChan: make(chan struct{}), ++ wantSettingsAck: true, ++ readIdleTimeout: conf.SendPingTimeout, ++ pingTimeout: conf.PingTimeout, ++ pings: make(map[[8]byte]chan struct{}), ++ reqHeaderMu: make(chan struct{}, 1), ++ lastActive: t.now(), ++ } ++ var group synctestGroupInterface + if t.transportTestHooks != nil { + t.markNewGoroutine() + t.transportTestHooks.newclientconn(cc) + c = cc.tconn ++ group = t.group + } + if VerboseLogs { + t.vlogf("http2: Transport creating client conn %p to %v", cc, c.RemoteAddr()) +@@ -807,24 +856,23 @@ func (t *Transport) newClientConn(c net.Conn, singleUse bool) (*ClientConn, erro + // TODO: adjust this writer size to account for frame size + + // MTU + crypto/tls record padding. + cc.bw = bufio.NewWriter(stickyErrWriter{ ++ group: group, + conn: c, +- timeout: t.WriteByteTimeout, ++ timeout: conf.WriteByteTimeout, + err: &cc.werr, + }) + cc.br = bufio.NewReader(c) + cc.fr = NewFramer(cc.bw, cc.br) +- if t.maxFrameReadSize() != 0 { +- cc.fr.SetMaxReadFrameSize(t.maxFrameReadSize()) +- } ++ cc.fr.SetMaxReadFrameSize(conf.MaxReadFrameSize) + if t.CountError != nil { + cc.fr.countError = t.CountError + } +- maxHeaderTableSize := t.maxDecoderHeaderTableSize() ++ maxHeaderTableSize := conf.MaxDecoderHeaderTableSize + cc.fr.ReadMetaHeaders = hpack.NewDecoder(maxHeaderTableSize, nil) + cc.fr.MaxHeaderListSize = t.maxHeaderListSize() + + cc.henc = hpack.NewEncoder(&cc.hbuf) +- cc.henc.SetMaxDynamicTableSizeLimit(t.maxEncoderHeaderTableSize()) ++ cc.henc.SetMaxDynamicTableSizeLimit(conf.MaxEncoderHeaderTableSize) + cc.peerMaxHeaderTableSize = initialHeaderTableSize + + if cs, ok := c.(connectionStater); ok { +@@ -834,11 +882,9 @@ func (t *Transport) newClientConn(c net.Conn, singleUse bool) (*ClientConn, erro + + initialSettings := []Setting{ + {ID: SettingEnablePush, Val: 0}, +- {ID: SettingInitialWindowSize, Val: transportDefaultStreamFlow}, +- } +- if max := t.maxFrameReadSize(); max != 0 { +- initialSettings = append(initialSettings, Setting{ID: SettingMaxFrameSize, Val: max}) ++ {ID: SettingInitialWindowSize, Val: uint32(cc.initialStreamRecvWindowSize)}, + } ++ initialSettings = append(initialSettings, Setting{ID: SettingMaxFrameSize, Val: conf.MaxReadFrameSize}) + if max := t.maxHeaderListSize(); max != 0 { + initialSettings = append(initialSettings, Setting{ID: SettingMaxHeaderListSize, Val: max}) + } +@@ -848,8 +894,8 @@ func (t *Transport) newClientConn(c net.Conn, singleUse bool) (*ClientConn, erro + + cc.bw.Write(clientPreface) + cc.fr.WriteSettings(initialSettings...) +- cc.fr.WriteWindowUpdate(0, transportDefaultConnFlow) +- cc.inflow.init(transportDefaultConnFlow + initialWindowSize) ++ cc.fr.WriteWindowUpdate(0, uint32(conf.MaxUploadBufferPerConnection)) ++ cc.inflow.init(conf.MaxUploadBufferPerConnection + initialWindowSize) + cc.bw.Flush() + if cc.werr != nil { + cc.Close() +@@ -867,7 +913,7 @@ func (t *Transport) newClientConn(c net.Conn, singleUse bool) (*ClientConn, erro + } + + func (cc *ClientConn) healthCheck() { +- pingTimeout := cc.t.pingTimeout() ++ pingTimeout := cc.pingTimeout + // We don't need to periodically ping in the health check, because the readLoop of ClientConn will + // trigger the healthCheck again if there is no frame received. + ctx, cancel := cc.t.contextWithTimeout(context.Background(), pingTimeout) +@@ -995,7 +1041,7 @@ func (cc *ClientConn) State() ClientConnState { + return ClientConnState{ + Closed: cc.closed, + Closing: cc.closing || cc.singleUse || cc.doNotReuse || cc.goAway != nil, +- StreamsActive: len(cc.streams), ++ StreamsActive: len(cc.streams) + cc.pendingResets, + StreamsReserved: cc.streamsReserved, + StreamsPending: cc.pendingRequests, + LastIdle: cc.lastIdle, +@@ -1027,16 +1073,38 @@ func (cc *ClientConn) idleStateLocked() (st clientConnIdleState) { + // writing it. + maxConcurrentOkay = true + } else { +- maxConcurrentOkay = int64(len(cc.streams)+cc.streamsReserved+1) <= int64(cc.maxConcurrentStreams) ++ // We can take a new request if the total of ++ // - active streams; ++ // - reservation slots for new streams; and ++ // - streams for which we have sent a RST_STREAM and a PING, ++ // but received no subsequent frame ++ // is less than the concurrency limit. ++ maxConcurrentOkay = cc.currentRequestCountLocked() < int(cc.maxConcurrentStreams) + } + + st.canTakeNewRequest = cc.goAway == nil && !cc.closed && !cc.closing && maxConcurrentOkay && + !cc.doNotReuse && + int64(cc.nextStreamID)+2*int64(cc.pendingRequests) < math.MaxInt32 && + !cc.tooIdleLocked() ++ ++ // If this connection has never been used for a request and is closed, ++ // then let it take a request (which will fail). ++ // ++ // This avoids a situation where an error early in a connection's lifetime ++ // goes unreported. ++ if cc.nextStreamID == 1 && cc.streamsReserved == 0 && cc.closed { ++ st.canTakeNewRequest = true ++ } ++ + return + } + ++// currentRequestCountLocked reports the number of concurrency slots currently in use, ++// including active streams, reserved slots, and reset streams waiting for acknowledgement. ++func (cc *ClientConn) currentRequestCountLocked() int { ++ return len(cc.streams) + cc.streamsReserved + cc.pendingResets ++} ++ + func (cc *ClientConn) canTakeNewRequestLocked() bool { + st := cc.idleStateLocked() + return st.canTakeNewRequest +@@ -1049,7 +1117,7 @@ func (cc *ClientConn) tooIdleLocked() bool { + // times are compared based on their wall time. We don't want + // to reuse a connection that's been sitting idle during + // VM/laptop suspend if monotonic time was also frozen. +- return cc.idleTimeout != 0 && !cc.lastIdle.IsZero() && time.Since(cc.lastIdle.Round(0)) > cc.idleTimeout ++ return cc.idleTimeout != 0 && !cc.lastIdle.IsZero() && cc.t.timeSince(cc.lastIdle.Round(0)) > cc.idleTimeout + } + + // onIdleTimeout is called from a time.AfterFunc goroutine. It will +@@ -1411,6 +1479,8 @@ func (cs *clientStream) doRequest(req *http.Request, streamf func(*clientStream) + cs.cleanupWriteRequest(err) + } + ++var errExtendedConnectNotSupported = errors.New("net/http: extended connect not supported by peer") ++ + // writeRequest sends a request. + // + // It returns nil after the request is written, the response read, +@@ -1426,12 +1496,31 @@ func (cs *clientStream) writeRequest(req *http.Request, streamf func(*clientStre + return err + } + ++ // wait for setting frames to be received, a server can change this value later, ++ // but we just wait for the first settings frame ++ var isExtendedConnect bool ++ if req.Method == "CONNECT" && req.Header.Get(":protocol") != "" { ++ isExtendedConnect = true ++ } ++ + // Acquire the new-request lock by writing to reqHeaderMu. + // This lock guards the critical section covering allocating a new stream ID + // (requires mu) and creating the stream (requires wmu). + if cc.reqHeaderMu == nil { + panic("RoundTrip on uninitialized ClientConn") // for tests + } ++ if isExtendedConnect { ++ select { ++ case <-cs.reqCancel: ++ return errRequestCanceled ++ case <-ctx.Done(): ++ return ctx.Err() ++ case <-cc.seenSettingsChan: ++ if !cc.extendedConnectAllowed { ++ return errExtendedConnectNotSupported ++ } ++ } ++ } + select { + case cc.reqHeaderMu <- struct{}{}: + case <-cs.reqCancel: +@@ -1613,6 +1702,7 @@ func (cs *clientStream) cleanupWriteRequest(err error) { + cs.reqBodyClosed = make(chan struct{}) + } + bodyClosed := cs.reqBodyClosed ++ closeOnIdle := cc.singleUse || cc.doNotReuse || cc.t.disableKeepAlives() || cc.goAway != nil + cc.mu.Unlock() + if mustCloseBody { + cs.reqBody.Close() +@@ -1637,16 +1727,44 @@ func (cs *clientStream) cleanupWriteRequest(err error) { + if cs.sentHeaders { + if se, ok := err.(StreamError); ok { + if se.Cause != errFromPeer { +- cc.writeStreamReset(cs.ID, se.Code, err) ++ cc.writeStreamReset(cs.ID, se.Code, false, err) + } + } else { +- cc.writeStreamReset(cs.ID, ErrCodeCancel, err) ++ // We're cancelling an in-flight request. ++ // ++ // This could be due to the server becoming unresponsive. ++ // To avoid sending too many requests on a dead connection, ++ // we let the request continue to consume a concurrency slot ++ // until we can confirm the server is still responding. ++ // We do this by sending a PING frame along with the RST_STREAM ++ // (unless a ping is already in flight). ++ // ++ // For simplicity, we don't bother tracking the PING payload: ++ // We reset cc.pendingResets any time we receive a PING ACK. ++ // ++ // We skip this if the conn is going to be closed on idle, ++ // because it's short lived and will probably be closed before ++ // we get the ping response. ++ ping := false ++ if !closeOnIdle { ++ cc.mu.Lock() ++ // rstStreamPingsBlocked works around a gRPC behavior: ++ // see comment on the field for details. ++ if !cc.rstStreamPingsBlocked { ++ if cc.pendingResets == 0 { ++ ping = true ++ } ++ cc.pendingResets++ ++ } ++ cc.mu.Unlock() ++ } ++ cc.writeStreamReset(cs.ID, ErrCodeCancel, ping, err) + } + } + cs.bufPipe.CloseWithError(err) // no-op if already closed + } else { + if cs.sentHeaders && !cs.sentEndStream { +- cc.writeStreamReset(cs.ID, ErrCodeNo, nil) ++ cc.writeStreamReset(cs.ID, ErrCodeNo, false, nil) + } + cs.bufPipe.CloseWithError(errRequestCanceled) + } +@@ -1668,12 +1786,17 @@ func (cs *clientStream) cleanupWriteRequest(err error) { + // Must hold cc.mu. + func (cc *ClientConn) awaitOpenSlotForStreamLocked(cs *clientStream) error { + for { +- cc.lastActive = time.Now() ++ if cc.closed && cc.nextStreamID == 1 && cc.streamsReserved == 0 { ++ // This is the very first request sent to this connection. ++ // Return a fatal error which aborts the retry loop. ++ return errClientConnNotEstablished ++ } ++ cc.lastActive = cc.t.now() + if cc.closed || !cc.canTakeNewRequestLocked() { + return errClientConnUnusable + } + cc.lastIdle = time.Time{} +- if int64(len(cc.streams)) < int64(cc.maxConcurrentStreams) { ++ if cc.currentRequestCountLocked() < int(cc.maxConcurrentStreams) { + return nil + } + cc.pendingRequests++ +@@ -1945,7 +2068,7 @@ func (cs *clientStream) awaitFlowControl(maxBytes int) (taken int32, err error) + + func validateHeaders(hdrs http.Header) string { + for k, vv := range hdrs { +- if !httpguts.ValidHeaderFieldName(k) { ++ if !httpguts.ValidHeaderFieldName(k) && k != ":protocol" { + return fmt.Sprintf("name %q", k) + } + for _, v := range vv { +@@ -1961,6 +2084,10 @@ func validateHeaders(hdrs http.Header) string { + + var errNilRequestURL = errors.New("http2: Request.URI is nil") + ++func isNormalConnect(req *http.Request) bool { ++ return req.Method == "CONNECT" && req.Header.Get(":protocol") == "" ++} ++ + // requires cc.wmu be held. + func (cc *ClientConn) encodeHeaders(req *http.Request, addGzipHeader bool, trailers string, contentLength int64) ([]byte, error) { + cc.hbuf.Reset() +@@ -1981,7 +2108,7 @@ func (cc *ClientConn) encodeHeaders(req *http.Request, addGzipHeader bool, trail + } + + var path string +- if req.Method != "CONNECT" { ++ if !isNormalConnect(req) { + path = req.URL.RequestURI() + if !validPseudoPath(path) { + orig := path +@@ -2018,7 +2145,7 @@ func (cc *ClientConn) encodeHeaders(req *http.Request, addGzipHeader bool, trail + m = http.MethodGet + } + f(":method", m) +- if req.Method != "CONNECT" { ++ if !isNormalConnect(req) { + f(":path", path) + f(":scheme", req.URL.Scheme) + } +@@ -2199,7 +2326,7 @@ type resAndError struct { + func (cc *ClientConn) addStreamLocked(cs *clientStream) { + cs.flow.add(int32(cc.initialWindowSize)) + cs.flow.setConnFlow(&cc.flow) +- cs.inflow.init(transportDefaultStreamFlow) ++ cs.inflow.init(cc.initialStreamRecvWindowSize) + cs.ID = cc.nextStreamID + cc.nextStreamID += 2 + cc.streams[cs.ID] = cs +@@ -2215,10 +2342,10 @@ func (cc *ClientConn) forgetStreamID(id uint32) { + if len(cc.streams) != slen-1 { + panic("forgetting unknown stream id") + } +- cc.lastActive = time.Now() ++ cc.lastActive = cc.t.now() + if len(cc.streams) == 0 && cc.idleTimer != nil { + cc.idleTimer.Reset(cc.idleTimeout) +- cc.lastIdle = time.Now() ++ cc.lastIdle = cc.t.now() + } + // Wake up writeRequestBody via clientStream.awaitFlowControl and + // wake up RoundTrip if there is a pending request. +@@ -2278,7 +2405,6 @@ func isEOFOrNetReadError(err error) bool { + + func (rl *clientConnReadLoop) cleanup() { + cc := rl.cc +- cc.t.connPool().MarkDead(cc) + defer cc.closeConn() + defer close(cc.readerDone) + +@@ -2302,6 +2428,24 @@ func (rl *clientConnReadLoop) cleanup() { + } + cc.closed = true + ++ // If the connection has never been used, and has been open for only a short time, ++ // leave it in the connection pool for a little while. ++ // ++ // This avoids a situation where new connections are constantly created, ++ // added to the pool, fail, and are removed from the pool, without any error ++ // being surfaced to the user. ++ const unusedWaitTime = 5 * time.Second ++ idleTime := cc.t.now().Sub(cc.lastActive) ++ if atomic.LoadUint32(&cc.atomicReused) == 0 && idleTime < unusedWaitTime { ++ cc.idleTimer = cc.t.afterFunc(unusedWaitTime-idleTime, func() { ++ cc.t.connPool().MarkDead(cc) ++ }) ++ } else { ++ cc.mu.Unlock() // avoid any deadlocks in MarkDead ++ cc.t.connPool().MarkDead(cc) ++ cc.mu.Lock() ++ } ++ + for _, cs := range cc.streams { + select { + case <-cs.peerClosed: +@@ -2345,7 +2489,7 @@ func (cc *ClientConn) countReadFrameError(err error) { + func (rl *clientConnReadLoop) run() error { + cc := rl.cc + gotSettings := false +- readIdleTimeout := cc.t.ReadIdleTimeout ++ readIdleTimeout := cc.readIdleTimeout + var t timer + if readIdleTimeout != 0 { + t = cc.t.afterFunc(readIdleTimeout, cc.healthCheck) +@@ -2359,7 +2503,7 @@ func (rl *clientConnReadLoop) run() error { + cc.vlogf("http2: Transport readFrame error on conn %p: (%T) %v", cc, err, err) + } + if se, ok := err.(StreamError); ok { +- if cs := rl.streamByID(se.StreamID); cs != nil { ++ if cs := rl.streamByID(se.StreamID, notHeaderOrDataFrame); cs != nil { + if se.Cause == nil { + se.Cause = cc.fr.errDetail + } +@@ -2405,13 +2549,16 @@ func (rl *clientConnReadLoop) run() error { + if VerboseLogs { + cc.vlogf("http2: Transport conn %p received error from processing frame %v: %v", cc, summarizeFrame(f), err) + } ++ if !cc.seenSettings { ++ close(cc.seenSettingsChan) ++ } + return err + } + } + } + + func (rl *clientConnReadLoop) processHeaders(f *MetaHeadersFrame) error { +- cs := rl.streamByID(f.StreamID) ++ cs := rl.streamByID(f.StreamID, headerOrDataFrame) + if cs == nil { + // We'd get here if we canceled a request while the + // server had its response still in flight. So if this +@@ -2529,15 +2676,34 @@ func (rl *clientConnReadLoop) handleResponse(cs *clientStream, f *MetaHeadersFra + if f.StreamEnded() { + return nil, errors.New("1xx informational response with END_STREAM flag") + } +- cs.num1xx++ +- const max1xxResponses = 5 // arbitrary bound on number of informational responses, same as net/http +- if cs.num1xx > max1xxResponses { +- return nil, errors.New("http2: too many 1xx informational responses") +- } + if fn := cs.get1xxTraceFunc(); fn != nil { ++ // If the 1xx response is being delivered to the user, ++ // then they're responsible for limiting the number ++ // of responses. + if err := fn(statusCode, textproto.MIMEHeader(header)); err != nil { + return nil, err + } ++ } else { ++ // If the user didn't examine the 1xx response, then we ++ // limit the size of all 1xx headers. ++ // ++ // This differs a bit from the HTTP/1 implementation, which ++ // limits the size of all 1xx headers plus the final response. ++ // Use the larger limit of MaxHeaderListSize and ++ // net/http.Transport.MaxResponseHeaderBytes. ++ limit := int64(cs.cc.t.maxHeaderListSize()) ++ if t1 := cs.cc.t.t1; t1 != nil && t1.MaxResponseHeaderBytes > limit { ++ limit = t1.MaxResponseHeaderBytes ++ } ++ for _, h := range f.Fields { ++ cs.totalHeaderSize += int64(h.Size()) ++ } ++ if cs.totalHeaderSize > limit { ++ if VerboseLogs { ++ log.Printf("http2: 1xx informational responses too large") ++ } ++ return nil, errors.New("header list too large") ++ } + } + if statusCode == 100 { + traceGot100Continue(cs.trace) +@@ -2721,7 +2887,7 @@ func (b transportResponseBody) Close() error { + + func (rl *clientConnReadLoop) processData(f *DataFrame) error { + cc := rl.cc +- cs := rl.streamByID(f.StreamID) ++ cs := rl.streamByID(f.StreamID, headerOrDataFrame) + data := f.Data() + if cs == nil { + cc.mu.Lock() +@@ -2856,9 +3022,22 @@ func (rl *clientConnReadLoop) endStreamError(cs *clientStream, err error) { + cs.abortStream(err) + } + +-func (rl *clientConnReadLoop) streamByID(id uint32) *clientStream { ++// Constants passed to streamByID for documentation purposes. ++const ( ++ headerOrDataFrame = true ++ notHeaderOrDataFrame = false ++) ++ ++// streamByID returns the stream with the given id, or nil if no stream has that id. ++// If headerOrData is true, it clears rst.StreamPingsBlocked. ++func (rl *clientConnReadLoop) streamByID(id uint32, headerOrData bool) *clientStream { + rl.cc.mu.Lock() + defer rl.cc.mu.Unlock() ++ if headerOrData { ++ // Work around an unfortunate gRPC behavior. ++ // See comment on ClientConn.rstStreamPingsBlocked for details. ++ rl.cc.rstStreamPingsBlocked = false ++ } + cs := rl.cc.streams[id] + if cs != nil && !cs.readAborted { + return cs +@@ -2952,6 +3131,21 @@ func (rl *clientConnReadLoop) processSettingsNoWrite(f *SettingsFrame) error { + case SettingHeaderTableSize: + cc.henc.SetMaxDynamicTableSize(s.Val) + cc.peerMaxHeaderTableSize = s.Val ++ case SettingEnableConnectProtocol: ++ if err := s.Valid(); err != nil { ++ return err ++ } ++ // If the peer wants to send us SETTINGS_ENABLE_CONNECT_PROTOCOL, ++ // we require that it do so in the first SETTINGS frame. ++ // ++ // When we attempt to use extended CONNECT, we wait for the first ++ // SETTINGS frame to see if the server supports it. If we let the ++ // server enable the feature with a later SETTINGS frame, then ++ // users will see inconsistent results depending on whether we've ++ // seen that frame or not. ++ if !cc.seenSettings { ++ cc.extendedConnectAllowed = s.Val == 1 ++ } + default: + cc.vlogf("Unhandled Setting: %v", s) + } +@@ -2969,6 +3163,7 @@ func (rl *clientConnReadLoop) processSettingsNoWrite(f *SettingsFrame) error { + // connection can establish to our default. + cc.maxConcurrentStreams = defaultMaxConcurrentStreams + } ++ close(cc.seenSettingsChan) + cc.seenSettings = true + } + +@@ -2977,7 +3172,7 @@ func (rl *clientConnReadLoop) processSettingsNoWrite(f *SettingsFrame) error { + + func (rl *clientConnReadLoop) processWindowUpdate(f *WindowUpdateFrame) error { + cc := rl.cc +- cs := rl.streamByID(f.StreamID) ++ cs := rl.streamByID(f.StreamID, notHeaderOrDataFrame) + if f.StreamID != 0 && cs == nil { + return nil + } +@@ -3006,7 +3201,7 @@ func (rl *clientConnReadLoop) processWindowUpdate(f *WindowUpdateFrame) error { + } + + func (rl *clientConnReadLoop) processResetStream(f *RSTStreamFrame) error { +- cs := rl.streamByID(f.StreamID) ++ cs := rl.streamByID(f.StreamID, notHeaderOrDataFrame) + if cs == nil { + // TODO: return error if server tries to RST_STREAM an idle stream + return nil +@@ -3081,6 +3276,12 @@ func (rl *clientConnReadLoop) processPing(f *PingFrame) error { + close(c) + delete(cc.pings, f.Data) + } ++ if cc.pendingResets > 0 { ++ // See clientStream.cleanupWriteRequest. ++ cc.pendingResets = 0 ++ cc.rstStreamPingsBlocked = true ++ cc.cond.Broadcast() ++ } + return nil + } + cc := rl.cc +@@ -3103,13 +3304,20 @@ func (rl *clientConnReadLoop) processPushPromise(f *PushPromiseFrame) error { + return ConnectionError(ErrCodeProtocol) + } + +-func (cc *ClientConn) writeStreamReset(streamID uint32, code ErrCode, err error) { ++// writeStreamReset sends a RST_STREAM frame. ++// When ping is true, it also sends a PING frame with a random payload. ++func (cc *ClientConn) writeStreamReset(streamID uint32, code ErrCode, ping bool, err error) { + // TODO: map err to more interesting error codes, once the + // HTTP community comes up with some. But currently for + // RST_STREAM there's no equivalent to GOAWAY frame's debug + // data, and the error codes are all pretty vague ("cancel"). + cc.wmu.Lock() + cc.fr.WriteRSTStream(streamID, code) ++ if ping { ++ var payload [8]byte ++ rand.Read(payload[:]) ++ cc.fr.WritePing(false, payload) ++ } + cc.bw.Flush() + cc.wmu.Unlock() + } +@@ -3263,7 +3471,7 @@ func traceGotConn(req *http.Request, cc *ClientConn, reused bool) { + cc.mu.Lock() + ci.WasIdle = len(cc.streams) == 0 && reused + if ci.WasIdle && !cc.lastActive.IsZero() { +- ci.IdleTime = time.Since(cc.lastActive) ++ ci.IdleTime = cc.t.timeSince(cc.lastActive) + } + cc.mu.Unlock() + +diff --git a/vendor/golang.org/x/net/http2/unencrypted.go b/vendor/golang.org/x/net/http2/unencrypted.go +new file mode 100644 +index 0000000..b2de211 +--- /dev/null ++++ b/vendor/golang.org/x/net/http2/unencrypted.go +@@ -0,0 +1,32 @@ ++// Copyright 2024 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 http2 ++ ++import ( ++ "crypto/tls" ++ "errors" ++ "net" ++) ++ ++const nextProtoUnencryptedHTTP2 = "unencrypted_http2" ++ ++// unencryptedNetConnFromTLSConn retrieves a net.Conn wrapped in a *tls.Conn. ++// ++// TLSNextProto functions accept a *tls.Conn. ++// ++// When passing an unencrypted HTTP/2 connection to a TLSNextProto function, ++// we pass a *tls.Conn with an underlying net.Conn containing the unencrypted connection. ++// To be extra careful about mistakes (accidentally dropping TLS encryption in a place ++// where we want it), the tls.Conn contains a net.Conn with an UnencryptedNetConn method ++// that returns the actual connection we want to use. ++func unencryptedNetConnFromTLSConn(tc *tls.Conn) (net.Conn, error) { ++ conner, ok := tc.NetConn().(interface { ++ UnencryptedNetConn() net.Conn ++ }) ++ if !ok { ++ return nil, errors.New("http2: TLS conn unexpectedly found in unencrypted handoff") ++ } ++ return conner.UnencryptedNetConn(), nil ++} +diff --git a/vendor/golang.org/x/net/http2/write.go b/vendor/golang.org/x/net/http2/write.go +index 33f6139..6ff6bee 100644 +--- a/vendor/golang.org/x/net/http2/write.go ++++ b/vendor/golang.org/x/net/http2/write.go +@@ -131,6 +131,16 @@ func (se StreamError) writeFrame(ctx writeContext) error { + + func (se StreamError) staysWithinBuffer(max int) bool { return frameHeaderLen+4 <= max } + ++type writePing struct { ++ data [8]byte ++} ++ ++func (w writePing) writeFrame(ctx writeContext) error { ++ return ctx.Framer().WritePing(false, w.data) ++} ++ ++func (w writePing) staysWithinBuffer(max int) bool { return frameHeaderLen+len(w.data) <= max } ++ + type writePingAck struct{ pf *PingFrame } + + func (w writePingAck) writeFrame(ctx writeContext) error { +diff --git a/vendor/golang.org/x/sys/unix/README.md b/vendor/golang.org/x/sys/unix/README.md +index 7d3c060..6e08a76 100644 +--- a/vendor/golang.org/x/sys/unix/README.md ++++ b/vendor/golang.org/x/sys/unix/README.md +@@ -156,7 +156,7 @@ from the generated architecture-specific files listed below, and merge these + into a common file for each OS. + + The merge is performed in the following steps: +-1. Construct the set of common code that is idential in all architecture-specific files. ++1. Construct the set of common code that is identical in all architecture-specific files. + 2. Write this common code to the merged file. + 3. Remove the common code from all architecture-specific files. + +diff --git a/vendor/golang.org/x/sys/unix/ioctl_linux.go b/vendor/golang.org/x/sys/unix/ioctl_linux.go +index dbe680e..7ca4fa1 100644 +--- a/vendor/golang.org/x/sys/unix/ioctl_linux.go ++++ b/vendor/golang.org/x/sys/unix/ioctl_linux.go +@@ -58,6 +58,102 @@ func IoctlGetEthtoolDrvinfo(fd int, ifname string) (*EthtoolDrvinfo, error) { + return &value, err + } + ++// IoctlGetEthtoolTsInfo fetches ethtool timestamping and PHC ++// association for the network device specified by ifname. ++func IoctlGetEthtoolTsInfo(fd int, ifname string) (*EthtoolTsInfo, error) { ++ ifr, err := NewIfreq(ifname) ++ if err != nil { ++ return nil, err ++ } ++ ++ value := EthtoolTsInfo{Cmd: ETHTOOL_GET_TS_INFO} ++ ifrd := ifr.withData(unsafe.Pointer(&value)) ++ ++ err = ioctlIfreqData(fd, SIOCETHTOOL, &ifrd) ++ return &value, err ++} ++ ++// IoctlGetHwTstamp retrieves the hardware timestamping configuration ++// for the network device specified by ifname. ++func IoctlGetHwTstamp(fd int, ifname string) (*HwTstampConfig, error) { ++ ifr, err := NewIfreq(ifname) ++ if err != nil { ++ return nil, err ++ } ++ ++ value := HwTstampConfig{} ++ ifrd := ifr.withData(unsafe.Pointer(&value)) ++ ++ err = ioctlIfreqData(fd, SIOCGHWTSTAMP, &ifrd) ++ return &value, err ++} ++ ++// IoctlSetHwTstamp updates the hardware timestamping configuration for ++// the network device specified by ifname. ++func IoctlSetHwTstamp(fd int, ifname string, cfg *HwTstampConfig) error { ++ ifr, err := NewIfreq(ifname) ++ if err != nil { ++ return err ++ } ++ ifrd := ifr.withData(unsafe.Pointer(cfg)) ++ return ioctlIfreqData(fd, SIOCSHWTSTAMP, &ifrd) ++} ++ ++// FdToClockID derives the clock ID from the file descriptor number ++// - see clock_gettime(3), FD_TO_CLOCKID macros. The resulting ID is ++// suitable for system calls like ClockGettime. ++func FdToClockID(fd int) int32 { return int32((int(^fd) << 3) | 3) } ++ ++// IoctlPtpClockGetcaps returns the description of a given PTP device. ++func IoctlPtpClockGetcaps(fd int) (*PtpClockCaps, error) { ++ var value PtpClockCaps ++ err := ioctlPtr(fd, PTP_CLOCK_GETCAPS2, unsafe.Pointer(&value)) ++ return &value, err ++} ++ ++// IoctlPtpSysOffsetPrecise returns a description of the clock ++// offset compared to the system clock. ++func IoctlPtpSysOffsetPrecise(fd int) (*PtpSysOffsetPrecise, error) { ++ var value PtpSysOffsetPrecise ++ err := ioctlPtr(fd, PTP_SYS_OFFSET_PRECISE2, unsafe.Pointer(&value)) ++ return &value, err ++} ++ ++// IoctlPtpSysOffsetExtended returns an extended description of the ++// clock offset compared to the system clock. The samples parameter ++// specifies the desired number of measurements. ++func IoctlPtpSysOffsetExtended(fd int, samples uint) (*PtpSysOffsetExtended, error) { ++ value := PtpSysOffsetExtended{Samples: uint32(samples)} ++ err := ioctlPtr(fd, PTP_SYS_OFFSET_EXTENDED2, unsafe.Pointer(&value)) ++ return &value, err ++} ++ ++// IoctlPtpPinGetfunc returns the configuration of the specified ++// I/O pin on given PTP device. ++func IoctlPtpPinGetfunc(fd int, index uint) (*PtpPinDesc, error) { ++ value := PtpPinDesc{Index: uint32(index)} ++ err := ioctlPtr(fd, PTP_PIN_GETFUNC2, unsafe.Pointer(&value)) ++ return &value, err ++} ++ ++// IoctlPtpPinSetfunc updates configuration of the specified PTP ++// I/O pin. ++func IoctlPtpPinSetfunc(fd int, pd *PtpPinDesc) error { ++ return ioctlPtr(fd, PTP_PIN_SETFUNC2, unsafe.Pointer(pd)) ++} ++ ++// IoctlPtpPeroutRequest configures the periodic output mode of the ++// PTP I/O pins. ++func IoctlPtpPeroutRequest(fd int, r *PtpPeroutRequest) error { ++ return ioctlPtr(fd, PTP_PEROUT_REQUEST2, unsafe.Pointer(r)) ++} ++ ++// IoctlPtpExttsRequest configures the external timestamping mode ++// of the PTP I/O pins. ++func IoctlPtpExttsRequest(fd int, r *PtpExttsRequest) error { ++ return ioctlPtr(fd, PTP_EXTTS_REQUEST2, unsafe.Pointer(r)) ++} ++ + // IoctlGetWatchdogInfo fetches information about a watchdog device from the + // Linux watchdog API. For more information, see: + // https://www.kernel.org/doc/html/latest/watchdog/watchdog-api.html. +diff --git a/vendor/golang.org/x/sys/unix/mkerrors.sh b/vendor/golang.org/x/sys/unix/mkerrors.sh +index d07dd09..6ab02b6 100644 +--- a/vendor/golang.org/x/sys/unix/mkerrors.sh ++++ b/vendor/golang.org/x/sys/unix/mkerrors.sh +@@ -158,6 +158,16 @@ includes_Linux=' + #endif + #define _GNU_SOURCE + ++// See the description in unix/linux/types.go ++#if defined(__ARM_EABI__) || \ ++ (defined(__mips__) && (_MIPS_SIM == _ABIO32)) || \ ++ (defined(__powerpc__) && (!defined(__powerpc64__))) ++# ifdef _TIME_BITS ++# undef _TIME_BITS ++# endif ++# define _TIME_BITS 32 ++#endif ++ + // is broken on powerpc64, as it fails to include definitions of + // these structures. We just include them copied from . + #if defined(__powerpc__) +@@ -256,6 +266,7 @@ struct ltchars { + #include + #include + #include ++#include + #include + #include + #include +@@ -527,6 +538,7 @@ ccflags="$@" + $2 ~ /^(AF|SOCK|SO|SOL|IPPROTO|IP|IPV6|TCP|MCAST|EVFILT|NOTE|SHUT|PROT|MAP|MREMAP|MFD|T?PACKET|MSG|SCM|MCL|DT|MADV|PR|LOCAL|TCPOPT|UDP)_/ || + $2 ~ /^NFC_(GENL|PROTO|COMM|RF|SE|DIRECTION|LLCP|SOCKPROTO)_/ || + $2 ~ /^NFC_.*_(MAX)?SIZE$/ || ++ $2 ~ /^PTP_/ || + $2 ~ /^RAW_PAYLOAD_/ || + $2 ~ /^[US]F_/ || + $2 ~ /^TP_STATUS_/ || +@@ -552,6 +564,7 @@ ccflags="$@" + $2 !~ /^RTC_VL_(ACCURACY|BACKUP|DATA)/ && + $2 ~ /^(NETLINK|NLM|NLMSG|NLA|IFA|IFAN|RT|RTC|RTCF|RTN|RTPROT|RTNH|ARPHRD|ETH_P|NETNSA)_/ || + $2 ~ /^SOCK_|SK_DIAG_|SKNLGRP_$/ || ++ $2 ~ /^(CONNECT|SAE)_/ || + $2 ~ /^FIORDCHK$/ || + $2 ~ /^SIOC/ || + $2 ~ /^TIOC/ || +@@ -655,7 +668,7 @@ errors=$( + signals=$( + echo '#include ' | $CC -x c - -E -dM $ccflags | + awk '$1=="#define" && $2 ~ /^SIG[A-Z0-9]+$/ { print $2 }' | +- grep -v 'SIGSTKSIZE\|SIGSTKSZ\|SIGRT\|SIGMAX64' | ++ grep -E -v '(SIGSTKSIZE|SIGSTKSZ|SIGRT|SIGMAX64)' | + sort + ) + +@@ -665,7 +678,7 @@ echo '#include ' | $CC -x c - -E -dM $ccflags | + sort >_error.grep + echo '#include ' | $CC -x c - -E -dM $ccflags | + awk '$1=="#define" && $2 ~ /^SIG[A-Z0-9]+$/ { print "^\t" $2 "[ \t]*=" }' | +- grep -v 'SIGSTKSIZE\|SIGSTKSZ\|SIGRT\|SIGMAX64' | ++ grep -E -v '(SIGSTKSIZE|SIGSTKSZ|SIGRT|SIGMAX64)' | + sort >_signal.grep + + echo '// mkerrors.sh' "$@" +diff --git a/vendor/golang.org/x/sys/unix/syscall_aix.go b/vendor/golang.org/x/sys/unix/syscall_aix.go +index 67ce6ce..6f15ba1 100644 +--- a/vendor/golang.org/x/sys/unix/syscall_aix.go ++++ b/vendor/golang.org/x/sys/unix/syscall_aix.go +@@ -360,7 +360,7 @@ func Wait4(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (wpid int, + var status _C_int + var r Pid_t + err = ERESTART +- // AIX wait4 may return with ERESTART errno, while the processus is still ++ // AIX wait4 may return with ERESTART errno, while the process is still + // active. + for err == ERESTART { + r, err = wait4(Pid_t(pid), &status, options, rusage) +diff --git a/vendor/golang.org/x/sys/unix/syscall_darwin.go b/vendor/golang.org/x/sys/unix/syscall_darwin.go +index 2d15200..099867d 100644 +--- a/vendor/golang.org/x/sys/unix/syscall_darwin.go ++++ b/vendor/golang.org/x/sys/unix/syscall_darwin.go +@@ -566,6 +566,43 @@ func PthreadFchdir(fd int) (err error) { + return pthread_fchdir_np(fd) + } + ++// Connectx calls connectx(2) to initiate a connection on a socket. ++// ++// srcIf, srcAddr, and dstAddr are filled into a [SaEndpoints] struct and passed as the endpoints argument. ++// ++// - srcIf is the optional source interface index. 0 means unspecified. ++// - srcAddr is the optional source address. nil means unspecified. ++// - dstAddr is the destination address. ++// ++// On success, Connectx returns the number of bytes enqueued for transmission. ++func Connectx(fd int, srcIf uint32, srcAddr, dstAddr Sockaddr, associd SaeAssocID, flags uint32, iov []Iovec, connid *SaeConnID) (n uintptr, err error) { ++ endpoints := SaEndpoints{ ++ Srcif: srcIf, ++ } ++ ++ if srcAddr != nil { ++ addrp, addrlen, err := srcAddr.sockaddr() ++ if err != nil { ++ return 0, err ++ } ++ endpoints.Srcaddr = (*RawSockaddr)(addrp) ++ endpoints.Srcaddrlen = uint32(addrlen) ++ } ++ ++ if dstAddr != nil { ++ addrp, addrlen, err := dstAddr.sockaddr() ++ if err != nil { ++ return 0, err ++ } ++ endpoints.Dstaddr = (*RawSockaddr)(addrp) ++ endpoints.Dstaddrlen = uint32(addrlen) ++ } ++ ++ err = connectx(fd, &endpoints, associd, flags, iov, &n, connid) ++ return ++} ++ ++//sys connectx(fd int, endpoints *SaEndpoints, associd SaeAssocID, flags uint32, iov []Iovec, n *uintptr, connid *SaeConnID) (err error) + //sys sendfile(infd int, outfd int, offset int64, len *int64, hdtr unsafe.Pointer, flags int) (err error) + + //sys shmat(id int, addr uintptr, flag int) (ret uintptr, err error) +diff --git a/vendor/golang.org/x/sys/unix/syscall_hurd.go b/vendor/golang.org/x/sys/unix/syscall_hurd.go +index ba46651..a6a2d2f 100644 +--- a/vendor/golang.org/x/sys/unix/syscall_hurd.go ++++ b/vendor/golang.org/x/sys/unix/syscall_hurd.go +@@ -11,6 +11,7 @@ package unix + int ioctl(int, unsigned long int, uintptr_t); + */ + import "C" ++import "unsafe" + + func ioctl(fd int, req uint, arg uintptr) (err error) { + r0, er := C.ioctl(C.int(fd), C.ulong(req), C.uintptr_t(arg)) +diff --git a/vendor/golang.org/x/sys/unix/syscall_linux.go b/vendor/golang.org/x/sys/unix/syscall_linux.go +index 3f1d3d4..230a945 100644 +--- a/vendor/golang.org/x/sys/unix/syscall_linux.go ++++ b/vendor/golang.org/x/sys/unix/syscall_linux.go +@@ -1295,6 +1295,48 @@ func GetsockoptTCPInfo(fd, level, opt int) (*TCPInfo, error) { + return &value, err + } + ++// GetsockoptTCPCCVegasInfo returns algorithm specific congestion control information for a socket using the "vegas" ++// algorithm. ++// ++// The socket's congestion control algorighm can be retrieved via [GetsockoptString] with the [TCP_CONGESTION] option: ++// ++// algo, err := unix.GetsockoptString(fd, unix.IPPROTO_TCP, unix.TCP_CONGESTION) ++func GetsockoptTCPCCVegasInfo(fd, level, opt int) (*TCPVegasInfo, error) { ++ var value [SizeofTCPCCInfo / 4]uint32 // ensure proper alignment ++ vallen := _Socklen(SizeofTCPCCInfo) ++ err := getsockopt(fd, level, opt, unsafe.Pointer(&value[0]), &vallen) ++ out := (*TCPVegasInfo)(unsafe.Pointer(&value[0])) ++ return out, err ++} ++ ++// GetsockoptTCPCCDCTCPInfo returns algorithm specific congestion control information for a socket using the "dctp" ++// algorithm. ++// ++// The socket's congestion control algorighm can be retrieved via [GetsockoptString] with the [TCP_CONGESTION] option: ++// ++// algo, err := unix.GetsockoptString(fd, unix.IPPROTO_TCP, unix.TCP_CONGESTION) ++func GetsockoptTCPCCDCTCPInfo(fd, level, opt int) (*TCPDCTCPInfo, error) { ++ var value [SizeofTCPCCInfo / 4]uint32 // ensure proper alignment ++ vallen := _Socklen(SizeofTCPCCInfo) ++ err := getsockopt(fd, level, opt, unsafe.Pointer(&value[0]), &vallen) ++ out := (*TCPDCTCPInfo)(unsafe.Pointer(&value[0])) ++ return out, err ++} ++ ++// GetsockoptTCPCCBBRInfo returns algorithm specific congestion control information for a socket using the "bbr" ++// algorithm. ++// ++// The socket's congestion control algorighm can be retrieved via [GetsockoptString] with the [TCP_CONGESTION] option: ++// ++// algo, err := unix.GetsockoptString(fd, unix.IPPROTO_TCP, unix.TCP_CONGESTION) ++func GetsockoptTCPCCBBRInfo(fd, level, opt int) (*TCPBBRInfo, error) { ++ var value [SizeofTCPCCInfo / 4]uint32 // ensure proper alignment ++ vallen := _Socklen(SizeofTCPCCInfo) ++ err := getsockopt(fd, level, opt, unsafe.Pointer(&value[0]), &vallen) ++ out := (*TCPBBRInfo)(unsafe.Pointer(&value[0])) ++ return out, err ++} ++ + // GetsockoptString returns the string value of the socket option opt for the + // socket associated with fd at the given socket level. + func GetsockoptString(fd, level, opt int) (string, error) { +@@ -1818,6 +1860,7 @@ func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err e + //sys ClockAdjtime(clockid int32, buf *Timex) (state int, err error) + //sys ClockGetres(clockid int32, res *Timespec) (err error) + //sys ClockGettime(clockid int32, time *Timespec) (err error) ++//sys ClockSettime(clockid int32, time *Timespec) (err error) + //sys ClockNanosleep(clockid int32, flags int, request *Timespec, remain *Timespec) (err error) + //sys Close(fd int) (err error) + //sys CloseRange(first uint, last uint, flags uint) (err error) +@@ -1959,7 +2002,26 @@ func Getpgrp() (pid int) { + //sysnb Getpid() (pid int) + //sysnb Getppid() (ppid int) + //sys Getpriority(which int, who int) (prio int, err error) +-//sys Getrandom(buf []byte, flags int) (n int, err error) ++ ++func Getrandom(buf []byte, flags int) (n int, err error) { ++ vdsoRet, supported := vgetrandom(buf, uint32(flags)) ++ if supported { ++ if vdsoRet < 0 { ++ return 0, errnoErr(syscall.Errno(-vdsoRet)) ++ } ++ return vdsoRet, nil ++ } ++ var p *byte ++ if len(buf) > 0 { ++ p = &buf[0] ++ } ++ r, _, e := Syscall(SYS_GETRANDOM, uintptr(unsafe.Pointer(p)), uintptr(len(buf)), uintptr(flags)) ++ if e != 0 { ++ return 0, errnoErr(e) ++ } ++ return int(r), nil ++} ++ + //sysnb Getrusage(who int, rusage *Rusage) (err error) + //sysnb Getsid(pid int) (sid int, err error) + //sysnb Gettid() (tid int) +diff --git a/vendor/golang.org/x/sys/unix/syscall_linux_arm64.go b/vendor/golang.org/x/sys/unix/syscall_linux_arm64.go +index cf2ee6c..745e5c7 100644 +--- a/vendor/golang.org/x/sys/unix/syscall_linux_arm64.go ++++ b/vendor/golang.org/x/sys/unix/syscall_linux_arm64.go +@@ -182,3 +182,5 @@ func KexecFileLoad(kernelFd int, initrdFd int, cmdline string, flags int) error + } + return kexecFileLoad(kernelFd, initrdFd, cmdlineLen, cmdline, flags) + } ++ ++const SYS_FSTATAT = SYS_NEWFSTATAT +diff --git a/vendor/golang.org/x/sys/unix/syscall_linux_loong64.go b/vendor/golang.org/x/sys/unix/syscall_linux_loong64.go +index 3d0e984..dd2262a 100644 +--- a/vendor/golang.org/x/sys/unix/syscall_linux_loong64.go ++++ b/vendor/golang.org/x/sys/unix/syscall_linux_loong64.go +@@ -214,3 +214,5 @@ func KexecFileLoad(kernelFd int, initrdFd int, cmdline string, flags int) error + } + return kexecFileLoad(kernelFd, initrdFd, cmdlineLen, cmdline, flags) + } ++ ++const SYS_FSTATAT = SYS_NEWFSTATAT +diff --git a/vendor/golang.org/x/sys/unix/syscall_linux_riscv64.go b/vendor/golang.org/x/sys/unix/syscall_linux_riscv64.go +index 6f5a288..8cf3670 100644 +--- a/vendor/golang.org/x/sys/unix/syscall_linux_riscv64.go ++++ b/vendor/golang.org/x/sys/unix/syscall_linux_riscv64.go +@@ -187,3 +187,5 @@ func RISCVHWProbe(pairs []RISCVHWProbePairs, set *CPUSet, flags uint) (err error + } + return riscvHWProbe(pairs, setSize, set, flags) + } ++ ++const SYS_FSTATAT = SYS_NEWFSTATAT +diff --git a/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go b/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go +index 312ae6a..7bf5c04 100644 +--- a/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go ++++ b/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go +@@ -768,6 +768,15 @@ func Munmap(b []byte) (err error) { + return mapper.Munmap(b) + } + ++func MmapPtr(fd int, offset int64, addr unsafe.Pointer, length uintptr, prot int, flags int) (ret unsafe.Pointer, err error) { ++ xaddr, err := mapper.mmap(uintptr(addr), length, prot, flags, fd, offset) ++ return unsafe.Pointer(xaddr), err ++} ++ ++func MunmapPtr(addr unsafe.Pointer, length uintptr) (err error) { ++ return mapper.munmap(uintptr(addr), length) ++} ++ + //sys Gethostname(buf []byte) (err error) = SYS___GETHOSTNAME_A + //sysnb Getgid() (gid int) + //sysnb Getpid() (pid int) +@@ -816,10 +825,10 @@ func Lstat(path string, stat *Stat_t) (err error) { + // for checking symlinks begins with $VERSION/ $SYSNAME/ $SYSSYMR/ $SYSSYMA/ + func isSpecialPath(path []byte) (v bool) { + var special = [4][8]byte{ +- [8]byte{'V', 'E', 'R', 'S', 'I', 'O', 'N', '/'}, +- [8]byte{'S', 'Y', 'S', 'N', 'A', 'M', 'E', '/'}, +- [8]byte{'S', 'Y', 'S', 'S', 'Y', 'M', 'R', '/'}, +- [8]byte{'S', 'Y', 'S', 'S', 'Y', 'M', 'A', '/'}} ++ {'V', 'E', 'R', 'S', 'I', 'O', 'N', '/'}, ++ {'S', 'Y', 'S', 'N', 'A', 'M', 'E', '/'}, ++ {'S', 'Y', 'S', 'S', 'Y', 'M', 'R', '/'}, ++ {'S', 'Y', 'S', 'S', 'Y', 'M', 'A', '/'}} + + var i, j int + for i = 0; i < len(special); i++ { +@@ -3115,3 +3124,90 @@ func legacy_Mkfifoat(dirfd int, path string, mode uint32) (err error) { + //sys Posix_openpt(oflag int) (fd int, err error) = SYS_POSIX_OPENPT + //sys Grantpt(fildes int) (rc int, err error) = SYS_GRANTPT + //sys Unlockpt(fildes int) (rc int, err error) = SYS_UNLOCKPT ++ ++func fcntlAsIs(fd uintptr, cmd int, arg uintptr) (val int, err error) { ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_FCNTL<<4, uintptr(fd), uintptr(cmd), arg) ++ runtime.ExitSyscall() ++ val = int(r0) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++func Fcntl(fd uintptr, cmd int, op interface{}) (ret int, err error) { ++ switch op.(type) { ++ case *Flock_t: ++ err = FcntlFlock(fd, cmd, op.(*Flock_t)) ++ if err != nil { ++ ret = -1 ++ } ++ return ++ case int: ++ return FcntlInt(fd, cmd, op.(int)) ++ case *F_cnvrt: ++ return fcntlAsIs(fd, cmd, uintptr(unsafe.Pointer(op.(*F_cnvrt)))) ++ case unsafe.Pointer: ++ return fcntlAsIs(fd, cmd, uintptr(op.(unsafe.Pointer))) ++ default: ++ return -1, EINVAL ++ } ++ return ++} ++ ++func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) { ++ if raceenabled { ++ raceReleaseMerge(unsafe.Pointer(&ioSync)) ++ } ++ return sendfile(outfd, infd, offset, count) ++} ++ ++func sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) { ++ // TODO: use LE call instead if the call is implemented ++ originalOffset, err := Seek(infd, 0, SEEK_CUR) ++ if err != nil { ++ return -1, err ++ } ++ //start reading data from in_fd ++ if offset != nil { ++ _, err := Seek(infd, *offset, SEEK_SET) ++ if err != nil { ++ return -1, err ++ } ++ } ++ ++ buf := make([]byte, count) ++ readBuf := make([]byte, 0) ++ var n int = 0 ++ for i := 0; i < count; i += n { ++ n, err := Read(infd, buf) ++ if n == 0 { ++ if err != nil { ++ return -1, err ++ } else { // EOF ++ break ++ } ++ } ++ readBuf = append(readBuf, buf...) ++ buf = buf[0:0] ++ } ++ ++ n2, err := Write(outfd, readBuf) ++ if err != nil { ++ return -1, err ++ } ++ ++ //When sendfile() returns, this variable will be set to the ++ // offset of the byte following the last byte that was read. ++ if offset != nil { ++ *offset = *offset + int64(n) ++ // If offset is not NULL, then sendfile() does not modify the file ++ // offset of in_fd ++ _, err := Seek(infd, originalOffset, SEEK_SET) ++ if err != nil { ++ return -1, err ++ } ++ } ++ return n2, nil ++} +diff --git a/vendor/golang.org/x/sys/unix/vgetrandom_linux.go b/vendor/golang.org/x/sys/unix/vgetrandom_linux.go +new file mode 100644 +index 0000000..07ac8e0 +--- /dev/null ++++ b/vendor/golang.org/x/sys/unix/vgetrandom_linux.go +@@ -0,0 +1,13 @@ ++// Copyright 2024 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. ++ ++//go:build linux && go1.24 ++ ++package unix ++ ++import _ "unsafe" ++ ++//go:linkname vgetrandom runtime.vgetrandom ++//go:noescape ++func vgetrandom(p []byte, flags uint32) (ret int, supported bool) +diff --git a/vendor/golang.org/x/sys/unix/vgetrandom_unsupported.go b/vendor/golang.org/x/sys/unix/vgetrandom_unsupported.go +new file mode 100644 +index 0000000..297e97b +--- /dev/null ++++ b/vendor/golang.org/x/sys/unix/vgetrandom_unsupported.go +@@ -0,0 +1,11 @@ ++// Copyright 2024 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. ++ ++//go:build !linux || !go1.24 ++ ++package unix ++ ++func vgetrandom(p []byte, flags uint32) (ret int, supported bool) { ++ return -1, false ++} +diff --git a/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go b/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go +index 4308ac1..d73c465 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go +@@ -237,6 +237,9 @@ const ( + CLOCK_UPTIME_RAW_APPROX = 0x9 + CLONE_NOFOLLOW = 0x1 + CLONE_NOOWNERCOPY = 0x2 ++ CONNECT_DATA_AUTHENTICATED = 0x4 ++ CONNECT_DATA_IDEMPOTENT = 0x2 ++ CONNECT_RESUME_ON_READ_WRITE = 0x1 + CR0 = 0x0 + CR1 = 0x1000 + CR2 = 0x2000 +@@ -1265,6 +1268,10 @@ const ( + RTV_SSTHRESH = 0x20 + RUSAGE_CHILDREN = -0x1 + RUSAGE_SELF = 0x0 ++ SAE_ASSOCID_ALL = 0xffffffff ++ SAE_ASSOCID_ANY = 0x0 ++ SAE_CONNID_ALL = 0xffffffff ++ SAE_CONNID_ANY = 0x0 + SCM_CREDS = 0x3 + SCM_RIGHTS = 0x1 + SCM_TIMESTAMP = 0x2 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go b/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go +index c8068a7..4a55a40 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go +@@ -237,6 +237,9 @@ const ( + CLOCK_UPTIME_RAW_APPROX = 0x9 + CLONE_NOFOLLOW = 0x1 + CLONE_NOOWNERCOPY = 0x2 ++ CONNECT_DATA_AUTHENTICATED = 0x4 ++ CONNECT_DATA_IDEMPOTENT = 0x2 ++ CONNECT_RESUME_ON_READ_WRITE = 0x1 + CR0 = 0x0 + CR1 = 0x1000 + CR2 = 0x2000 +@@ -1265,6 +1268,10 @@ const ( + RTV_SSTHRESH = 0x20 + RUSAGE_CHILDREN = -0x1 + RUSAGE_SELF = 0x0 ++ SAE_ASSOCID_ALL = 0xffffffff ++ SAE_ASSOCID_ANY = 0x0 ++ SAE_CONNID_ALL = 0xffffffff ++ SAE_CONNID_ANY = 0x0 + SCM_CREDS = 0x3 + SCM_RIGHTS = 0x1 + SCM_TIMESTAMP = 0x2 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux.go b/vendor/golang.org/x/sys/unix/zerrors_linux.go +index 01a70b2..6ebc48b 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux.go +@@ -321,6 +321,9 @@ const ( + AUDIT_INTEGRITY_STATUS = 0x70a + AUDIT_IPC = 0x517 + AUDIT_IPC_SET_PERM = 0x51f ++ AUDIT_IPE_ACCESS = 0x58c ++ AUDIT_IPE_CONFIG_CHANGE = 0x58d ++ AUDIT_IPE_POLICY_LOAD = 0x58e + AUDIT_KERNEL = 0x7d0 + AUDIT_KERNEL_OTHER = 0x524 + AUDIT_KERN_MODULE = 0x532 +@@ -489,12 +492,14 @@ const ( + BPF_F_ID = 0x20 + BPF_F_NETFILTER_IP_DEFRAG = 0x1 + BPF_F_QUERY_EFFECTIVE = 0x1 ++ BPF_F_REDIRECT_FLAGS = 0x19 + BPF_F_REPLACE = 0x4 + BPF_F_SLEEPABLE = 0x10 + BPF_F_STRICT_ALIGNMENT = 0x1 + BPF_F_TEST_REG_INVARIANTS = 0x80 + BPF_F_TEST_RND_HI32 = 0x4 + BPF_F_TEST_RUN_ON_CPU = 0x1 ++ BPF_F_TEST_SKB_CHECKSUM_COMPLETE = 0x4 + BPF_F_TEST_STATE_FREQ = 0x8 + BPF_F_TEST_XDP_LIVE_FRAMES = 0x2 + BPF_F_XDP_DEV_BOUND_ONLY = 0x40 +@@ -1165,6 +1170,7 @@ const ( + EXTA = 0xe + EXTB = 0xf + F2FS_SUPER_MAGIC = 0xf2f52010 ++ FALLOC_FL_ALLOCATE_RANGE = 0x0 + FALLOC_FL_COLLAPSE_RANGE = 0x8 + FALLOC_FL_INSERT_RANGE = 0x20 + FALLOC_FL_KEEP_SIZE = 0x1 +@@ -1798,6 +1804,8 @@ const ( + LANDLOCK_ACCESS_NET_BIND_TCP = 0x1 + LANDLOCK_ACCESS_NET_CONNECT_TCP = 0x2 + LANDLOCK_CREATE_RULESET_VERSION = 0x1 ++ LANDLOCK_SCOPE_ABSTRACT_UNIX_SOCKET = 0x1 ++ LANDLOCK_SCOPE_SIGNAL = 0x2 + LINUX_REBOOT_CMD_CAD_OFF = 0x0 + LINUX_REBOOT_CMD_CAD_ON = 0x89abcdef + LINUX_REBOOT_CMD_HALT = 0xcdef0123 +@@ -1922,6 +1930,8 @@ const ( + MNT_EXPIRE = 0x4 + MNT_FORCE = 0x1 + MNT_ID_REQ_SIZE_VER0 = 0x18 ++ MNT_ID_REQ_SIZE_VER1 = 0x20 ++ MNT_NS_INFO_SIZE_VER0 = 0x10 + MODULE_INIT_COMPRESSED_FILE = 0x4 + MODULE_INIT_IGNORE_MODVERSIONS = 0x1 + MODULE_INIT_IGNORE_VERMAGIC = 0x2 +@@ -2187,7 +2197,7 @@ const ( + NFT_REG_SIZE = 0x10 + NFT_REJECT_ICMPX_MAX = 0x3 + NFT_RT_MAX = 0x4 +- NFT_SECMARK_CTX_MAXLEN = 0x100 ++ NFT_SECMARK_CTX_MAXLEN = 0x1000 + NFT_SET_MAXNAMELEN = 0x100 + NFT_SOCKET_MAX = 0x3 + NFT_TABLE_F_MASK = 0x7 +@@ -2356,9 +2366,11 @@ const ( + PERF_MEM_LVLNUM_IO = 0xa + PERF_MEM_LVLNUM_L1 = 0x1 + PERF_MEM_LVLNUM_L2 = 0x2 ++ PERF_MEM_LVLNUM_L2_MHB = 0x5 + PERF_MEM_LVLNUM_L3 = 0x3 + PERF_MEM_LVLNUM_L4 = 0x4 + PERF_MEM_LVLNUM_LFB = 0xc ++ PERF_MEM_LVLNUM_MSC = 0x6 + PERF_MEM_LVLNUM_NA = 0xf + PERF_MEM_LVLNUM_PMEM = 0xe + PERF_MEM_LVLNUM_RAM = 0xd +@@ -2431,6 +2443,7 @@ const ( + PRIO_PGRP = 0x1 + PRIO_PROCESS = 0x0 + PRIO_USER = 0x2 ++ PROCFS_IOCTL_MAGIC = 'f' + PROC_SUPER_MAGIC = 0x9fa0 + PROT_EXEC = 0x4 + PROT_GROWSDOWN = 0x1000000 +@@ -2620,6 +2633,28 @@ const ( + PR_UNALIGN_NOPRINT = 0x1 + PR_UNALIGN_SIGBUS = 0x2 + PSTOREFS_MAGIC = 0x6165676c ++ PTP_CLK_MAGIC = '=' ++ PTP_ENABLE_FEATURE = 0x1 ++ PTP_EXTTS_EDGES = 0x6 ++ PTP_EXTTS_EVENT_VALID = 0x1 ++ PTP_EXTTS_V1_VALID_FLAGS = 0x7 ++ PTP_EXTTS_VALID_FLAGS = 0x1f ++ PTP_EXT_OFFSET = 0x10 ++ PTP_FALLING_EDGE = 0x4 ++ PTP_MAX_SAMPLES = 0x19 ++ PTP_PEROUT_DUTY_CYCLE = 0x2 ++ PTP_PEROUT_ONE_SHOT = 0x1 ++ PTP_PEROUT_PHASE = 0x4 ++ PTP_PEROUT_V1_VALID_FLAGS = 0x0 ++ PTP_PEROUT_VALID_FLAGS = 0x7 ++ PTP_PIN_GETFUNC = 0xc0603d06 ++ PTP_PIN_GETFUNC2 = 0xc0603d0f ++ PTP_RISING_EDGE = 0x2 ++ PTP_STRICT_FLAGS = 0x8 ++ PTP_SYS_OFFSET_EXTENDED = 0xc4c03d09 ++ PTP_SYS_OFFSET_EXTENDED2 = 0xc4c03d12 ++ PTP_SYS_OFFSET_PRECISE = 0xc0403d08 ++ PTP_SYS_OFFSET_PRECISE2 = 0xc0403d11 + PTRACE_ATTACH = 0x10 + PTRACE_CONT = 0x7 + PTRACE_DETACH = 0x11 +@@ -2933,15 +2968,17 @@ const ( + RUSAGE_SELF = 0x0 + RUSAGE_THREAD = 0x1 + RWF_APPEND = 0x10 ++ RWF_ATOMIC = 0x40 + RWF_DSYNC = 0x2 + RWF_HIPRI = 0x1 + RWF_NOAPPEND = 0x20 + RWF_NOWAIT = 0x8 +- RWF_SUPPORTED = 0x3f ++ RWF_SUPPORTED = 0x7f + RWF_SYNC = 0x4 + RWF_WRITE_LIFE_NOT_SET = 0x0 + SCHED_BATCH = 0x3 + SCHED_DEADLINE = 0x6 ++ SCHED_EXT = 0x7 + SCHED_FIFO = 0x1 + SCHED_FLAG_ALL = 0x7f + SCHED_FLAG_DL_OVERRUN = 0x4 +@@ -3210,6 +3247,7 @@ const ( + STATX_ATTR_MOUNT_ROOT = 0x2000 + STATX_ATTR_NODUMP = 0x40 + STATX_ATTR_VERITY = 0x100000 ++ STATX_ATTR_WRITE_ATOMIC = 0x400000 + STATX_BASIC_STATS = 0x7ff + STATX_BLOCKS = 0x400 + STATX_BTIME = 0x800 +@@ -3226,6 +3264,7 @@ const ( + STATX_SUBVOL = 0x8000 + STATX_TYPE = 0x1 + STATX_UID = 0x8 ++ STATX_WRITE_ATOMIC = 0x10000 + STATX__RESERVED = 0x80000000 + SYNC_FILE_RANGE_WAIT_AFTER = 0x4 + SYNC_FILE_RANGE_WAIT_BEFORE = 0x1 +@@ -3624,6 +3663,7 @@ const ( + XDP_UMEM_PGOFF_COMPLETION_RING = 0x180000000 + XDP_UMEM_PGOFF_FILL_RING = 0x100000000 + XDP_UMEM_REG = 0x4 ++ XDP_UMEM_TX_METADATA_LEN = 0x4 + XDP_UMEM_TX_SW_CSUM = 0x2 + XDP_UMEM_UNALIGNED_CHUNK_FLAG = 0x1 + XDP_USE_NEED_WAKEUP = 0x8 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_386.go b/vendor/golang.org/x/sys/unix/zerrors_linux_386.go +index 684a516..c0d45e3 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_386.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_386.go +@@ -109,6 +109,7 @@ const ( + HIDIOCGRAWINFO = 0x80084803 + HIDIOCGRDESC = 0x90044802 + HIDIOCGRDESCSIZE = 0x80044801 ++ HIDIOCREVOKE = 0x4004480d + HUPCL = 0x400 + ICANON = 0x2 + IEXTEN = 0x8000 +@@ -153,9 +154,14 @@ const ( + NFDBITS = 0x20 + NLDLY = 0x100 + NOFLSH = 0x80 ++ NS_GET_MNTNS_ID = 0x8008b705 + NS_GET_NSTYPE = 0xb703 + NS_GET_OWNER_UID = 0xb704 + NS_GET_PARENT = 0xb702 ++ NS_GET_PID_FROM_PIDNS = 0x8004b706 ++ NS_GET_PID_IN_PIDNS = 0x8004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x8004b707 ++ NS_GET_TGID_IN_PIDNS = 0x8004b709 + NS_GET_USERNS = 0xb701 + OLCUC = 0x2 + ONLCR = 0x4 +@@ -232,6 +238,20 @@ const ( + PPPIOCUNBRIDGECHAN = 0x7434 + PPPIOCXFERUNIT = 0x744e + PR_SET_PTRACER_ANY = 0xffffffff ++ PTP_CLOCK_GETCAPS = 0x80503d01 ++ PTP_CLOCK_GETCAPS2 = 0x80503d0a ++ PTP_ENABLE_PPS = 0x40043d04 ++ PTP_ENABLE_PPS2 = 0x40043d0d ++ PTP_EXTTS_REQUEST = 0x40103d02 ++ PTP_EXTTS_REQUEST2 = 0x40103d0b ++ PTP_MASK_CLEAR_ALL = 0x3d13 ++ PTP_MASK_EN_SINGLE = 0x40043d14 ++ PTP_PEROUT_REQUEST = 0x40383d03 ++ PTP_PEROUT_REQUEST2 = 0x40383d0c ++ PTP_PIN_SETFUNC = 0x40603d07 ++ PTP_PIN_SETFUNC2 = 0x40603d10 ++ PTP_SYS_OFFSET = 0x43403d05 ++ PTP_SYS_OFFSET2 = 0x43403d0e + PTRACE_GETFPREGS = 0xe + PTRACE_GETFPXREGS = 0x12 + PTRACE_GET_THREAD_AREA = 0x19 +@@ -278,6 +298,8 @@ const ( + RTC_WIE_ON = 0x700f + RTC_WKALM_RD = 0x80287010 + RTC_WKALM_SET = 0x4028700f ++ SCM_DEVMEM_DMABUF = 0x4f ++ SCM_DEVMEM_LINEAR = 0x4e + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a +@@ -316,6 +338,9 @@ const ( + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DEVMEM_DMABUF = 0x4f ++ SO_DEVMEM_DONTNEED = 0x50 ++ SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x27 + SO_DONTROUTE = 0x5 + SO_ERROR = 0x4 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go +index 61d74b5..c731d24 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go +@@ -109,6 +109,7 @@ const ( + HIDIOCGRAWINFO = 0x80084803 + HIDIOCGRDESC = 0x90044802 + HIDIOCGRDESCSIZE = 0x80044801 ++ HIDIOCREVOKE = 0x4004480d + HUPCL = 0x400 + ICANON = 0x2 + IEXTEN = 0x8000 +@@ -153,9 +154,14 @@ const ( + NFDBITS = 0x40 + NLDLY = 0x100 + NOFLSH = 0x80 ++ NS_GET_MNTNS_ID = 0x8008b705 + NS_GET_NSTYPE = 0xb703 + NS_GET_OWNER_UID = 0xb704 + NS_GET_PARENT = 0xb702 ++ NS_GET_PID_FROM_PIDNS = 0x8004b706 ++ NS_GET_PID_IN_PIDNS = 0x8004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x8004b707 ++ NS_GET_TGID_IN_PIDNS = 0x8004b709 + NS_GET_USERNS = 0xb701 + OLCUC = 0x2 + ONLCR = 0x4 +@@ -232,6 +238,20 @@ const ( + PPPIOCUNBRIDGECHAN = 0x7434 + PPPIOCXFERUNIT = 0x744e + PR_SET_PTRACER_ANY = 0xffffffffffffffff ++ PTP_CLOCK_GETCAPS = 0x80503d01 ++ PTP_CLOCK_GETCAPS2 = 0x80503d0a ++ PTP_ENABLE_PPS = 0x40043d04 ++ PTP_ENABLE_PPS2 = 0x40043d0d ++ PTP_EXTTS_REQUEST = 0x40103d02 ++ PTP_EXTTS_REQUEST2 = 0x40103d0b ++ PTP_MASK_CLEAR_ALL = 0x3d13 ++ PTP_MASK_EN_SINGLE = 0x40043d14 ++ PTP_PEROUT_REQUEST = 0x40383d03 ++ PTP_PEROUT_REQUEST2 = 0x40383d0c ++ PTP_PIN_SETFUNC = 0x40603d07 ++ PTP_PIN_SETFUNC2 = 0x40603d10 ++ PTP_SYS_OFFSET = 0x43403d05 ++ PTP_SYS_OFFSET2 = 0x43403d0e + PTRACE_ARCH_PRCTL = 0x1e + PTRACE_GETFPREGS = 0xe + PTRACE_GETFPXREGS = 0x12 +@@ -279,6 +299,8 @@ const ( + RTC_WIE_ON = 0x700f + RTC_WKALM_RD = 0x80287010 + RTC_WKALM_SET = 0x4028700f ++ SCM_DEVMEM_DMABUF = 0x4f ++ SCM_DEVMEM_LINEAR = 0x4e + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a +@@ -317,6 +339,9 @@ const ( + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DEVMEM_DMABUF = 0x4f ++ SO_DEVMEM_DONTNEED = 0x50 ++ SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x27 + SO_DONTROUTE = 0x5 + SO_ERROR = 0x4 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go b/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go +index a28c9e3..680018a 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go +@@ -108,6 +108,7 @@ const ( + HIDIOCGRAWINFO = 0x80084803 + HIDIOCGRDESC = 0x90044802 + HIDIOCGRDESCSIZE = 0x80044801 ++ HIDIOCREVOKE = 0x4004480d + HUPCL = 0x400 + ICANON = 0x2 + IEXTEN = 0x8000 +@@ -150,9 +151,14 @@ const ( + NFDBITS = 0x20 + NLDLY = 0x100 + NOFLSH = 0x80 ++ NS_GET_MNTNS_ID = 0x8008b705 + NS_GET_NSTYPE = 0xb703 + NS_GET_OWNER_UID = 0xb704 + NS_GET_PARENT = 0xb702 ++ NS_GET_PID_FROM_PIDNS = 0x8004b706 ++ NS_GET_PID_IN_PIDNS = 0x8004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x8004b707 ++ NS_GET_TGID_IN_PIDNS = 0x8004b709 + NS_GET_USERNS = 0xb701 + OLCUC = 0x2 + ONLCR = 0x4 +@@ -229,6 +235,20 @@ const ( + PPPIOCUNBRIDGECHAN = 0x7434 + PPPIOCXFERUNIT = 0x744e + PR_SET_PTRACER_ANY = 0xffffffff ++ PTP_CLOCK_GETCAPS = 0x80503d01 ++ PTP_CLOCK_GETCAPS2 = 0x80503d0a ++ PTP_ENABLE_PPS = 0x40043d04 ++ PTP_ENABLE_PPS2 = 0x40043d0d ++ PTP_EXTTS_REQUEST = 0x40103d02 ++ PTP_EXTTS_REQUEST2 = 0x40103d0b ++ PTP_MASK_CLEAR_ALL = 0x3d13 ++ PTP_MASK_EN_SINGLE = 0x40043d14 ++ PTP_PEROUT_REQUEST = 0x40383d03 ++ PTP_PEROUT_REQUEST2 = 0x40383d0c ++ PTP_PIN_SETFUNC = 0x40603d07 ++ PTP_PIN_SETFUNC2 = 0x40603d10 ++ PTP_SYS_OFFSET = 0x43403d05 ++ PTP_SYS_OFFSET2 = 0x43403d0e + PTRACE_GETCRUNCHREGS = 0x19 + PTRACE_GETFDPIC = 0x1f + PTRACE_GETFDPIC_EXEC = 0x0 +@@ -284,6 +304,8 @@ const ( + RTC_WIE_ON = 0x700f + RTC_WKALM_RD = 0x80287010 + RTC_WKALM_SET = 0x4028700f ++ SCM_DEVMEM_DMABUF = 0x4f ++ SCM_DEVMEM_LINEAR = 0x4e + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a +@@ -322,6 +344,9 @@ const ( + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DEVMEM_DMABUF = 0x4f ++ SO_DEVMEM_DONTNEED = 0x50 ++ SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x27 + SO_DONTROUTE = 0x5 + SO_ERROR = 0x4 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go +index ab5d1fe..a63909f 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go +@@ -112,6 +112,7 @@ const ( + HIDIOCGRAWINFO = 0x80084803 + HIDIOCGRDESC = 0x90044802 + HIDIOCGRDESCSIZE = 0x80044801 ++ HIDIOCREVOKE = 0x4004480d + HUPCL = 0x400 + ICANON = 0x2 + IEXTEN = 0x8000 +@@ -154,9 +155,14 @@ const ( + NFDBITS = 0x40 + NLDLY = 0x100 + NOFLSH = 0x80 ++ NS_GET_MNTNS_ID = 0x8008b705 + NS_GET_NSTYPE = 0xb703 + NS_GET_OWNER_UID = 0xb704 + NS_GET_PARENT = 0xb702 ++ NS_GET_PID_FROM_PIDNS = 0x8004b706 ++ NS_GET_PID_IN_PIDNS = 0x8004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x8004b707 ++ NS_GET_TGID_IN_PIDNS = 0x8004b709 + NS_GET_USERNS = 0xb701 + OLCUC = 0x2 + ONLCR = 0x4 +@@ -200,6 +206,7 @@ const ( + PERF_EVENT_IOC_SET_BPF = 0x40042408 + PERF_EVENT_IOC_SET_FILTER = 0x40082406 + PERF_EVENT_IOC_SET_OUTPUT = 0x2405 ++ POE_MAGIC = 0x504f4530 + PPPIOCATTACH = 0x4004743d + PPPIOCATTCHAN = 0x40047438 + PPPIOCBRIDGECHAN = 0x40047435 +@@ -235,6 +242,20 @@ const ( + PROT_BTI = 0x10 + PROT_MTE = 0x20 + PR_SET_PTRACER_ANY = 0xffffffffffffffff ++ PTP_CLOCK_GETCAPS = 0x80503d01 ++ PTP_CLOCK_GETCAPS2 = 0x80503d0a ++ PTP_ENABLE_PPS = 0x40043d04 ++ PTP_ENABLE_PPS2 = 0x40043d0d ++ PTP_EXTTS_REQUEST = 0x40103d02 ++ PTP_EXTTS_REQUEST2 = 0x40103d0b ++ PTP_MASK_CLEAR_ALL = 0x3d13 ++ PTP_MASK_EN_SINGLE = 0x40043d14 ++ PTP_PEROUT_REQUEST = 0x40383d03 ++ PTP_PEROUT_REQUEST2 = 0x40383d0c ++ PTP_PIN_SETFUNC = 0x40603d07 ++ PTP_PIN_SETFUNC2 = 0x40603d10 ++ PTP_SYS_OFFSET = 0x43403d05 ++ PTP_SYS_OFFSET2 = 0x43403d0e + PTRACE_PEEKMTETAGS = 0x21 + PTRACE_POKEMTETAGS = 0x22 + PTRACE_SYSEMU = 0x1f +@@ -275,6 +296,8 @@ const ( + RTC_WIE_ON = 0x700f + RTC_WKALM_RD = 0x80287010 + RTC_WKALM_SET = 0x4028700f ++ SCM_DEVMEM_DMABUF = 0x4f ++ SCM_DEVMEM_LINEAR = 0x4e + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a +@@ -313,6 +336,9 @@ const ( + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DEVMEM_DMABUF = 0x4f ++ SO_DEVMEM_DONTNEED = 0x50 ++ SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x27 + SO_DONTROUTE = 0x5 + SO_ERROR = 0x4 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go +index c523090..9b0a257 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go +@@ -109,6 +109,7 @@ const ( + HIDIOCGRAWINFO = 0x80084803 + HIDIOCGRDESC = 0x90044802 + HIDIOCGRDESCSIZE = 0x80044801 ++ HIDIOCREVOKE = 0x4004480d + HUPCL = 0x400 + ICANON = 0x2 + IEXTEN = 0x8000 +@@ -154,9 +155,14 @@ const ( + NFDBITS = 0x40 + NLDLY = 0x100 + NOFLSH = 0x80 ++ NS_GET_MNTNS_ID = 0x8008b705 + NS_GET_NSTYPE = 0xb703 + NS_GET_OWNER_UID = 0xb704 + NS_GET_PARENT = 0xb702 ++ NS_GET_PID_FROM_PIDNS = 0x8004b706 ++ NS_GET_PID_IN_PIDNS = 0x8004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x8004b707 ++ NS_GET_TGID_IN_PIDNS = 0x8004b709 + NS_GET_USERNS = 0xb701 + OLCUC = 0x2 + ONLCR = 0x4 +@@ -233,6 +239,20 @@ const ( + PPPIOCUNBRIDGECHAN = 0x7434 + PPPIOCXFERUNIT = 0x744e + PR_SET_PTRACER_ANY = 0xffffffffffffffff ++ PTP_CLOCK_GETCAPS = 0x80503d01 ++ PTP_CLOCK_GETCAPS2 = 0x80503d0a ++ PTP_ENABLE_PPS = 0x40043d04 ++ PTP_ENABLE_PPS2 = 0x40043d0d ++ PTP_EXTTS_REQUEST = 0x40103d02 ++ PTP_EXTTS_REQUEST2 = 0x40103d0b ++ PTP_MASK_CLEAR_ALL = 0x3d13 ++ PTP_MASK_EN_SINGLE = 0x40043d14 ++ PTP_PEROUT_REQUEST = 0x40383d03 ++ PTP_PEROUT_REQUEST2 = 0x40383d0c ++ PTP_PIN_SETFUNC = 0x40603d07 ++ PTP_PIN_SETFUNC2 = 0x40603d10 ++ PTP_SYS_OFFSET = 0x43403d05 ++ PTP_SYS_OFFSET2 = 0x43403d0e + PTRACE_SYSEMU = 0x1f + PTRACE_SYSEMU_SINGLESTEP = 0x20 + RLIMIT_AS = 0x9 +@@ -271,6 +291,8 @@ const ( + RTC_WIE_ON = 0x700f + RTC_WKALM_RD = 0x80287010 + RTC_WKALM_SET = 0x4028700f ++ SCM_DEVMEM_DMABUF = 0x4f ++ SCM_DEVMEM_LINEAR = 0x4e + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a +@@ -309,6 +331,9 @@ const ( + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DEVMEM_DMABUF = 0x4f ++ SO_DEVMEM_DONTNEED = 0x50 ++ SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x27 + SO_DONTROUTE = 0x5 + SO_ERROR = 0x4 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go b/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go +index 01e6ea7..958e6e0 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go +@@ -108,6 +108,7 @@ const ( + HIDIOCGRAWINFO = 0x40084803 + HIDIOCGRDESC = 0x50044802 + HIDIOCGRDESCSIZE = 0x40044801 ++ HIDIOCREVOKE = 0x8004480d + HUPCL = 0x400 + ICANON = 0x2 + IEXTEN = 0x100 +@@ -150,9 +151,14 @@ const ( + NFDBITS = 0x20 + NLDLY = 0x100 + NOFLSH = 0x80 ++ NS_GET_MNTNS_ID = 0x4008b705 + NS_GET_NSTYPE = 0x2000b703 + NS_GET_OWNER_UID = 0x2000b704 + NS_GET_PARENT = 0x2000b702 ++ NS_GET_PID_FROM_PIDNS = 0x4004b706 ++ NS_GET_PID_IN_PIDNS = 0x4004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x4004b707 ++ NS_GET_TGID_IN_PIDNS = 0x4004b709 + NS_GET_USERNS = 0x2000b701 + OLCUC = 0x2 + ONLCR = 0x4 +@@ -229,6 +235,20 @@ const ( + PPPIOCUNBRIDGECHAN = 0x20007434 + PPPIOCXFERUNIT = 0x2000744e + PR_SET_PTRACER_ANY = 0xffffffff ++ PTP_CLOCK_GETCAPS = 0x40503d01 ++ PTP_CLOCK_GETCAPS2 = 0x40503d0a ++ PTP_ENABLE_PPS = 0x80043d04 ++ PTP_ENABLE_PPS2 = 0x80043d0d ++ PTP_EXTTS_REQUEST = 0x80103d02 ++ PTP_EXTTS_REQUEST2 = 0x80103d0b ++ PTP_MASK_CLEAR_ALL = 0x20003d13 ++ PTP_MASK_EN_SINGLE = 0x80043d14 ++ PTP_PEROUT_REQUEST = 0x80383d03 ++ PTP_PEROUT_REQUEST2 = 0x80383d0c ++ PTP_PIN_SETFUNC = 0x80603d07 ++ PTP_PIN_SETFUNC2 = 0x80603d10 ++ PTP_SYS_OFFSET = 0x83403d05 ++ PTP_SYS_OFFSET2 = 0x83403d0e + PTRACE_GETFPREGS = 0xe + PTRACE_GET_THREAD_AREA = 0x19 + PTRACE_GET_THREAD_AREA_3264 = 0xc4 +@@ -277,6 +297,8 @@ const ( + RTC_WIE_ON = 0x2000700f + RTC_WKALM_RD = 0x40287010 + RTC_WKALM_SET = 0x8028700f ++ SCM_DEVMEM_DMABUF = 0x4f ++ SCM_DEVMEM_LINEAR = 0x4e + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a +@@ -315,6 +337,9 @@ const ( + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DEVMEM_DMABUF = 0x4f ++ SO_DEVMEM_DONTNEED = 0x50 ++ SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x1029 + SO_DONTROUTE = 0x10 + SO_ERROR = 0x1007 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go +index 7aa610b..50c7f25 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go +@@ -108,6 +108,7 @@ const ( + HIDIOCGRAWINFO = 0x40084803 + HIDIOCGRDESC = 0x50044802 + HIDIOCGRDESCSIZE = 0x40044801 ++ HIDIOCREVOKE = 0x8004480d + HUPCL = 0x400 + ICANON = 0x2 + IEXTEN = 0x100 +@@ -150,9 +151,14 @@ const ( + NFDBITS = 0x40 + NLDLY = 0x100 + NOFLSH = 0x80 ++ NS_GET_MNTNS_ID = 0x4008b705 + NS_GET_NSTYPE = 0x2000b703 + NS_GET_OWNER_UID = 0x2000b704 + NS_GET_PARENT = 0x2000b702 ++ NS_GET_PID_FROM_PIDNS = 0x4004b706 ++ NS_GET_PID_IN_PIDNS = 0x4004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x4004b707 ++ NS_GET_TGID_IN_PIDNS = 0x4004b709 + NS_GET_USERNS = 0x2000b701 + OLCUC = 0x2 + ONLCR = 0x4 +@@ -229,6 +235,20 @@ const ( + PPPIOCUNBRIDGECHAN = 0x20007434 + PPPIOCXFERUNIT = 0x2000744e + PR_SET_PTRACER_ANY = 0xffffffffffffffff ++ PTP_CLOCK_GETCAPS = 0x40503d01 ++ PTP_CLOCK_GETCAPS2 = 0x40503d0a ++ PTP_ENABLE_PPS = 0x80043d04 ++ PTP_ENABLE_PPS2 = 0x80043d0d ++ PTP_EXTTS_REQUEST = 0x80103d02 ++ PTP_EXTTS_REQUEST2 = 0x80103d0b ++ PTP_MASK_CLEAR_ALL = 0x20003d13 ++ PTP_MASK_EN_SINGLE = 0x80043d14 ++ PTP_PEROUT_REQUEST = 0x80383d03 ++ PTP_PEROUT_REQUEST2 = 0x80383d0c ++ PTP_PIN_SETFUNC = 0x80603d07 ++ PTP_PIN_SETFUNC2 = 0x80603d10 ++ PTP_SYS_OFFSET = 0x83403d05 ++ PTP_SYS_OFFSET2 = 0x83403d0e + PTRACE_GETFPREGS = 0xe + PTRACE_GET_THREAD_AREA = 0x19 + PTRACE_GET_THREAD_AREA_3264 = 0xc4 +@@ -277,6 +297,8 @@ const ( + RTC_WIE_ON = 0x2000700f + RTC_WKALM_RD = 0x40287010 + RTC_WKALM_SET = 0x8028700f ++ SCM_DEVMEM_DMABUF = 0x4f ++ SCM_DEVMEM_LINEAR = 0x4e + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a +@@ -315,6 +337,9 @@ const ( + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DEVMEM_DMABUF = 0x4f ++ SO_DEVMEM_DONTNEED = 0x50 ++ SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x1029 + SO_DONTROUTE = 0x10 + SO_ERROR = 0x1007 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go b/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go +index 92af771..ced21d6 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go +@@ -108,6 +108,7 @@ const ( + HIDIOCGRAWINFO = 0x40084803 + HIDIOCGRDESC = 0x50044802 + HIDIOCGRDESCSIZE = 0x40044801 ++ HIDIOCREVOKE = 0x8004480d + HUPCL = 0x400 + ICANON = 0x2 + IEXTEN = 0x100 +@@ -150,9 +151,14 @@ const ( + NFDBITS = 0x40 + NLDLY = 0x100 + NOFLSH = 0x80 ++ NS_GET_MNTNS_ID = 0x4008b705 + NS_GET_NSTYPE = 0x2000b703 + NS_GET_OWNER_UID = 0x2000b704 + NS_GET_PARENT = 0x2000b702 ++ NS_GET_PID_FROM_PIDNS = 0x4004b706 ++ NS_GET_PID_IN_PIDNS = 0x4004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x4004b707 ++ NS_GET_TGID_IN_PIDNS = 0x4004b709 + NS_GET_USERNS = 0x2000b701 + OLCUC = 0x2 + ONLCR = 0x4 +@@ -229,6 +235,20 @@ const ( + PPPIOCUNBRIDGECHAN = 0x20007434 + PPPIOCXFERUNIT = 0x2000744e + PR_SET_PTRACER_ANY = 0xffffffffffffffff ++ PTP_CLOCK_GETCAPS = 0x40503d01 ++ PTP_CLOCK_GETCAPS2 = 0x40503d0a ++ PTP_ENABLE_PPS = 0x80043d04 ++ PTP_ENABLE_PPS2 = 0x80043d0d ++ PTP_EXTTS_REQUEST = 0x80103d02 ++ PTP_EXTTS_REQUEST2 = 0x80103d0b ++ PTP_MASK_CLEAR_ALL = 0x20003d13 ++ PTP_MASK_EN_SINGLE = 0x80043d14 ++ PTP_PEROUT_REQUEST = 0x80383d03 ++ PTP_PEROUT_REQUEST2 = 0x80383d0c ++ PTP_PIN_SETFUNC = 0x80603d07 ++ PTP_PIN_SETFUNC2 = 0x80603d10 ++ PTP_SYS_OFFSET = 0x83403d05 ++ PTP_SYS_OFFSET2 = 0x83403d0e + PTRACE_GETFPREGS = 0xe + PTRACE_GET_THREAD_AREA = 0x19 + PTRACE_GET_THREAD_AREA_3264 = 0xc4 +@@ -277,6 +297,8 @@ const ( + RTC_WIE_ON = 0x2000700f + RTC_WKALM_RD = 0x40287010 + RTC_WKALM_SET = 0x8028700f ++ SCM_DEVMEM_DMABUF = 0x4f ++ SCM_DEVMEM_LINEAR = 0x4e + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a +@@ -315,6 +337,9 @@ const ( + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DEVMEM_DMABUF = 0x4f ++ SO_DEVMEM_DONTNEED = 0x50 ++ SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x1029 + SO_DONTROUTE = 0x10 + SO_ERROR = 0x1007 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go b/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go +index b27ef5e..226c044 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go +@@ -108,6 +108,7 @@ const ( + HIDIOCGRAWINFO = 0x40084803 + HIDIOCGRDESC = 0x50044802 + HIDIOCGRDESCSIZE = 0x40044801 ++ HIDIOCREVOKE = 0x8004480d + HUPCL = 0x400 + ICANON = 0x2 + IEXTEN = 0x100 +@@ -150,9 +151,14 @@ const ( + NFDBITS = 0x20 + NLDLY = 0x100 + NOFLSH = 0x80 ++ NS_GET_MNTNS_ID = 0x4008b705 + NS_GET_NSTYPE = 0x2000b703 + NS_GET_OWNER_UID = 0x2000b704 + NS_GET_PARENT = 0x2000b702 ++ NS_GET_PID_FROM_PIDNS = 0x4004b706 ++ NS_GET_PID_IN_PIDNS = 0x4004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x4004b707 ++ NS_GET_TGID_IN_PIDNS = 0x4004b709 + NS_GET_USERNS = 0x2000b701 + OLCUC = 0x2 + ONLCR = 0x4 +@@ -229,6 +235,20 @@ const ( + PPPIOCUNBRIDGECHAN = 0x20007434 + PPPIOCXFERUNIT = 0x2000744e + PR_SET_PTRACER_ANY = 0xffffffff ++ PTP_CLOCK_GETCAPS = 0x40503d01 ++ PTP_CLOCK_GETCAPS2 = 0x40503d0a ++ PTP_ENABLE_PPS = 0x80043d04 ++ PTP_ENABLE_PPS2 = 0x80043d0d ++ PTP_EXTTS_REQUEST = 0x80103d02 ++ PTP_EXTTS_REQUEST2 = 0x80103d0b ++ PTP_MASK_CLEAR_ALL = 0x20003d13 ++ PTP_MASK_EN_SINGLE = 0x80043d14 ++ PTP_PEROUT_REQUEST = 0x80383d03 ++ PTP_PEROUT_REQUEST2 = 0x80383d0c ++ PTP_PIN_SETFUNC = 0x80603d07 ++ PTP_PIN_SETFUNC2 = 0x80603d10 ++ PTP_SYS_OFFSET = 0x83403d05 ++ PTP_SYS_OFFSET2 = 0x83403d0e + PTRACE_GETFPREGS = 0xe + PTRACE_GET_THREAD_AREA = 0x19 + PTRACE_GET_THREAD_AREA_3264 = 0xc4 +@@ -277,6 +297,8 @@ const ( + RTC_WIE_ON = 0x2000700f + RTC_WKALM_RD = 0x40287010 + RTC_WKALM_SET = 0x8028700f ++ SCM_DEVMEM_DMABUF = 0x4f ++ SCM_DEVMEM_LINEAR = 0x4e + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a +@@ -315,6 +337,9 @@ const ( + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DEVMEM_DMABUF = 0x4f ++ SO_DEVMEM_DONTNEED = 0x50 ++ SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x1029 + SO_DONTROUTE = 0x10 + SO_ERROR = 0x1007 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go +index 237a2ce..3122737 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go +@@ -108,6 +108,7 @@ const ( + HIDIOCGRAWINFO = 0x40084803 + HIDIOCGRDESC = 0x50044802 + HIDIOCGRDESCSIZE = 0x40044801 ++ HIDIOCREVOKE = 0x8004480d + HUPCL = 0x4000 + ICANON = 0x100 + IEXTEN = 0x400 +@@ -152,9 +153,14 @@ const ( + NL3 = 0x300 + NLDLY = 0x300 + NOFLSH = 0x80000000 ++ NS_GET_MNTNS_ID = 0x4008b705 + NS_GET_NSTYPE = 0x2000b703 + NS_GET_OWNER_UID = 0x2000b704 + NS_GET_PARENT = 0x2000b702 ++ NS_GET_PID_FROM_PIDNS = 0x4004b706 ++ NS_GET_PID_IN_PIDNS = 0x4004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x4004b707 ++ NS_GET_TGID_IN_PIDNS = 0x4004b709 + NS_GET_USERNS = 0x2000b701 + OLCUC = 0x4 + ONLCR = 0x2 +@@ -232,6 +238,20 @@ const ( + PPPIOCXFERUNIT = 0x2000744e + PROT_SAO = 0x10 + PR_SET_PTRACER_ANY = 0xffffffff ++ PTP_CLOCK_GETCAPS = 0x40503d01 ++ PTP_CLOCK_GETCAPS2 = 0x40503d0a ++ PTP_ENABLE_PPS = 0x80043d04 ++ PTP_ENABLE_PPS2 = 0x80043d0d ++ PTP_EXTTS_REQUEST = 0x80103d02 ++ PTP_EXTTS_REQUEST2 = 0x80103d0b ++ PTP_MASK_CLEAR_ALL = 0x20003d13 ++ PTP_MASK_EN_SINGLE = 0x80043d14 ++ PTP_PEROUT_REQUEST = 0x80383d03 ++ PTP_PEROUT_REQUEST2 = 0x80383d0c ++ PTP_PIN_SETFUNC = 0x80603d07 ++ PTP_PIN_SETFUNC2 = 0x80603d10 ++ PTP_SYS_OFFSET = 0x83403d05 ++ PTP_SYS_OFFSET2 = 0x83403d0e + PTRACE_GETEVRREGS = 0x14 + PTRACE_GETFPREGS = 0xe + PTRACE_GETREGS64 = 0x16 +@@ -332,6 +352,8 @@ const ( + RTC_WIE_ON = 0x2000700f + RTC_WKALM_RD = 0x40287010 + RTC_WKALM_SET = 0x8028700f ++ SCM_DEVMEM_DMABUF = 0x4f ++ SCM_DEVMEM_LINEAR = 0x4e + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a +@@ -370,6 +392,9 @@ const ( + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DEVMEM_DMABUF = 0x4f ++ SO_DEVMEM_DONTNEED = 0x50 ++ SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x27 + SO_DONTROUTE = 0x5 + SO_ERROR = 0x4 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go +index 4a5c555..eb5d346 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go +@@ -108,6 +108,7 @@ const ( + HIDIOCGRAWINFO = 0x40084803 + HIDIOCGRDESC = 0x50044802 + HIDIOCGRDESCSIZE = 0x40044801 ++ HIDIOCREVOKE = 0x8004480d + HUPCL = 0x4000 + ICANON = 0x100 + IEXTEN = 0x400 +@@ -152,9 +153,14 @@ const ( + NL3 = 0x300 + NLDLY = 0x300 + NOFLSH = 0x80000000 ++ NS_GET_MNTNS_ID = 0x4008b705 + NS_GET_NSTYPE = 0x2000b703 + NS_GET_OWNER_UID = 0x2000b704 + NS_GET_PARENT = 0x2000b702 ++ NS_GET_PID_FROM_PIDNS = 0x4004b706 ++ NS_GET_PID_IN_PIDNS = 0x4004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x4004b707 ++ NS_GET_TGID_IN_PIDNS = 0x4004b709 + NS_GET_USERNS = 0x2000b701 + OLCUC = 0x4 + ONLCR = 0x2 +@@ -232,6 +238,20 @@ const ( + PPPIOCXFERUNIT = 0x2000744e + PROT_SAO = 0x10 + PR_SET_PTRACER_ANY = 0xffffffffffffffff ++ PTP_CLOCK_GETCAPS = 0x40503d01 ++ PTP_CLOCK_GETCAPS2 = 0x40503d0a ++ PTP_ENABLE_PPS = 0x80043d04 ++ PTP_ENABLE_PPS2 = 0x80043d0d ++ PTP_EXTTS_REQUEST = 0x80103d02 ++ PTP_EXTTS_REQUEST2 = 0x80103d0b ++ PTP_MASK_CLEAR_ALL = 0x20003d13 ++ PTP_MASK_EN_SINGLE = 0x80043d14 ++ PTP_PEROUT_REQUEST = 0x80383d03 ++ PTP_PEROUT_REQUEST2 = 0x80383d0c ++ PTP_PIN_SETFUNC = 0x80603d07 ++ PTP_PIN_SETFUNC2 = 0x80603d10 ++ PTP_SYS_OFFSET = 0x83403d05 ++ PTP_SYS_OFFSET2 = 0x83403d0e + PTRACE_GETEVRREGS = 0x14 + PTRACE_GETFPREGS = 0xe + PTRACE_GETREGS64 = 0x16 +@@ -336,6 +356,8 @@ const ( + RTC_WIE_ON = 0x2000700f + RTC_WKALM_RD = 0x40287010 + RTC_WKALM_SET = 0x8028700f ++ SCM_DEVMEM_DMABUF = 0x4f ++ SCM_DEVMEM_LINEAR = 0x4e + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a +@@ -374,6 +396,9 @@ const ( + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DEVMEM_DMABUF = 0x4f ++ SO_DEVMEM_DONTNEED = 0x50 ++ SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x27 + SO_DONTROUTE = 0x5 + SO_ERROR = 0x4 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go +index a02fb49..e921ebc 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go +@@ -108,6 +108,7 @@ const ( + HIDIOCGRAWINFO = 0x40084803 + HIDIOCGRDESC = 0x50044802 + HIDIOCGRDESCSIZE = 0x40044801 ++ HIDIOCREVOKE = 0x8004480d + HUPCL = 0x4000 + ICANON = 0x100 + IEXTEN = 0x400 +@@ -152,9 +153,14 @@ const ( + NL3 = 0x300 + NLDLY = 0x300 + NOFLSH = 0x80000000 ++ NS_GET_MNTNS_ID = 0x4008b705 + NS_GET_NSTYPE = 0x2000b703 + NS_GET_OWNER_UID = 0x2000b704 + NS_GET_PARENT = 0x2000b702 ++ NS_GET_PID_FROM_PIDNS = 0x4004b706 ++ NS_GET_PID_IN_PIDNS = 0x4004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x4004b707 ++ NS_GET_TGID_IN_PIDNS = 0x4004b709 + NS_GET_USERNS = 0x2000b701 + OLCUC = 0x4 + ONLCR = 0x2 +@@ -232,6 +238,20 @@ const ( + PPPIOCXFERUNIT = 0x2000744e + PROT_SAO = 0x10 + PR_SET_PTRACER_ANY = 0xffffffffffffffff ++ PTP_CLOCK_GETCAPS = 0x40503d01 ++ PTP_CLOCK_GETCAPS2 = 0x40503d0a ++ PTP_ENABLE_PPS = 0x80043d04 ++ PTP_ENABLE_PPS2 = 0x80043d0d ++ PTP_EXTTS_REQUEST = 0x80103d02 ++ PTP_EXTTS_REQUEST2 = 0x80103d0b ++ PTP_MASK_CLEAR_ALL = 0x20003d13 ++ PTP_MASK_EN_SINGLE = 0x80043d14 ++ PTP_PEROUT_REQUEST = 0x80383d03 ++ PTP_PEROUT_REQUEST2 = 0x80383d0c ++ PTP_PIN_SETFUNC = 0x80603d07 ++ PTP_PIN_SETFUNC2 = 0x80603d10 ++ PTP_SYS_OFFSET = 0x83403d05 ++ PTP_SYS_OFFSET2 = 0x83403d0e + PTRACE_GETEVRREGS = 0x14 + PTRACE_GETFPREGS = 0xe + PTRACE_GETREGS64 = 0x16 +@@ -336,6 +356,8 @@ const ( + RTC_WIE_ON = 0x2000700f + RTC_WKALM_RD = 0x40287010 + RTC_WKALM_SET = 0x8028700f ++ SCM_DEVMEM_DMABUF = 0x4f ++ SCM_DEVMEM_LINEAR = 0x4e + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a +@@ -374,6 +396,9 @@ const ( + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DEVMEM_DMABUF = 0x4f ++ SO_DEVMEM_DONTNEED = 0x50 ++ SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x27 + SO_DONTROUTE = 0x5 + SO_ERROR = 0x4 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go +index e26a7c6..38ba81c 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go +@@ -108,6 +108,7 @@ const ( + HIDIOCGRAWINFO = 0x80084803 + HIDIOCGRDESC = 0x90044802 + HIDIOCGRDESCSIZE = 0x80044801 ++ HIDIOCREVOKE = 0x4004480d + HUPCL = 0x400 + ICANON = 0x2 + IEXTEN = 0x8000 +@@ -150,9 +151,14 @@ const ( + NFDBITS = 0x40 + NLDLY = 0x100 + NOFLSH = 0x80 ++ NS_GET_MNTNS_ID = 0x8008b705 + NS_GET_NSTYPE = 0xb703 + NS_GET_OWNER_UID = 0xb704 + NS_GET_PARENT = 0xb702 ++ NS_GET_PID_FROM_PIDNS = 0x8004b706 ++ NS_GET_PID_IN_PIDNS = 0x8004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x8004b707 ++ NS_GET_TGID_IN_PIDNS = 0x8004b709 + NS_GET_USERNS = 0xb701 + OLCUC = 0x2 + ONLCR = 0x4 +@@ -229,6 +235,20 @@ const ( + PPPIOCUNBRIDGECHAN = 0x7434 + PPPIOCXFERUNIT = 0x744e + PR_SET_PTRACER_ANY = 0xffffffffffffffff ++ PTP_CLOCK_GETCAPS = 0x80503d01 ++ PTP_CLOCK_GETCAPS2 = 0x80503d0a ++ PTP_ENABLE_PPS = 0x40043d04 ++ PTP_ENABLE_PPS2 = 0x40043d0d ++ PTP_EXTTS_REQUEST = 0x40103d02 ++ PTP_EXTTS_REQUEST2 = 0x40103d0b ++ PTP_MASK_CLEAR_ALL = 0x3d13 ++ PTP_MASK_EN_SINGLE = 0x40043d14 ++ PTP_PEROUT_REQUEST = 0x40383d03 ++ PTP_PEROUT_REQUEST2 = 0x40383d0c ++ PTP_PIN_SETFUNC = 0x40603d07 ++ PTP_PIN_SETFUNC2 = 0x40603d10 ++ PTP_SYS_OFFSET = 0x43403d05 ++ PTP_SYS_OFFSET2 = 0x43403d0e + PTRACE_GETFDPIC = 0x21 + PTRACE_GETFDPIC_EXEC = 0x0 + PTRACE_GETFDPIC_INTERP = 0x1 +@@ -268,6 +288,8 @@ const ( + RTC_WIE_ON = 0x700f + RTC_WKALM_RD = 0x80287010 + RTC_WKALM_SET = 0x4028700f ++ SCM_DEVMEM_DMABUF = 0x4f ++ SCM_DEVMEM_LINEAR = 0x4e + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a +@@ -306,6 +328,9 @@ const ( + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DEVMEM_DMABUF = 0x4f ++ SO_DEVMEM_DONTNEED = 0x50 ++ SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x27 + SO_DONTROUTE = 0x5 + SO_ERROR = 0x4 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go b/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go +index c48f7c2..71f0400 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go +@@ -108,6 +108,7 @@ const ( + HIDIOCGRAWINFO = 0x80084803 + HIDIOCGRDESC = 0x90044802 + HIDIOCGRDESCSIZE = 0x80044801 ++ HIDIOCREVOKE = 0x4004480d + HUPCL = 0x400 + ICANON = 0x2 + IEXTEN = 0x8000 +@@ -150,9 +151,14 @@ const ( + NFDBITS = 0x40 + NLDLY = 0x100 + NOFLSH = 0x80 ++ NS_GET_MNTNS_ID = 0x8008b705 + NS_GET_NSTYPE = 0xb703 + NS_GET_OWNER_UID = 0xb704 + NS_GET_PARENT = 0xb702 ++ NS_GET_PID_FROM_PIDNS = 0x8004b706 ++ NS_GET_PID_IN_PIDNS = 0x8004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x8004b707 ++ NS_GET_TGID_IN_PIDNS = 0x8004b709 + NS_GET_USERNS = 0xb701 + OLCUC = 0x2 + ONLCR = 0x4 +@@ -229,6 +235,20 @@ const ( + PPPIOCUNBRIDGECHAN = 0x7434 + PPPIOCXFERUNIT = 0x744e + PR_SET_PTRACER_ANY = 0xffffffffffffffff ++ PTP_CLOCK_GETCAPS = 0x80503d01 ++ PTP_CLOCK_GETCAPS2 = 0x80503d0a ++ PTP_ENABLE_PPS = 0x40043d04 ++ PTP_ENABLE_PPS2 = 0x40043d0d ++ PTP_EXTTS_REQUEST = 0x40103d02 ++ PTP_EXTTS_REQUEST2 = 0x40103d0b ++ PTP_MASK_CLEAR_ALL = 0x3d13 ++ PTP_MASK_EN_SINGLE = 0x40043d14 ++ PTP_PEROUT_REQUEST = 0x40383d03 ++ PTP_PEROUT_REQUEST2 = 0x40383d0c ++ PTP_PIN_SETFUNC = 0x40603d07 ++ PTP_PIN_SETFUNC2 = 0x40603d10 ++ PTP_SYS_OFFSET = 0x43403d05 ++ PTP_SYS_OFFSET2 = 0x43403d0e + PTRACE_DISABLE_TE = 0x5010 + PTRACE_ENABLE_TE = 0x5009 + PTRACE_GET_LAST_BREAK = 0x5006 +@@ -340,6 +360,8 @@ const ( + RTC_WIE_ON = 0x700f + RTC_WKALM_RD = 0x80287010 + RTC_WKALM_SET = 0x4028700f ++ SCM_DEVMEM_DMABUF = 0x4f ++ SCM_DEVMEM_LINEAR = 0x4e + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a +@@ -378,6 +400,9 @@ const ( + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DEVMEM_DMABUF = 0x4f ++ SO_DEVMEM_DONTNEED = 0x50 ++ SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x27 + SO_DONTROUTE = 0x5 + SO_ERROR = 0x4 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go +index ad4b9aa..c44a313 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go +@@ -112,6 +112,7 @@ const ( + HIDIOCGRAWINFO = 0x40084803 + HIDIOCGRDESC = 0x50044802 + HIDIOCGRDESCSIZE = 0x40044801 ++ HIDIOCREVOKE = 0x8004480d + HUPCL = 0x400 + ICANON = 0x2 + IEXTEN = 0x8000 +@@ -155,9 +156,14 @@ const ( + NFDBITS = 0x40 + NLDLY = 0x100 + NOFLSH = 0x80 ++ NS_GET_MNTNS_ID = 0x4008b705 + NS_GET_NSTYPE = 0x2000b703 + NS_GET_OWNER_UID = 0x2000b704 + NS_GET_PARENT = 0x2000b702 ++ NS_GET_PID_FROM_PIDNS = 0x4004b706 ++ NS_GET_PID_IN_PIDNS = 0x4004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x4004b707 ++ NS_GET_TGID_IN_PIDNS = 0x4004b709 + NS_GET_USERNS = 0x2000b701 + OLCUC = 0x2 + ONLCR = 0x4 +@@ -234,6 +240,20 @@ const ( + PPPIOCUNBRIDGECHAN = 0x20007434 + PPPIOCXFERUNIT = 0x2000744e + PR_SET_PTRACER_ANY = 0xffffffffffffffff ++ PTP_CLOCK_GETCAPS = 0x40503d01 ++ PTP_CLOCK_GETCAPS2 = 0x40503d0a ++ PTP_ENABLE_PPS = 0x80043d04 ++ PTP_ENABLE_PPS2 = 0x80043d0d ++ PTP_EXTTS_REQUEST = 0x80103d02 ++ PTP_EXTTS_REQUEST2 = 0x80103d0b ++ PTP_MASK_CLEAR_ALL = 0x20003d13 ++ PTP_MASK_EN_SINGLE = 0x80043d14 ++ PTP_PEROUT_REQUEST = 0x80383d03 ++ PTP_PEROUT_REQUEST2 = 0x80383d0c ++ PTP_PIN_SETFUNC = 0x80603d07 ++ PTP_PIN_SETFUNC2 = 0x80603d10 ++ PTP_SYS_OFFSET = 0x83403d05 ++ PTP_SYS_OFFSET2 = 0x83403d0e + PTRACE_GETFPAREGS = 0x14 + PTRACE_GETFPREGS = 0xe + PTRACE_GETFPREGS64 = 0x19 +@@ -331,6 +351,8 @@ const ( + RTC_WIE_ON = 0x2000700f + RTC_WKALM_RD = 0x40287010 + RTC_WKALM_SET = 0x8028700f ++ SCM_DEVMEM_DMABUF = 0x58 ++ SCM_DEVMEM_LINEAR = 0x57 + SCM_TIMESTAMPING = 0x23 + SCM_TIMESTAMPING_OPT_STATS = 0x38 + SCM_TIMESTAMPING_PKTINFO = 0x3c +@@ -417,6 +439,9 @@ const ( + SO_CNX_ADVICE = 0x37 + SO_COOKIE = 0x3b + SO_DETACH_REUSEPORT_BPF = 0x47 ++ SO_DEVMEM_DMABUF = 0x58 ++ SO_DEVMEM_DONTNEED = 0x59 ++ SO_DEVMEM_LINEAR = 0x57 + SO_DOMAIN = 0x1029 + SO_DONTROUTE = 0x10 + SO_ERROR = 0x1007 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_zos_s390x.go b/vendor/golang.org/x/sys/unix/zerrors_zos_s390x.go +index da08b2a..1ec2b14 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_zos_s390x.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_zos_s390x.go +@@ -581,6 +581,8 @@ const ( + AT_EMPTY_PATH = 0x1000 + AT_REMOVEDIR = 0x200 + RENAME_NOREPLACE = 1 << 0 ++ ST_RDONLY = 1 ++ ST_NOSUID = 2 + ) + + const ( +diff --git a/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go b/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go +index b622533..24b346e 100644 +--- a/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go ++++ b/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go +@@ -841,6 +841,26 @@ var libc_pthread_fchdir_np_trampoline_addr uintptr + + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + ++func connectx(fd int, endpoints *SaEndpoints, associd SaeAssocID, flags uint32, iov []Iovec, n *uintptr, connid *SaeConnID) (err error) { ++ var _p0 unsafe.Pointer ++ if len(iov) > 0 { ++ _p0 = unsafe.Pointer(&iov[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ _, _, e1 := syscall_syscall9(libc_connectx_trampoline_addr, uintptr(fd), uintptr(unsafe.Pointer(endpoints)), uintptr(associd), uintptr(flags), uintptr(_p0), uintptr(len(iov)), uintptr(unsafe.Pointer(n)), uintptr(unsafe.Pointer(connid)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++var libc_connectx_trampoline_addr uintptr ++ ++//go:cgo_import_dynamic libc_connectx connectx "/usr/lib/libSystem.B.dylib" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ + func sendfile(infd int, outfd int, offset int64, len *int64, hdtr unsafe.Pointer, flags int) (err error) { + _, _, e1 := syscall_syscall6(libc_sendfile_trampoline_addr, uintptr(infd), uintptr(outfd), uintptr(offset), uintptr(unsafe.Pointer(len)), uintptr(hdtr), uintptr(flags)) + if e1 != 0 { +diff --git a/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.s b/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.s +index cfe6646..ebd2131 100644 +--- a/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.s ++++ b/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.s +@@ -248,6 +248,11 @@ TEXT libc_pthread_fchdir_np_trampoline<>(SB),NOSPLIT,$0-0 + GLOBL ·libc_pthread_fchdir_np_trampoline_addr(SB), RODATA, $8 + DATA ·libc_pthread_fchdir_np_trampoline_addr(SB)/8, $libc_pthread_fchdir_np_trampoline<>(SB) + ++TEXT libc_connectx_trampoline<>(SB),NOSPLIT,$0-0 ++ JMP libc_connectx(SB) ++GLOBL ·libc_connectx_trampoline_addr(SB), RODATA, $8 ++DATA ·libc_connectx_trampoline_addr(SB)/8, $libc_connectx_trampoline<>(SB) ++ + TEXT libc_sendfile_trampoline<>(SB),NOSPLIT,$0-0 + JMP libc_sendfile(SB) + GLOBL ·libc_sendfile_trampoline_addr(SB), RODATA, $8 +diff --git a/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go b/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go +index 13f624f..824b9c2 100644 +--- a/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go ++++ b/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go +@@ -841,6 +841,26 @@ var libc_pthread_fchdir_np_trampoline_addr uintptr + + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + ++func connectx(fd int, endpoints *SaEndpoints, associd SaeAssocID, flags uint32, iov []Iovec, n *uintptr, connid *SaeConnID) (err error) { ++ var _p0 unsafe.Pointer ++ if len(iov) > 0 { ++ _p0 = unsafe.Pointer(&iov[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ _, _, e1 := syscall_syscall9(libc_connectx_trampoline_addr, uintptr(fd), uintptr(unsafe.Pointer(endpoints)), uintptr(associd), uintptr(flags), uintptr(_p0), uintptr(len(iov)), uintptr(unsafe.Pointer(n)), uintptr(unsafe.Pointer(connid)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++var libc_connectx_trampoline_addr uintptr ++ ++//go:cgo_import_dynamic libc_connectx connectx "/usr/lib/libSystem.B.dylib" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ + func sendfile(infd int, outfd int, offset int64, len *int64, hdtr unsafe.Pointer, flags int) (err error) { + _, _, e1 := syscall_syscall6(libc_sendfile_trampoline_addr, uintptr(infd), uintptr(outfd), uintptr(offset), uintptr(unsafe.Pointer(len)), uintptr(hdtr), uintptr(flags)) + if e1 != 0 { +diff --git a/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.s b/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.s +index fe222b7..4f178a2 100644 +--- a/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.s ++++ b/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.s +@@ -248,6 +248,11 @@ TEXT libc_pthread_fchdir_np_trampoline<>(SB),NOSPLIT,$0-0 + GLOBL ·libc_pthread_fchdir_np_trampoline_addr(SB), RODATA, $8 + DATA ·libc_pthread_fchdir_np_trampoline_addr(SB)/8, $libc_pthread_fchdir_np_trampoline<>(SB) + ++TEXT libc_connectx_trampoline<>(SB),NOSPLIT,$0-0 ++ JMP libc_connectx(SB) ++GLOBL ·libc_connectx_trampoline_addr(SB), RODATA, $8 ++DATA ·libc_connectx_trampoline_addr(SB)/8, $libc_connectx_trampoline<>(SB) ++ + TEXT libc_sendfile_trampoline<>(SB),NOSPLIT,$0-0 + JMP libc_sendfile(SB) + GLOBL ·libc_sendfile_trampoline_addr(SB), RODATA, $8 +diff --git a/vendor/golang.org/x/sys/unix/zsyscall_linux.go b/vendor/golang.org/x/sys/unix/zsyscall_linux.go +index 1bc1a5a..5cc1e8e 100644 +--- a/vendor/golang.org/x/sys/unix/zsyscall_linux.go ++++ b/vendor/golang.org/x/sys/unix/zsyscall_linux.go +@@ -592,6 +592,16 @@ func ClockGettime(clockid int32, time *Timespec) (err error) { + + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + ++func ClockSettime(clockid int32, time *Timespec) (err error) { ++ _, _, e1 := Syscall(SYS_CLOCK_SETTIME, uintptr(clockid), uintptr(unsafe.Pointer(time)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ + func ClockNanosleep(clockid int32, flags int, request *Timespec, remain *Timespec) (err error) { + _, _, e1 := Syscall6(SYS_CLOCK_NANOSLEEP, uintptr(clockid), uintptr(flags), uintptr(unsafe.Pointer(request)), uintptr(unsafe.Pointer(remain)), 0, 0) + if e1 != 0 { +@@ -971,23 +981,6 @@ func Getpriority(which int, who int) (prio int, err error) { + + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +-func Getrandom(buf []byte, flags int) (n int, err error) { +- var _p0 unsafe.Pointer +- if len(buf) > 0 { +- _p0 = unsafe.Pointer(&buf[0]) +- } else { +- _p0 = unsafe.Pointer(&_zero) +- } +- r0, _, e1 := Syscall(SYS_GETRANDOM, uintptr(_p0), uintptr(len(buf)), uintptr(flags)) +- n = int(r0) +- if e1 != 0 { +- err = errnoErr(e1) +- } +- return +-} +- +-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT +- + func Getrusage(who int, rusage *Rusage) (err error) { + _, _, e1 := RawSyscall(SYS_GETRUSAGE, uintptr(who), uintptr(unsafe.Pointer(rusage)), 0) + if e1 != 0 { +diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go +index d3e38f6..f485dbf 100644 +--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go ++++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go +@@ -341,6 +341,7 @@ const ( + SYS_STATX = 332 + SYS_IO_PGETEVENTS = 333 + SYS_RSEQ = 334 ++ SYS_URETPROBE = 335 + SYS_PIDFD_SEND_SIGNAL = 424 + SYS_IO_URING_SETUP = 425 + SYS_IO_URING_ENTER = 426 +diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go +index 6c778c2..1893e2f 100644 +--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go ++++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go +@@ -85,7 +85,7 @@ const ( + SYS_SPLICE = 76 + SYS_TEE = 77 + SYS_READLINKAT = 78 +- SYS_FSTATAT = 79 ++ SYS_NEWFSTATAT = 79 + SYS_FSTAT = 80 + SYS_SYNC = 81 + SYS_FSYNC = 82 +diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_loong64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_loong64.go +index 37281cf..16a4017 100644 +--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_loong64.go ++++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_loong64.go +@@ -84,6 +84,8 @@ const ( + SYS_SPLICE = 76 + SYS_TEE = 77 + SYS_READLINKAT = 78 ++ SYS_NEWFSTATAT = 79 ++ SYS_FSTAT = 80 + SYS_SYNC = 81 + SYS_FSYNC = 82 + SYS_FDATASYNC = 83 +diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go +index 9889f6a..a5459e7 100644 +--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go ++++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go +@@ -84,7 +84,7 @@ const ( + SYS_SPLICE = 76 + SYS_TEE = 77 + SYS_READLINKAT = 78 +- SYS_FSTATAT = 79 ++ SYS_NEWFSTATAT = 79 + SYS_FSTAT = 80 + SYS_SYNC = 81 + SYS_FSYNC = 82 +diff --git a/vendor/golang.org/x/sys/unix/ztypes_darwin_amd64.go b/vendor/golang.org/x/sys/unix/ztypes_darwin_amd64.go +index 091d107..17c53bd 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_darwin_amd64.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_darwin_amd64.go +@@ -306,6 +306,19 @@ type XVSockPgen struct { + + type _Socklen uint32 + ++type SaeAssocID uint32 ++ ++type SaeConnID uint32 ++ ++type SaEndpoints struct { ++ Srcif uint32 ++ Srcaddr *RawSockaddr ++ Srcaddrlen uint32 ++ Dstaddr *RawSockaddr ++ Dstaddrlen uint32 ++ _ [4]byte ++} ++ + type Xucred struct { + Version uint32 + Uid uint32 +@@ -449,11 +462,14 @@ type FdSet struct { + + const ( + SizeofIfMsghdr = 0x70 ++ SizeofIfMsghdr2 = 0xa0 + SizeofIfData = 0x60 ++ SizeofIfData64 = 0x80 + SizeofIfaMsghdr = 0x14 + SizeofIfmaMsghdr = 0x10 + SizeofIfmaMsghdr2 = 0x14 + SizeofRtMsghdr = 0x5c ++ SizeofRtMsghdr2 = 0x5c + SizeofRtMetrics = 0x38 + ) + +@@ -467,6 +483,20 @@ type IfMsghdr struct { + Data IfData + } + ++type IfMsghdr2 struct { ++ Msglen uint16 ++ Version uint8 ++ Type uint8 ++ Addrs int32 ++ Flags int32 ++ Index uint16 ++ Snd_len int32 ++ Snd_maxlen int32 ++ Snd_drops int32 ++ Timer int32 ++ Data IfData64 ++} ++ + type IfData struct { + Type uint8 + Typelen uint8 +@@ -499,6 +529,34 @@ type IfData struct { + Reserved2 uint32 + } + ++type IfData64 struct { ++ Type uint8 ++ Typelen uint8 ++ Physical uint8 ++ Addrlen uint8 ++ Hdrlen uint8 ++ Recvquota uint8 ++ Xmitquota uint8 ++ Unused1 uint8 ++ Mtu uint32 ++ Metric uint32 ++ Baudrate uint64 ++ Ipackets uint64 ++ Ierrors uint64 ++ Opackets uint64 ++ Oerrors uint64 ++ Collisions uint64 ++ Ibytes uint64 ++ Obytes uint64 ++ Imcasts uint64 ++ Omcasts uint64 ++ Iqdrops uint64 ++ Noproto uint64 ++ Recvtiming uint32 ++ Xmittiming uint32 ++ Lastchange Timeval32 ++} ++ + type IfaMsghdr struct { + Msglen uint16 + Version uint8 +@@ -544,6 +602,21 @@ type RtMsghdr struct { + Rmx RtMetrics + } + ++type RtMsghdr2 struct { ++ Msglen uint16 ++ Version uint8 ++ Type uint8 ++ Index uint16 ++ Flags int32 ++ Addrs int32 ++ Refcnt int32 ++ Parentflags int32 ++ Reserved int32 ++ Use int32 ++ Inits uint32 ++ Rmx RtMetrics ++} ++ + type RtMetrics struct { + Locks uint32 + Mtu uint32 +diff --git a/vendor/golang.org/x/sys/unix/ztypes_darwin_arm64.go b/vendor/golang.org/x/sys/unix/ztypes_darwin_arm64.go +index 28ff4ef..2392226 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_darwin_arm64.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_darwin_arm64.go +@@ -306,6 +306,19 @@ type XVSockPgen struct { + + type _Socklen uint32 + ++type SaeAssocID uint32 ++ ++type SaeConnID uint32 ++ ++type SaEndpoints struct { ++ Srcif uint32 ++ Srcaddr *RawSockaddr ++ Srcaddrlen uint32 ++ Dstaddr *RawSockaddr ++ Dstaddrlen uint32 ++ _ [4]byte ++} ++ + type Xucred struct { + Version uint32 + Uid uint32 +@@ -449,11 +462,14 @@ type FdSet struct { + + const ( + SizeofIfMsghdr = 0x70 ++ SizeofIfMsghdr2 = 0xa0 + SizeofIfData = 0x60 ++ SizeofIfData64 = 0x80 + SizeofIfaMsghdr = 0x14 + SizeofIfmaMsghdr = 0x10 + SizeofIfmaMsghdr2 = 0x14 + SizeofRtMsghdr = 0x5c ++ SizeofRtMsghdr2 = 0x5c + SizeofRtMetrics = 0x38 + ) + +@@ -467,6 +483,20 @@ type IfMsghdr struct { + Data IfData + } + ++type IfMsghdr2 struct { ++ Msglen uint16 ++ Version uint8 ++ Type uint8 ++ Addrs int32 ++ Flags int32 ++ Index uint16 ++ Snd_len int32 ++ Snd_maxlen int32 ++ Snd_drops int32 ++ Timer int32 ++ Data IfData64 ++} ++ + type IfData struct { + Type uint8 + Typelen uint8 +@@ -499,6 +529,34 @@ type IfData struct { + Reserved2 uint32 + } + ++type IfData64 struct { ++ Type uint8 ++ Typelen uint8 ++ Physical uint8 ++ Addrlen uint8 ++ Hdrlen uint8 ++ Recvquota uint8 ++ Xmitquota uint8 ++ Unused1 uint8 ++ Mtu uint32 ++ Metric uint32 ++ Baudrate uint64 ++ Ipackets uint64 ++ Ierrors uint64 ++ Opackets uint64 ++ Oerrors uint64 ++ Collisions uint64 ++ Ibytes uint64 ++ Obytes uint64 ++ Imcasts uint64 ++ Omcasts uint64 ++ Iqdrops uint64 ++ Noproto uint64 ++ Recvtiming uint32 ++ Xmittiming uint32 ++ Lastchange Timeval32 ++} ++ + type IfaMsghdr struct { + Msglen uint16 + Version uint8 +@@ -544,6 +602,21 @@ type RtMsghdr struct { + Rmx RtMetrics + } + ++type RtMsghdr2 struct { ++ Msglen uint16 ++ Version uint8 ++ Type uint8 ++ Index uint16 ++ Flags int32 ++ Addrs int32 ++ Refcnt int32 ++ Parentflags int32 ++ Reserved int32 ++ Use int32 ++ Inits uint32 ++ Rmx RtMetrics ++} ++ + type RtMetrics struct { + Locks uint32 + Mtu uint32 +diff --git a/vendor/golang.org/x/sys/unix/ztypes_freebsd_386.go b/vendor/golang.org/x/sys/unix/ztypes_freebsd_386.go +index 6cbd094..51e13eb 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_freebsd_386.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_freebsd_386.go +@@ -625,6 +625,7 @@ const ( + POLLRDNORM = 0x40 + POLLWRBAND = 0x100 + POLLWRNORM = 0x4 ++ POLLRDHUP = 0x4000 + ) + + type CapRights struct { +diff --git a/vendor/golang.org/x/sys/unix/ztypes_freebsd_amd64.go b/vendor/golang.org/x/sys/unix/ztypes_freebsd_amd64.go +index 7c03b6e..d002d8e 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_freebsd_amd64.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_freebsd_amd64.go +@@ -630,6 +630,7 @@ const ( + POLLRDNORM = 0x40 + POLLWRBAND = 0x100 + POLLWRNORM = 0x4 ++ POLLRDHUP = 0x4000 + ) + + type CapRights struct { +diff --git a/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm.go b/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm.go +index 422107e..3f863d8 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm.go +@@ -616,6 +616,7 @@ const ( + POLLRDNORM = 0x40 + POLLWRBAND = 0x100 + POLLWRNORM = 0x4 ++ POLLRDHUP = 0x4000 + ) + + type CapRights struct { +diff --git a/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm64.go b/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm64.go +index 505a12a..61c7293 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm64.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm64.go +@@ -610,6 +610,7 @@ const ( + POLLRDNORM = 0x40 + POLLWRBAND = 0x100 + POLLWRNORM = 0x4 ++ POLLRDHUP = 0x4000 + ) + + type CapRights struct { +diff --git a/vendor/golang.org/x/sys/unix/ztypes_freebsd_riscv64.go b/vendor/golang.org/x/sys/unix/ztypes_freebsd_riscv64.go +index cc986c7..b5d1741 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_freebsd_riscv64.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_freebsd_riscv64.go +@@ -612,6 +612,7 @@ const ( + POLLRDNORM = 0x40 + POLLWRBAND = 0x100 + POLLWRNORM = 0x4 ++ POLLRDHUP = 0x4000 + ) + + type CapRights struct { +diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux.go b/vendor/golang.org/x/sys/unix/ztypes_linux.go +index b102b95..5537148 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_linux.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_linux.go +@@ -87,31 +87,35 @@ type StatxTimestamp struct { + } + + type Statx_t struct { +- Mask uint32 +- Blksize uint32 +- Attributes uint64 +- Nlink uint32 +- Uid uint32 +- Gid uint32 +- Mode uint16 +- _ [1]uint16 +- Ino uint64 +- Size uint64 +- Blocks uint64 +- Attributes_mask uint64 +- Atime StatxTimestamp +- Btime StatxTimestamp +- Ctime StatxTimestamp +- Mtime StatxTimestamp +- Rdev_major uint32 +- Rdev_minor uint32 +- Dev_major uint32 +- Dev_minor uint32 +- Mnt_id uint64 +- Dio_mem_align uint32 +- Dio_offset_align uint32 +- Subvol uint64 +- _ [11]uint64 ++ Mask uint32 ++ Blksize uint32 ++ Attributes uint64 ++ Nlink uint32 ++ Uid uint32 ++ Gid uint32 ++ Mode uint16 ++ _ [1]uint16 ++ Ino uint64 ++ Size uint64 ++ Blocks uint64 ++ Attributes_mask uint64 ++ Atime StatxTimestamp ++ Btime StatxTimestamp ++ Ctime StatxTimestamp ++ Mtime StatxTimestamp ++ Rdev_major uint32 ++ Rdev_minor uint32 ++ Dev_major uint32 ++ Dev_minor uint32 ++ Mnt_id uint64 ++ Dio_mem_align uint32 ++ Dio_offset_align uint32 ++ Subvol uint64 ++ Atomic_write_unit_min uint32 ++ Atomic_write_unit_max uint32 ++ Atomic_write_segments_max uint32 ++ _ [1]uint32 ++ _ [9]uint64 + } + + type Fsid struct { +@@ -516,6 +520,29 @@ type TCPInfo struct { + Total_rto_time uint32 + } + ++type TCPVegasInfo struct { ++ Enabled uint32 ++ Rttcnt uint32 ++ Rtt uint32 ++ Minrtt uint32 ++} ++ ++type TCPDCTCPInfo struct { ++ Enabled uint16 ++ Ce_state uint16 ++ Alpha uint32 ++ Ab_ecn uint32 ++ Ab_tot uint32 ++} ++ ++type TCPBBRInfo struct { ++ Bw_lo uint32 ++ Bw_hi uint32 ++ Min_rtt uint32 ++ Pacing_gain uint32 ++ Cwnd_gain uint32 ++} ++ + type CanFilter struct { + Id uint32 + Mask uint32 +@@ -557,6 +584,7 @@ const ( + SizeofICMPv6Filter = 0x20 + SizeofUcred = 0xc + SizeofTCPInfo = 0xf8 ++ SizeofTCPCCInfo = 0x14 + SizeofCanFilter = 0x8 + SizeofTCPRepairOpt = 0x8 + ) +@@ -1724,12 +1752,6 @@ const ( + IFLA_IPVLAN_UNSPEC = 0x0 + IFLA_IPVLAN_MODE = 0x1 + IFLA_IPVLAN_FLAGS = 0x2 +- NETKIT_NEXT = -0x1 +- NETKIT_PASS = 0x0 +- NETKIT_DROP = 0x2 +- NETKIT_REDIRECT = 0x7 +- NETKIT_L2 = 0x0 +- NETKIT_L3 = 0x1 + IFLA_NETKIT_UNSPEC = 0x0 + IFLA_NETKIT_PEER_INFO = 0x1 + IFLA_NETKIT_PRIMARY = 0x2 +@@ -1768,6 +1790,7 @@ const ( + IFLA_VXLAN_DF = 0x1d + IFLA_VXLAN_VNIFILTER = 0x1e + IFLA_VXLAN_LOCALBYPASS = 0x1f ++ IFLA_VXLAN_LABEL_POLICY = 0x20 + IFLA_GENEVE_UNSPEC = 0x0 + IFLA_GENEVE_ID = 0x1 + IFLA_GENEVE_REMOTE = 0x2 +@@ -1797,6 +1820,8 @@ const ( + IFLA_GTP_ROLE = 0x4 + IFLA_GTP_CREATE_SOCKETS = 0x5 + IFLA_GTP_RESTART_COUNT = 0x6 ++ IFLA_GTP_LOCAL = 0x7 ++ IFLA_GTP_LOCAL6 = 0x8 + IFLA_BOND_UNSPEC = 0x0 + IFLA_BOND_MODE = 0x1 + IFLA_BOND_ACTIVE_SLAVE = 0x2 +@@ -1829,6 +1854,7 @@ const ( + IFLA_BOND_AD_LACP_ACTIVE = 0x1d + IFLA_BOND_MISSED_MAX = 0x1e + IFLA_BOND_NS_IP6_TARGET = 0x1f ++ IFLA_BOND_COUPLED_CONTROL = 0x20 + IFLA_BOND_AD_INFO_UNSPEC = 0x0 + IFLA_BOND_AD_INFO_AGGREGATOR = 0x1 + IFLA_BOND_AD_INFO_NUM_PORTS = 0x2 +@@ -1897,6 +1923,7 @@ const ( + IFLA_HSR_SEQ_NR = 0x5 + IFLA_HSR_VERSION = 0x6 + IFLA_HSR_PROTOCOL = 0x7 ++ IFLA_HSR_INTERLINK = 0x8 + IFLA_STATS_UNSPEC = 0x0 + IFLA_STATS_LINK_64 = 0x1 + IFLA_STATS_LINK_XSTATS = 0x2 +@@ -1949,6 +1976,15 @@ const ( + IFLA_DSA_MASTER = 0x1 + ) + ++const ( ++ NETKIT_NEXT = -0x1 ++ NETKIT_PASS = 0x0 ++ NETKIT_DROP = 0x2 ++ NETKIT_REDIRECT = 0x7 ++ NETKIT_L2 = 0x0 ++ NETKIT_L3 = 0x1 ++) ++ + const ( + NF_INET_PRE_ROUTING = 0x0 + NF_INET_LOCAL_IN = 0x1 +@@ -2486,7 +2522,7 @@ type XDPMmapOffsets struct { + type XDPUmemReg struct { + Addr uint64 + Len uint64 +- Chunk_size uint32 ++ Size uint32 + Headroom uint32 + Flags uint32 + Tx_metadata_len uint32 +@@ -2558,8 +2594,8 @@ const ( + SOF_TIMESTAMPING_BIND_PHC = 0x8000 + SOF_TIMESTAMPING_OPT_ID_TCP = 0x10000 + +- SOF_TIMESTAMPING_LAST = 0x10000 +- SOF_TIMESTAMPING_MASK = 0x1ffff ++ SOF_TIMESTAMPING_LAST = 0x20000 ++ SOF_TIMESTAMPING_MASK = 0x3ffff + + SCM_TSTAMP_SND = 0x0 + SCM_TSTAMP_SCHED = 0x1 +@@ -3505,7 +3541,7 @@ type Nhmsg struct { + type NexthopGrp struct { + Id uint32 + Weight uint8 +- Resvd1 uint8 ++ High uint8 + Resvd2 uint16 + } + +@@ -3766,7 +3802,7 @@ const ( + ETHTOOL_MSG_PSE_GET = 0x24 + ETHTOOL_MSG_PSE_SET = 0x25 + ETHTOOL_MSG_RSS_GET = 0x26 +- ETHTOOL_MSG_USER_MAX = 0x2b ++ ETHTOOL_MSG_USER_MAX = 0x2d + ETHTOOL_MSG_KERNEL_NONE = 0x0 + ETHTOOL_MSG_STRSET_GET_REPLY = 0x1 + ETHTOOL_MSG_LINKINFO_GET_REPLY = 0x2 +@@ -3806,12 +3842,15 @@ const ( + ETHTOOL_MSG_MODULE_NTF = 0x24 + ETHTOOL_MSG_PSE_GET_REPLY = 0x25 + ETHTOOL_MSG_RSS_GET_REPLY = 0x26 +- ETHTOOL_MSG_KERNEL_MAX = 0x2b ++ ETHTOOL_MSG_KERNEL_MAX = 0x2e ++ ETHTOOL_FLAG_COMPACT_BITSETS = 0x1 ++ ETHTOOL_FLAG_OMIT_REPLY = 0x2 ++ ETHTOOL_FLAG_STATS = 0x4 + ETHTOOL_A_HEADER_UNSPEC = 0x0 + ETHTOOL_A_HEADER_DEV_INDEX = 0x1 + ETHTOOL_A_HEADER_DEV_NAME = 0x2 + ETHTOOL_A_HEADER_FLAGS = 0x3 +- ETHTOOL_A_HEADER_MAX = 0x3 ++ ETHTOOL_A_HEADER_MAX = 0x4 + ETHTOOL_A_BITSET_BIT_UNSPEC = 0x0 + ETHTOOL_A_BITSET_BIT_INDEX = 0x1 + ETHTOOL_A_BITSET_BIT_NAME = 0x2 +@@ -3948,7 +3987,7 @@ const ( + ETHTOOL_A_COALESCE_RATE_SAMPLE_INTERVAL = 0x17 + ETHTOOL_A_COALESCE_USE_CQE_MODE_TX = 0x18 + ETHTOOL_A_COALESCE_USE_CQE_MODE_RX = 0x19 +- ETHTOOL_A_COALESCE_MAX = 0x1c ++ ETHTOOL_A_COALESCE_MAX = 0x1e + ETHTOOL_A_PAUSE_UNSPEC = 0x0 + ETHTOOL_A_PAUSE_HEADER = 0x1 + ETHTOOL_A_PAUSE_AUTONEG = 0x2 +@@ -3992,11 +4031,11 @@ const ( + ETHTOOL_A_CABLE_RESULT_UNSPEC = 0x0 + ETHTOOL_A_CABLE_RESULT_PAIR = 0x1 + ETHTOOL_A_CABLE_RESULT_CODE = 0x2 +- ETHTOOL_A_CABLE_RESULT_MAX = 0x2 ++ ETHTOOL_A_CABLE_RESULT_MAX = 0x3 + ETHTOOL_A_CABLE_FAULT_LENGTH_UNSPEC = 0x0 + ETHTOOL_A_CABLE_FAULT_LENGTH_PAIR = 0x1 + ETHTOOL_A_CABLE_FAULT_LENGTH_CM = 0x2 +- ETHTOOL_A_CABLE_FAULT_LENGTH_MAX = 0x2 ++ ETHTOOL_A_CABLE_FAULT_LENGTH_MAX = 0x3 + ETHTOOL_A_CABLE_TEST_NTF_STATUS_UNSPEC = 0x0 + ETHTOOL_A_CABLE_TEST_NTF_STATUS_STARTED = 0x1 + ETHTOOL_A_CABLE_TEST_NTF_STATUS_COMPLETED = 0x2 +@@ -4079,6 +4118,107 @@ type EthtoolDrvinfo struct { + Regdump_len uint32 + } + ++type EthtoolTsInfo struct { ++ Cmd uint32 ++ So_timestamping uint32 ++ Phc_index int32 ++ Tx_types uint32 ++ Tx_reserved [3]uint32 ++ Rx_filters uint32 ++ Rx_reserved [3]uint32 ++} ++ ++type HwTstampConfig struct { ++ Flags int32 ++ Tx_type int32 ++ Rx_filter int32 ++} ++ ++const ( ++ HWTSTAMP_FILTER_NONE = 0x0 ++ HWTSTAMP_FILTER_ALL = 0x1 ++ HWTSTAMP_FILTER_SOME = 0x2 ++ HWTSTAMP_FILTER_PTP_V1_L4_EVENT = 0x3 ++ HWTSTAMP_FILTER_PTP_V2_L4_EVENT = 0x6 ++ HWTSTAMP_FILTER_PTP_V2_L2_EVENT = 0x9 ++ HWTSTAMP_FILTER_PTP_V2_EVENT = 0xc ++) ++ ++const ( ++ HWTSTAMP_TX_OFF = 0x0 ++ HWTSTAMP_TX_ON = 0x1 ++ HWTSTAMP_TX_ONESTEP_SYNC = 0x2 ++) ++ ++type ( ++ PtpClockCaps struct { ++ Max_adj int32 ++ N_alarm int32 ++ N_ext_ts int32 ++ N_per_out int32 ++ Pps int32 ++ N_pins int32 ++ Cross_timestamping int32 ++ Adjust_phase int32 ++ Max_phase_adj int32 ++ Rsv [11]int32 ++ } ++ PtpClockTime struct { ++ Sec int64 ++ Nsec uint32 ++ Reserved uint32 ++ } ++ PtpExttsEvent struct { ++ T PtpClockTime ++ Index uint32 ++ Flags uint32 ++ Rsv [2]uint32 ++ } ++ PtpExttsRequest struct { ++ Index uint32 ++ Flags uint32 ++ Rsv [2]uint32 ++ } ++ PtpPeroutRequest struct { ++ StartOrPhase PtpClockTime ++ Period PtpClockTime ++ Index uint32 ++ Flags uint32 ++ On PtpClockTime ++ } ++ PtpPinDesc struct { ++ Name [64]byte ++ Index uint32 ++ Func uint32 ++ Chan uint32 ++ Rsv [5]uint32 ++ } ++ PtpSysOffset struct { ++ Samples uint32 ++ Rsv [3]uint32 ++ Ts [51]PtpClockTime ++ } ++ PtpSysOffsetExtended struct { ++ Samples uint32 ++ Clockid int32 ++ Rsv [2]uint32 ++ Ts [25][3]PtpClockTime ++ } ++ PtpSysOffsetPrecise struct { ++ Device PtpClockTime ++ Realtime PtpClockTime ++ Monoraw PtpClockTime ++ Rsv [4]uint32 ++ } ++) ++ ++const ( ++ PTP_PF_NONE = 0x0 ++ PTP_PF_EXTTS = 0x1 ++ PTP_PF_PEROUT = 0x2 ++ PTP_PF_PHYSYNC = 0x3 ++) ++ + type ( + HIDRawReportDescriptor struct { + Size uint32 +@@ -4260,6 +4400,7 @@ const ( + type LandlockRulesetAttr struct { + Access_fs uint64 + Access_net uint64 ++ Scoped uint64 + } + + type LandlockPathBeneathAttr struct { +@@ -4606,7 +4747,7 @@ const ( + NL80211_ATTR_MAC_HINT = 0xc8 + NL80211_ATTR_MAC_MASK = 0xd7 + NL80211_ATTR_MAX_AP_ASSOC_STA = 0xca +- NL80211_ATTR_MAX = 0x14a ++ NL80211_ATTR_MAX = 0x14c + NL80211_ATTR_MAX_CRIT_PROT_DURATION = 0xb4 + NL80211_ATTR_MAX_CSA_COUNTERS = 0xce + NL80211_ATTR_MAX_MATCH_SETS = 0x85 +@@ -5210,7 +5351,7 @@ const ( + NL80211_FREQUENCY_ATTR_GO_CONCURRENT = 0xf + NL80211_FREQUENCY_ATTR_INDOOR_ONLY = 0xe + NL80211_FREQUENCY_ATTR_IR_CONCURRENT = 0xf +- NL80211_FREQUENCY_ATTR_MAX = 0x20 ++ NL80211_FREQUENCY_ATTR_MAX = 0x21 + NL80211_FREQUENCY_ATTR_MAX_TX_POWER = 0x6 + NL80211_FREQUENCY_ATTR_NO_10MHZ = 0x11 + NL80211_FREQUENCY_ATTR_NO_160MHZ = 0xc +diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go b/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go +index 15adc04..ad05b51 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go +@@ -727,6 +727,37 @@ const ( + RISCV_HWPROBE_EXT_ZBA = 0x8 + RISCV_HWPROBE_EXT_ZBB = 0x10 + RISCV_HWPROBE_EXT_ZBS = 0x20 ++ RISCV_HWPROBE_EXT_ZICBOZ = 0x40 ++ RISCV_HWPROBE_EXT_ZBC = 0x80 ++ RISCV_HWPROBE_EXT_ZBKB = 0x100 ++ RISCV_HWPROBE_EXT_ZBKC = 0x200 ++ RISCV_HWPROBE_EXT_ZBKX = 0x400 ++ RISCV_HWPROBE_EXT_ZKND = 0x800 ++ RISCV_HWPROBE_EXT_ZKNE = 0x1000 ++ RISCV_HWPROBE_EXT_ZKNH = 0x2000 ++ RISCV_HWPROBE_EXT_ZKSED = 0x4000 ++ RISCV_HWPROBE_EXT_ZKSH = 0x8000 ++ RISCV_HWPROBE_EXT_ZKT = 0x10000 ++ RISCV_HWPROBE_EXT_ZVBB = 0x20000 ++ RISCV_HWPROBE_EXT_ZVBC = 0x40000 ++ RISCV_HWPROBE_EXT_ZVKB = 0x80000 ++ RISCV_HWPROBE_EXT_ZVKG = 0x100000 ++ RISCV_HWPROBE_EXT_ZVKNED = 0x200000 ++ RISCV_HWPROBE_EXT_ZVKNHA = 0x400000 ++ RISCV_HWPROBE_EXT_ZVKNHB = 0x800000 ++ RISCV_HWPROBE_EXT_ZVKSED = 0x1000000 ++ RISCV_HWPROBE_EXT_ZVKSH = 0x2000000 ++ RISCV_HWPROBE_EXT_ZVKT = 0x4000000 ++ RISCV_HWPROBE_EXT_ZFH = 0x8000000 ++ RISCV_HWPROBE_EXT_ZFHMIN = 0x10000000 ++ RISCV_HWPROBE_EXT_ZIHINTNTL = 0x20000000 ++ RISCV_HWPROBE_EXT_ZVFH = 0x40000000 ++ RISCV_HWPROBE_EXT_ZVFHMIN = 0x80000000 ++ RISCV_HWPROBE_EXT_ZFA = 0x100000000 ++ RISCV_HWPROBE_EXT_ZTSO = 0x200000000 ++ RISCV_HWPROBE_EXT_ZACAS = 0x400000000 ++ RISCV_HWPROBE_EXT_ZICOND = 0x800000000 ++ RISCV_HWPROBE_EXT_ZIHINTPAUSE = 0x1000000000 + RISCV_HWPROBE_KEY_CPUPERF_0 = 0x5 + RISCV_HWPROBE_MISALIGNED_UNKNOWN = 0x0 + RISCV_HWPROBE_MISALIGNED_EMULATED = 0x1 +@@ -734,4 +765,6 @@ const ( + RISCV_HWPROBE_MISALIGNED_FAST = 0x3 + RISCV_HWPROBE_MISALIGNED_UNSUPPORTED = 0x4 + RISCV_HWPROBE_MISALIGNED_MASK = 0x7 ++ RISCV_HWPROBE_KEY_ZICBOZ_BLOCK_SIZE = 0x6 ++ RISCV_HWPROBE_WHICH_CPUS = 0x1 + ) +diff --git a/vendor/golang.org/x/sys/unix/ztypes_zos_s390x.go b/vendor/golang.org/x/sys/unix/ztypes_zos_s390x.go +index d9a13af..2e5d5a4 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_zos_s390x.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_zos_s390x.go +@@ -377,6 +377,12 @@ type Flock_t struct { + Pid int32 + } + ++type F_cnvrt struct { ++ Cvtcmd int32 ++ Pccsid int16 ++ Fccsid int16 ++} ++ + type Termios struct { + Cflag uint32 + Iflag uint32 +diff --git a/vendor/golang.org/x/sys/windows/dll_windows.go b/vendor/golang.org/x/sys/windows/dll_windows.go +index 115341f..4e613cf 100644 +--- a/vendor/golang.org/x/sys/windows/dll_windows.go ++++ b/vendor/golang.org/x/sys/windows/dll_windows.go +@@ -65,7 +65,7 @@ func LoadDLL(name string) (dll *DLL, err error) { + return d, nil + } + +-// MustLoadDLL is like LoadDLL but panics if load operation failes. ++// MustLoadDLL is like LoadDLL but panics if load operation fails. + func MustLoadDLL(name string) *DLL { + d, e := LoadDLL(name) + if e != nil { +diff --git a/vendor/golang.org/x/sys/windows/syscall_windows.go b/vendor/golang.org/x/sys/windows/syscall_windows.go +index 1fa34fd..4a32543 100644 +--- a/vendor/golang.org/x/sys/windows/syscall_windows.go ++++ b/vendor/golang.org/x/sys/windows/syscall_windows.go +@@ -168,6 +168,8 @@ func NewCallbackCDecl(fn interface{}) uintptr { + //sys CreateNamedPipe(name *uint16, flags uint32, pipeMode uint32, maxInstances uint32, outSize uint32, inSize uint32, defaultTimeout uint32, sa *SecurityAttributes) (handle Handle, err error) [failretval==InvalidHandle] = CreateNamedPipeW + //sys ConnectNamedPipe(pipe Handle, overlapped *Overlapped) (err error) + //sys DisconnectNamedPipe(pipe Handle) (err error) ++//sys GetNamedPipeClientProcessId(pipe Handle, clientProcessID *uint32) (err error) ++//sys GetNamedPipeServerProcessId(pipe Handle, serverProcessID *uint32) (err error) + //sys GetNamedPipeInfo(pipe Handle, flags *uint32, outSize *uint32, inSize *uint32, maxInstances *uint32) (err error) + //sys GetNamedPipeHandleState(pipe Handle, state *uint32, curInstances *uint32, maxCollectionCount *uint32, collectDataTimeout *uint32, userName *uint16, maxUserNameSize uint32) (err error) = GetNamedPipeHandleStateW + //sys SetNamedPipeHandleState(pipe Handle, state *uint32, maxCollectionCount *uint32, collectDataTimeout *uint32) (err error) = SetNamedPipeHandleState +@@ -313,6 +315,10 @@ func NewCallbackCDecl(fn interface{}) uintptr { + //sys SetConsoleMode(console Handle, mode uint32) (err error) = kernel32.SetConsoleMode + //sys GetConsoleScreenBufferInfo(console Handle, info *ConsoleScreenBufferInfo) (err error) = kernel32.GetConsoleScreenBufferInfo + //sys setConsoleCursorPosition(console Handle, position uint32) (err error) = kernel32.SetConsoleCursorPosition ++//sys GetConsoleCP() (cp uint32, err error) = kernel32.GetConsoleCP ++//sys GetConsoleOutputCP() (cp uint32, err error) = kernel32.GetConsoleOutputCP ++//sys SetConsoleCP(cp uint32) (err error) = kernel32.SetConsoleCP ++//sys SetConsoleOutputCP(cp uint32) (err error) = kernel32.SetConsoleOutputCP + //sys WriteConsole(console Handle, buf *uint16, towrite uint32, written *uint32, reserved *byte) (err error) = kernel32.WriteConsoleW + //sys ReadConsole(console Handle, buf *uint16, toread uint32, read *uint32, inputControl *byte) (err error) = kernel32.ReadConsoleW + //sys resizePseudoConsole(pconsole Handle, size uint32) (hr error) = kernel32.ResizePseudoConsole +@@ -721,20 +727,12 @@ func DurationSinceBoot() time.Duration { + } + + func Ftruncate(fd Handle, length int64) (err error) { +- curoffset, e := Seek(fd, 0, 1) +- if e != nil { +- return e +- } +- defer Seek(fd, curoffset, 0) +- _, e = Seek(fd, length, 0) +- if e != nil { +- return e ++ type _FILE_END_OF_FILE_INFO struct { ++ EndOfFile int64 + } +- e = SetEndOfFile(fd) +- if e != nil { +- return e +- } +- return nil ++ var info _FILE_END_OF_FILE_INFO ++ info.EndOfFile = length ++ return SetFileInformationByHandle(fd, FileEndOfFileInfo, (*byte)(unsafe.Pointer(&info)), uint32(unsafe.Sizeof(info))) + } + + func Gettimeofday(tv *Timeval) (err error) { +@@ -890,6 +888,11 @@ const socket_error = uintptr(^uint32(0)) + //sys GetACP() (acp uint32) = kernel32.GetACP + //sys MultiByteToWideChar(codePage uint32, dwFlags uint32, str *byte, nstr int32, wchar *uint16, nwchar int32) (nwrite int32, err error) = kernel32.MultiByteToWideChar + //sys getBestInterfaceEx(sockaddr unsafe.Pointer, pdwBestIfIndex *uint32) (errcode error) = iphlpapi.GetBestInterfaceEx ++//sys GetIfEntry2Ex(level uint32, row *MibIfRow2) (errcode error) = iphlpapi.GetIfEntry2Ex ++//sys GetUnicastIpAddressEntry(row *MibUnicastIpAddressRow) (errcode error) = iphlpapi.GetUnicastIpAddressEntry ++//sys NotifyIpInterfaceChange(family uint16, callback uintptr, callerContext unsafe.Pointer, initialNotification bool, notificationHandle *Handle) (errcode error) = iphlpapi.NotifyIpInterfaceChange ++//sys NotifyUnicastIpAddressChange(family uint16, callback uintptr, callerContext unsafe.Pointer, initialNotification bool, notificationHandle *Handle) (errcode error) = iphlpapi.NotifyUnicastIpAddressChange ++//sys CancelMibChangeNotify2(notificationHandle Handle) (errcode error) = iphlpapi.CancelMibChangeNotify2 + + // For testing: clients can set this flag to force + // creation of IPv6 sockets to return EAFNOSUPPORT. +@@ -1681,13 +1684,16 @@ func (s NTStatus) Error() string { + // do not use NTUnicodeString, and instead UTF16PtrFromString should be used for + // the more common *uint16 string type. + func NewNTUnicodeString(s string) (*NTUnicodeString, error) { +- var u NTUnicodeString +- s16, err := UTF16PtrFromString(s) ++ s16, err := UTF16FromString(s) + if err != nil { + return nil, err + } +- RtlInitUnicodeString(&u, s16) +- return &u, nil ++ n := uint16(len(s16) * 2) ++ return &NTUnicodeString{ ++ Length: n - 2, // subtract 2 bytes for the NULL terminator ++ MaximumLength: n, ++ Buffer: &s16[0], ++ }, nil + } + + // Slice returns a uint16 slice that aliases the data in the NTUnicodeString. +diff --git a/vendor/golang.org/x/sys/windows/types_windows.go b/vendor/golang.org/x/sys/windows/types_windows.go +index 4d0c157..9d138de 100644 +--- a/vendor/golang.org/x/sys/windows/types_windows.go ++++ b/vendor/golang.org/x/sys/windows/types_windows.go +@@ -176,6 +176,7 @@ const ( + WAIT_FAILED = 0xFFFFFFFF + + // Access rights for process. ++ PROCESS_ALL_ACCESS = 0xFFFF + PROCESS_CREATE_PROCESS = 0x0080 + PROCESS_CREATE_THREAD = 0x0002 + PROCESS_DUP_HANDLE = 0x0040 +@@ -1060,6 +1061,7 @@ const ( + SIO_GET_EXTENSION_FUNCTION_POINTER = IOC_INOUT | IOC_WS2 | 6 + SIO_KEEPALIVE_VALS = IOC_IN | IOC_VENDOR | 4 + SIO_UDP_CONNRESET = IOC_IN | IOC_VENDOR | 12 ++ SIO_UDP_NETRESET = IOC_IN | IOC_VENDOR | 15 + + // cf. http://support.microsoft.com/default.aspx?scid=kb;en-us;257460 + +@@ -2031,6 +2033,50 @@ const ( + IF_TYPE_IEEE1394 = 144 + ) + ++// Enum NL_PREFIX_ORIGIN for [IpAdapterUnicastAddress], see ++// https://learn.microsoft.com/en-us/windows/win32/api/nldef/ne-nldef-nl_prefix_origin ++const ( ++ IpPrefixOriginOther = 0 ++ IpPrefixOriginManual = 1 ++ IpPrefixOriginWellKnown = 2 ++ IpPrefixOriginDhcp = 3 ++ IpPrefixOriginRouterAdvertisement = 4 ++ IpPrefixOriginUnchanged = 1 << 4 ++) ++ ++// Enum NL_SUFFIX_ORIGIN for [IpAdapterUnicastAddress], see ++// https://learn.microsoft.com/en-us/windows/win32/api/nldef/ne-nldef-nl_suffix_origin ++const ( ++ NlsoOther = 0 ++ NlsoManual = 1 ++ NlsoWellKnown = 2 ++ NlsoDhcp = 3 ++ NlsoLinkLayerAddress = 4 ++ NlsoRandom = 5 ++ IpSuffixOriginOther = 0 ++ IpSuffixOriginManual = 1 ++ IpSuffixOriginWellKnown = 2 ++ IpSuffixOriginDhcp = 3 ++ IpSuffixOriginLinkLayerAddress = 4 ++ IpSuffixOriginRandom = 5 ++ IpSuffixOriginUnchanged = 1 << 4 ++) ++ ++// Enum NL_DAD_STATE for [IpAdapterUnicastAddress], see ++// https://learn.microsoft.com/en-us/windows/win32/api/nldef/ne-nldef-nl_dad_state ++const ( ++ NldsInvalid = 0 ++ NldsTentative = 1 ++ NldsDuplicate = 2 ++ NldsDeprecated = 3 ++ NldsPreferred = 4 ++ IpDadStateInvalid = 0 ++ IpDadStateTentative = 1 ++ IpDadStateDuplicate = 2 ++ IpDadStateDeprecated = 3 ++ IpDadStatePreferred = 4 ++) ++ + type SocketAddress struct { + Sockaddr *syscall.RawSockaddrAny + SockaddrLength int32 +@@ -2158,6 +2204,132 @@ const ( + IfOperStatusLowerLayerDown = 7 + ) + ++const ( ++ IF_MAX_PHYS_ADDRESS_LENGTH = 32 ++ IF_MAX_STRING_SIZE = 256 ++) ++ ++// MIB_IF_ENTRY_LEVEL enumeration from netioapi.h or ++// https://learn.microsoft.com/en-us/windows/win32/api/netioapi/nf-netioapi-getifentry2ex. ++const ( ++ MibIfEntryNormal = 0 ++ MibIfEntryNormalWithoutStatistics = 2 ++) ++ ++// MIB_NOTIFICATION_TYPE enumeration from netioapi.h or ++// https://learn.microsoft.com/en-us/windows/win32/api/netioapi/ne-netioapi-mib_notification_type. ++const ( ++ MibParameterNotification = 0 ++ MibAddInstance = 1 ++ MibDeleteInstance = 2 ++ MibInitialNotification = 3 ++) ++ ++// MibIfRow2 stores information about a particular interface. See ++// https://learn.microsoft.com/en-us/windows/win32/api/netioapi/ns-netioapi-mib_if_row2. ++type MibIfRow2 struct { ++ InterfaceLuid uint64 ++ InterfaceIndex uint32 ++ InterfaceGuid GUID ++ Alias [IF_MAX_STRING_SIZE + 1]uint16 ++ Description [IF_MAX_STRING_SIZE + 1]uint16 ++ PhysicalAddressLength uint32 ++ PhysicalAddress [IF_MAX_PHYS_ADDRESS_LENGTH]uint8 ++ PermanentPhysicalAddress [IF_MAX_PHYS_ADDRESS_LENGTH]uint8 ++ Mtu uint32 ++ Type uint32 ++ TunnelType uint32 ++ MediaType uint32 ++ PhysicalMediumType uint32 ++ AccessType uint32 ++ DirectionType uint32 ++ InterfaceAndOperStatusFlags uint8 ++ OperStatus uint32 ++ AdminStatus uint32 ++ MediaConnectState uint32 ++ NetworkGuid GUID ++ ConnectionType uint32 ++ TransmitLinkSpeed uint64 ++ ReceiveLinkSpeed uint64 ++ InOctets uint64 ++ InUcastPkts uint64 ++ InNUcastPkts uint64 ++ InDiscards uint64 ++ InErrors uint64 ++ InUnknownProtos uint64 ++ InUcastOctets uint64 ++ InMulticastOctets uint64 ++ InBroadcastOctets uint64 ++ OutOctets uint64 ++ OutUcastPkts uint64 ++ OutNUcastPkts uint64 ++ OutDiscards uint64 ++ OutErrors uint64 ++ OutUcastOctets uint64 ++ OutMulticastOctets uint64 ++ OutBroadcastOctets uint64 ++ OutQLen uint64 ++} ++ ++// MIB_UNICASTIPADDRESS_ROW stores information about a unicast IP address. See ++// https://learn.microsoft.com/en-us/windows/win32/api/netioapi/ns-netioapi-mib_unicastipaddress_row. ++type MibUnicastIpAddressRow struct { ++ Address RawSockaddrInet6 // SOCKADDR_INET union ++ InterfaceLuid uint64 ++ InterfaceIndex uint32 ++ PrefixOrigin uint32 ++ SuffixOrigin uint32 ++ ValidLifetime uint32 ++ PreferredLifetime uint32 ++ OnLinkPrefixLength uint8 ++ SkipAsSource uint8 ++ DadState uint32 ++ ScopeId uint32 ++ CreationTimeStamp Filetime ++} ++ ++const ScopeLevelCount = 16 ++ ++// MIB_IPINTERFACE_ROW stores interface management information for a particular IP address family on a network interface. ++// See https://learn.microsoft.com/en-us/windows/win32/api/netioapi/ns-netioapi-mib_ipinterface_row. ++type MibIpInterfaceRow struct { ++ Family uint16 ++ InterfaceLuid uint64 ++ InterfaceIndex uint32 ++ MaxReassemblySize uint32 ++ InterfaceIdentifier uint64 ++ MinRouterAdvertisementInterval uint32 ++ MaxRouterAdvertisementInterval uint32 ++ AdvertisingEnabled uint8 ++ ForwardingEnabled uint8 ++ WeakHostSend uint8 ++ WeakHostReceive uint8 ++ UseAutomaticMetric uint8 ++ UseNeighborUnreachabilityDetection uint8 ++ ManagedAddressConfigurationSupported uint8 ++ OtherStatefulConfigurationSupported uint8 ++ AdvertiseDefaultRoute uint8 ++ RouterDiscoveryBehavior uint32 ++ DadTransmits uint32 ++ BaseReachableTime uint32 ++ RetransmitTime uint32 ++ PathMtuDiscoveryTimeout uint32 ++ LinkLocalAddressBehavior uint32 ++ LinkLocalAddressTimeout uint32 ++ ZoneIndices [ScopeLevelCount]uint32 ++ SitePrefixLength uint32 ++ Metric uint32 ++ NlMtu uint32 ++ Connected uint8 ++ SupportsWakeUpPatterns uint8 ++ SupportsNeighborDiscovery uint8 ++ SupportsRouterDiscovery uint8 ++ ReachableTime uint32 ++ TransmitOffload uint32 ++ ReceiveOffload uint32 ++ DisableDefaultRoutes uint8 ++} ++ + // Console related constants used for the mode parameter to SetConsoleMode. See + // https://docs.microsoft.com/en-us/windows/console/setconsolemode for details. + +diff --git a/vendor/golang.org/x/sys/windows/zsyscall_windows.go b/vendor/golang.org/x/sys/windows/zsyscall_windows.go +index 9bb979a..01c0716 100644 +--- a/vendor/golang.org/x/sys/windows/zsyscall_windows.go ++++ b/vendor/golang.org/x/sys/windows/zsyscall_windows.go +@@ -181,10 +181,15 @@ var ( + procDnsRecordListFree = moddnsapi.NewProc("DnsRecordListFree") + procDwmGetWindowAttribute = moddwmapi.NewProc("DwmGetWindowAttribute") + procDwmSetWindowAttribute = moddwmapi.NewProc("DwmSetWindowAttribute") ++ procCancelMibChangeNotify2 = modiphlpapi.NewProc("CancelMibChangeNotify2") + procGetAdaptersAddresses = modiphlpapi.NewProc("GetAdaptersAddresses") + procGetAdaptersInfo = modiphlpapi.NewProc("GetAdaptersInfo") + procGetBestInterfaceEx = modiphlpapi.NewProc("GetBestInterfaceEx") + procGetIfEntry = modiphlpapi.NewProc("GetIfEntry") ++ procGetIfEntry2Ex = modiphlpapi.NewProc("GetIfEntry2Ex") ++ procGetUnicastIpAddressEntry = modiphlpapi.NewProc("GetUnicastIpAddressEntry") ++ procNotifyIpInterfaceChange = modiphlpapi.NewProc("NotifyIpInterfaceChange") ++ procNotifyUnicastIpAddressChange = modiphlpapi.NewProc("NotifyUnicastIpAddressChange") + procAddDllDirectory = modkernel32.NewProc("AddDllDirectory") + procAssignProcessToJobObject = modkernel32.NewProc("AssignProcessToJobObject") + procCancelIo = modkernel32.NewProc("CancelIo") +@@ -247,7 +252,9 @@ var ( + procGetCommandLineW = modkernel32.NewProc("GetCommandLineW") + procGetComputerNameExW = modkernel32.NewProc("GetComputerNameExW") + procGetComputerNameW = modkernel32.NewProc("GetComputerNameW") ++ procGetConsoleCP = modkernel32.NewProc("GetConsoleCP") + procGetConsoleMode = modkernel32.NewProc("GetConsoleMode") ++ procGetConsoleOutputCP = modkernel32.NewProc("GetConsoleOutputCP") + procGetConsoleScreenBufferInfo = modkernel32.NewProc("GetConsoleScreenBufferInfo") + procGetCurrentDirectoryW = modkernel32.NewProc("GetCurrentDirectoryW") + procGetCurrentProcessId = modkernel32.NewProc("GetCurrentProcessId") +@@ -273,8 +280,10 @@ var ( + procGetMaximumProcessorCount = modkernel32.NewProc("GetMaximumProcessorCount") + procGetModuleFileNameW = modkernel32.NewProc("GetModuleFileNameW") + procGetModuleHandleExW = modkernel32.NewProc("GetModuleHandleExW") ++ procGetNamedPipeClientProcessId = modkernel32.NewProc("GetNamedPipeClientProcessId") + procGetNamedPipeHandleStateW = modkernel32.NewProc("GetNamedPipeHandleStateW") + procGetNamedPipeInfo = modkernel32.NewProc("GetNamedPipeInfo") ++ procGetNamedPipeServerProcessId = modkernel32.NewProc("GetNamedPipeServerProcessId") + procGetOverlappedResult = modkernel32.NewProc("GetOverlappedResult") + procGetPriorityClass = modkernel32.NewProc("GetPriorityClass") + procGetProcAddress = modkernel32.NewProc("GetProcAddress") +@@ -347,8 +356,10 @@ var ( + procSetCommMask = modkernel32.NewProc("SetCommMask") + procSetCommState = modkernel32.NewProc("SetCommState") + procSetCommTimeouts = modkernel32.NewProc("SetCommTimeouts") ++ procSetConsoleCP = modkernel32.NewProc("SetConsoleCP") + procSetConsoleCursorPosition = modkernel32.NewProc("SetConsoleCursorPosition") + procSetConsoleMode = modkernel32.NewProc("SetConsoleMode") ++ procSetConsoleOutputCP = modkernel32.NewProc("SetConsoleOutputCP") + procSetCurrentDirectoryW = modkernel32.NewProc("SetCurrentDirectoryW") + procSetDefaultDllDirectories = modkernel32.NewProc("SetDefaultDllDirectories") + procSetDllDirectoryW = modkernel32.NewProc("SetDllDirectoryW") +@@ -1602,6 +1613,14 @@ func DwmSetWindowAttribute(hwnd HWND, attribute uint32, value unsafe.Pointer, si + return + } + ++func CancelMibChangeNotify2(notificationHandle Handle) (errcode error) { ++ r0, _, _ := syscall.Syscall(procCancelMibChangeNotify2.Addr(), 1, uintptr(notificationHandle), 0, 0) ++ if r0 != 0 { ++ errcode = syscall.Errno(r0) ++ } ++ return ++} ++ + func GetAdaptersAddresses(family uint32, flags uint32, reserved uintptr, adapterAddresses *IpAdapterAddresses, sizePointer *uint32) (errcode error) { + r0, _, _ := syscall.Syscall6(procGetAdaptersAddresses.Addr(), 5, uintptr(family), uintptr(flags), uintptr(reserved), uintptr(unsafe.Pointer(adapterAddresses)), uintptr(unsafe.Pointer(sizePointer)), 0) + if r0 != 0 { +@@ -1634,6 +1653,46 @@ func GetIfEntry(pIfRow *MibIfRow) (errcode error) { + return + } + ++func GetIfEntry2Ex(level uint32, row *MibIfRow2) (errcode error) { ++ r0, _, _ := syscall.Syscall(procGetIfEntry2Ex.Addr(), 2, uintptr(level), uintptr(unsafe.Pointer(row)), 0) ++ if r0 != 0 { ++ errcode = syscall.Errno(r0) ++ } ++ return ++} ++ ++func GetUnicastIpAddressEntry(row *MibUnicastIpAddressRow) (errcode error) { ++ r0, _, _ := syscall.Syscall(procGetUnicastIpAddressEntry.Addr(), 1, uintptr(unsafe.Pointer(row)), 0, 0) ++ if r0 != 0 { ++ errcode = syscall.Errno(r0) ++ } ++ return ++} ++ ++func NotifyIpInterfaceChange(family uint16, callback uintptr, callerContext unsafe.Pointer, initialNotification bool, notificationHandle *Handle) (errcode error) { ++ var _p0 uint32 ++ if initialNotification { ++ _p0 = 1 ++ } ++ r0, _, _ := syscall.Syscall6(procNotifyIpInterfaceChange.Addr(), 5, uintptr(family), uintptr(callback), uintptr(callerContext), uintptr(_p0), uintptr(unsafe.Pointer(notificationHandle)), 0) ++ if r0 != 0 { ++ errcode = syscall.Errno(r0) ++ } ++ return ++} ++ ++func NotifyUnicastIpAddressChange(family uint16, callback uintptr, callerContext unsafe.Pointer, initialNotification bool, notificationHandle *Handle) (errcode error) { ++ var _p0 uint32 ++ if initialNotification { ++ _p0 = 1 ++ } ++ r0, _, _ := syscall.Syscall6(procNotifyUnicastIpAddressChange.Addr(), 5, uintptr(family), uintptr(callback), uintptr(callerContext), uintptr(_p0), uintptr(unsafe.Pointer(notificationHandle)), 0) ++ if r0 != 0 { ++ errcode = syscall.Errno(r0) ++ } ++ return ++} ++ + func AddDllDirectory(path *uint16) (cookie uintptr, err error) { + r0, _, e1 := syscall.Syscall(procAddDllDirectory.Addr(), 1, uintptr(unsafe.Pointer(path)), 0, 0) + cookie = uintptr(r0) +@@ -2162,6 +2221,15 @@ func GetComputerName(buf *uint16, n *uint32) (err error) { + return + } + ++func GetConsoleCP() (cp uint32, err error) { ++ r0, _, e1 := syscall.Syscall(procGetConsoleCP.Addr(), 0, 0, 0, 0) ++ cp = uint32(r0) ++ if cp == 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ + func GetConsoleMode(console Handle, mode *uint32) (err error) { + r1, _, e1 := syscall.Syscall(procGetConsoleMode.Addr(), 2, uintptr(console), uintptr(unsafe.Pointer(mode)), 0) + if r1 == 0 { +@@ -2170,6 +2238,15 @@ func GetConsoleMode(console Handle, mode *uint32) (err error) { + return + } + ++func GetConsoleOutputCP() (cp uint32, err error) { ++ r0, _, e1 := syscall.Syscall(procGetConsoleOutputCP.Addr(), 0, 0, 0, 0) ++ cp = uint32(r0) ++ if cp == 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ + func GetConsoleScreenBufferInfo(console Handle, info *ConsoleScreenBufferInfo) (err error) { + r1, _, e1 := syscall.Syscall(procGetConsoleScreenBufferInfo.Addr(), 2, uintptr(console), uintptr(unsafe.Pointer(info)), 0) + if r1 == 0 { +@@ -2371,6 +2448,14 @@ func GetModuleHandleEx(flags uint32, moduleName *uint16, module *Handle) (err er + return + } + ++func GetNamedPipeClientProcessId(pipe Handle, clientProcessID *uint32) (err error) { ++ r1, _, e1 := syscall.Syscall(procGetNamedPipeClientProcessId.Addr(), 2, uintptr(pipe), uintptr(unsafe.Pointer(clientProcessID)), 0) ++ if r1 == 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ + func GetNamedPipeHandleState(pipe Handle, state *uint32, curInstances *uint32, maxCollectionCount *uint32, collectDataTimeout *uint32, userName *uint16, maxUserNameSize uint32) (err error) { + r1, _, e1 := syscall.Syscall9(procGetNamedPipeHandleStateW.Addr(), 7, uintptr(pipe), uintptr(unsafe.Pointer(state)), uintptr(unsafe.Pointer(curInstances)), uintptr(unsafe.Pointer(maxCollectionCount)), uintptr(unsafe.Pointer(collectDataTimeout)), uintptr(unsafe.Pointer(userName)), uintptr(maxUserNameSize), 0, 0) + if r1 == 0 { +@@ -2387,6 +2472,14 @@ func GetNamedPipeInfo(pipe Handle, flags *uint32, outSize *uint32, inSize *uint3 + return + } + ++func GetNamedPipeServerProcessId(pipe Handle, serverProcessID *uint32) (err error) { ++ r1, _, e1 := syscall.Syscall(procGetNamedPipeServerProcessId.Addr(), 2, uintptr(pipe), uintptr(unsafe.Pointer(serverProcessID)), 0) ++ if r1 == 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ + func GetOverlappedResult(handle Handle, overlapped *Overlapped, done *uint32, wait bool) (err error) { + var _p0 uint32 + if wait { +@@ -3038,6 +3131,14 @@ func SetCommTimeouts(handle Handle, timeouts *CommTimeouts) (err error) { + return + } + ++func SetConsoleCP(cp uint32) (err error) { ++ r1, _, e1 := syscall.Syscall(procSetConsoleCP.Addr(), 1, uintptr(cp), 0, 0) ++ if r1 == 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ + func setConsoleCursorPosition(console Handle, position uint32) (err error) { + r1, _, e1 := syscall.Syscall(procSetConsoleCursorPosition.Addr(), 2, uintptr(console), uintptr(position), 0) + if r1 == 0 { +@@ -3054,6 +3155,14 @@ func SetConsoleMode(console Handle, mode uint32) (err error) { + return + } + ++func SetConsoleOutputCP(cp uint32) (err error) { ++ r1, _, e1 := syscall.Syscall(procSetConsoleOutputCP.Addr(), 1, uintptr(cp), 0, 0) ++ if r1 == 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ + func SetCurrentDirectory(path *uint16) (err error) { + r1, _, e1 := syscall.Syscall(procSetCurrentDirectoryW.Addr(), 1, uintptr(unsafe.Pointer(path)), 0, 0) + if r1 == 0 { +diff --git a/vendor/modules.txt b/vendor/modules.txt +index 6b39e77..be1b84e 100644 +--- a/vendor/modules.txt ++++ b/vendor/modules.txt +@@ -152,7 +152,7 @@ go.uber.org/zap/internal/exit + go.uber.org/zap/internal/pool + go.uber.org/zap/internal/stacktrace + go.uber.org/zap/zapcore +-# golang.org/x/net v0.28.0 ++# golang.org/x/net v0.33.0 + ## explicit; go 1.18 + golang.org/x/net/http/httpguts + golang.org/x/net/http2 +@@ -160,11 +160,11 @@ golang.org/x/net/http2/hpack + golang.org/x/net/idna + golang.org/x/net/internal/timeseries + golang.org/x/net/trace +-# golang.org/x/sys v0.23.0 ++# golang.org/x/sys v0.28.0 + ## explicit; go 1.18 + golang.org/x/sys/unix + golang.org/x/sys/windows +-# golang.org/x/text v0.17.0 ++# golang.org/x/text v0.21.0 + ## explicit; go 1.18 + golang.org/x/text/secure/bidirule + golang.org/x/text/transform +-- +2.40.1 + diff --git a/projects/kubernetes-csi/livenessprobe/1-30/patches/0001-Address-CVE-2024-45338.patch b/projects/kubernetes-csi/livenessprobe/1-30/patches/0001-Address-CVE-2024-45338.patch new file mode 100644 index 000000000..d284d9f1d --- /dev/null +++ b/projects/kubernetes-csi/livenessprobe/1-30/patches/0001-Address-CVE-2024-45338.patch @@ -0,0 +1,5325 @@ +From f846b95fea50c3bbb26a8702870a4c2979e671fe Mon Sep 17 00:00:00 2001 +From: torredil +Date: Mon, 23 Dec 2024 18:55:24 +0000 +Subject: [PATCH] Address CVE-2024-45338 + +Signed-off-by: torredil +--- + go.mod | 6 +- + go.sum | 12 +- + .../x/net/http2/client_conn_pool.go | 8 +- + vendor/golang.org/x/net/http2/config.go | 122 +++++ + vendor/golang.org/x/net/http2/config_go124.go | 61 +++ + .../x/net/http2/config_pre_go124.go | 16 + + vendor/golang.org/x/net/http2/frame.go | 4 +- + vendor/golang.org/x/net/http2/http2.go | 95 +++- + vendor/golang.org/x/net/http2/server.go | 244 ++++++--- + vendor/golang.org/x/net/http2/transport.go | 516 ++++++++++++------ + vendor/golang.org/x/net/http2/unencrypted.go | 32 ++ + vendor/golang.org/x/net/http2/write.go | 10 + + vendor/golang.org/x/sys/unix/README.md | 2 +- + vendor/golang.org/x/sys/unix/ioctl_linux.go | 96 ++++ + vendor/golang.org/x/sys/unix/mkerrors.sh | 17 +- + vendor/golang.org/x/sys/unix/syscall_aix.go | 2 +- + .../golang.org/x/sys/unix/syscall_darwin.go | 37 ++ + vendor/golang.org/x/sys/unix/syscall_hurd.go | 1 + + vendor/golang.org/x/sys/unix/syscall_linux.go | 64 ++- + .../x/sys/unix/syscall_linux_arm64.go | 2 + + .../x/sys/unix/syscall_linux_loong64.go | 2 + + .../x/sys/unix/syscall_linux_riscv64.go | 2 + + .../x/sys/unix/syscall_zos_s390x.go | 104 +++- + .../golang.org/x/sys/unix/vgetrandom_linux.go | 13 + + .../x/sys/unix/vgetrandom_unsupported.go | 11 + + .../x/sys/unix/zerrors_darwin_amd64.go | 7 + + .../x/sys/unix/zerrors_darwin_arm64.go | 7 + + vendor/golang.org/x/sys/unix/zerrors_linux.go | 44 +- + .../x/sys/unix/zerrors_linux_386.go | 25 + + .../x/sys/unix/zerrors_linux_amd64.go | 25 + + .../x/sys/unix/zerrors_linux_arm.go | 25 + + .../x/sys/unix/zerrors_linux_arm64.go | 26 + + .../x/sys/unix/zerrors_linux_loong64.go | 25 + + .../x/sys/unix/zerrors_linux_mips.go | 25 + + .../x/sys/unix/zerrors_linux_mips64.go | 25 + + .../x/sys/unix/zerrors_linux_mips64le.go | 25 + + .../x/sys/unix/zerrors_linux_mipsle.go | 25 + + .../x/sys/unix/zerrors_linux_ppc.go | 25 + + .../x/sys/unix/zerrors_linux_ppc64.go | 25 + + .../x/sys/unix/zerrors_linux_ppc64le.go | 25 + + .../x/sys/unix/zerrors_linux_riscv64.go | 25 + + .../x/sys/unix/zerrors_linux_s390x.go | 25 + + .../x/sys/unix/zerrors_linux_sparc64.go | 25 + + .../x/sys/unix/zerrors_zos_s390x.go | 2 + + .../x/sys/unix/zsyscall_darwin_amd64.go | 20 + + .../x/sys/unix/zsyscall_darwin_amd64.s | 5 + + .../x/sys/unix/zsyscall_darwin_arm64.go | 20 + + .../x/sys/unix/zsyscall_darwin_arm64.s | 5 + + .../golang.org/x/sys/unix/zsyscall_linux.go | 27 +- + .../x/sys/unix/zsysnum_linux_amd64.go | 1 + + .../x/sys/unix/zsysnum_linux_arm64.go | 2 +- + .../x/sys/unix/zsysnum_linux_loong64.go | 2 + + .../x/sys/unix/zsysnum_linux_riscv64.go | 2 +- + .../x/sys/unix/ztypes_darwin_amd64.go | 73 +++ + .../x/sys/unix/ztypes_darwin_arm64.go | 73 +++ + .../x/sys/unix/ztypes_freebsd_386.go | 1 + + .../x/sys/unix/ztypes_freebsd_amd64.go | 1 + + .../x/sys/unix/ztypes_freebsd_arm.go | 1 + + .../x/sys/unix/ztypes_freebsd_arm64.go | 1 + + .../x/sys/unix/ztypes_freebsd_riscv64.go | 1 + + vendor/golang.org/x/sys/unix/ztypes_linux.go | 227 ++++++-- + .../x/sys/unix/ztypes_linux_riscv64.go | 33 ++ + .../golang.org/x/sys/unix/ztypes_zos_s390x.go | 6 + + .../golang.org/x/sys/windows/dll_windows.go | 2 +- + .../x/sys/windows/syscall_windows.go | 40 +- + .../golang.org/x/sys/windows/types_windows.go | 172 ++++++ + .../x/sys/windows/zsyscall_windows.go | 109 ++++ + vendor/modules.txt | 6 +- + 68 files changed, 2370 insertions(+), 375 deletions(-) + create mode 100644 vendor/golang.org/x/net/http2/config.go + create mode 100644 vendor/golang.org/x/net/http2/config_go124.go + create mode 100644 vendor/golang.org/x/net/http2/config_pre_go124.go + create mode 100644 vendor/golang.org/x/net/http2/unencrypted.go + create mode 100644 vendor/golang.org/x/sys/unix/vgetrandom_linux.go + create mode 100644 vendor/golang.org/x/sys/unix/vgetrandom_unsupported.go + +diff --git a/go.mod b/go.mod +index 235ec1f..b8ded7e 100644 +--- a/go.mod ++++ b/go.mod +@@ -42,9 +42,9 @@ require ( + go.opentelemetry.io/otel/trace v1.28.0 // indirect + go.uber.org/multierr v1.11.0 // indirect + go.uber.org/zap v1.27.0 // indirect +- golang.org/x/net v0.28.0 // indirect +- golang.org/x/sys v0.23.0 // indirect +- golang.org/x/text v0.17.0 // indirect ++ golang.org/x/net v0.33.0 // indirect ++ golang.org/x/sys v0.28.0 // indirect ++ golang.org/x/text v0.21.0 // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20240701130421-f6361c86f094 // indirect + google.golang.org/grpc v1.65.0 // indirect + google.golang.org/protobuf v1.34.2 // indirect +diff --git a/go.sum b/go.sum +index 4a2470f..db27122 100644 +--- a/go.sum ++++ b/go.sum +@@ -109,8 +109,8 @@ golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLL + golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= + golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= + golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= +-golang.org/x/net v0.28.0 h1:a9JDOJc5GMUJ0+UDqmLT86WiEy7iWyIhz8gz8E4e5hE= +-golang.org/x/net v0.28.0/go.mod h1:yqtgsTWOOnlGLG9GFRrK3++bGOUEkNBoHZc8MEDWPNg= ++golang.org/x/net v0.33.0 h1:74SYHlV8BIgHIFC/LrYkOGIwL19eTYXQ5wc6TBuO36I= ++golang.org/x/net v0.33.0/go.mod h1:HXLR5J+9DxmrqMwG9qjGCxZ+zKXxBru04zlTvWlWuN4= + golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= + golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= + golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +@@ -121,13 +121,13 @@ golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7w + golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= + golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= + golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +-golang.org/x/sys v0.23.0 h1:YfKFowiIMvtgl1UERQoTPPToxltDeZfbj4H7dVUCwmM= +-golang.org/x/sys v0.23.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= ++golang.org/x/sys v0.28.0 h1:Fksou7UEQUWlKvIdsqzJmUmCX3cZuD2+P3XyyzwMhlA= ++golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= + golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= + golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= + golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +-golang.org/x/text v0.17.0 h1:XtiM5bkSOt+ewxlOE/aE/AKEHibwj/6gvWMl9Rsh0Qc= +-golang.org/x/text v0.17.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY= ++golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo= ++golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ= + golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= + golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= + golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +diff --git a/vendor/golang.org/x/net/http2/client_conn_pool.go b/vendor/golang.org/x/net/http2/client_conn_pool.go +index 780968d..e81b73e 100644 +--- a/vendor/golang.org/x/net/http2/client_conn_pool.go ++++ b/vendor/golang.org/x/net/http2/client_conn_pool.go +@@ -8,8 +8,8 @@ package http2 + + import ( + "context" +- "crypto/tls" + "errors" ++ "net" + "net/http" + "sync" + ) +@@ -158,7 +158,7 @@ func (c *dialCall) dial(ctx context.Context, addr string) { + // This code decides which ones live or die. + // The return value used is whether c was used. + // c is never closed. +-func (p *clientConnPool) addConnIfNeeded(key string, t *Transport, c *tls.Conn) (used bool, err error) { ++func (p *clientConnPool) addConnIfNeeded(key string, t *Transport, c net.Conn) (used bool, err error) { + p.mu.Lock() + for _, cc := range p.conns[key] { + if cc.CanTakeNewRequest() { +@@ -194,8 +194,8 @@ type addConnCall struct { + err error + } + +-func (c *addConnCall) run(t *Transport, key string, tc *tls.Conn) { +- cc, err := t.NewClientConn(tc) ++func (c *addConnCall) run(t *Transport, key string, nc net.Conn) { ++ cc, err := t.NewClientConn(nc) + + p := c.p + p.mu.Lock() +diff --git a/vendor/golang.org/x/net/http2/config.go b/vendor/golang.org/x/net/http2/config.go +new file mode 100644 +index 0000000..de58dfb +--- /dev/null ++++ b/vendor/golang.org/x/net/http2/config.go +@@ -0,0 +1,122 @@ ++// Copyright 2024 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 http2 ++ ++import ( ++ "math" ++ "net/http" ++ "time" ++) ++ ++// http2Config is a package-internal version of net/http.HTTP2Config. ++// ++// http.HTTP2Config was added in Go 1.24. ++// When running with a version of net/http that includes HTTP2Config, ++// we merge the configuration with the fields in Transport or Server ++// to produce an http2Config. ++// ++// Zero valued fields in http2Config are interpreted as in the ++// net/http.HTTPConfig documentation. ++// ++// Precedence order for reconciling configurations is: ++// ++// - Use the net/http.{Server,Transport}.HTTP2Config value, when non-zero. ++// - Otherwise use the http2.{Server.Transport} value. ++// - If the resulting value is zero or out of range, use a default. ++type http2Config struct { ++ MaxConcurrentStreams uint32 ++ MaxDecoderHeaderTableSize uint32 ++ MaxEncoderHeaderTableSize uint32 ++ MaxReadFrameSize uint32 ++ MaxUploadBufferPerConnection int32 ++ MaxUploadBufferPerStream int32 ++ SendPingTimeout time.Duration ++ PingTimeout time.Duration ++ WriteByteTimeout time.Duration ++ PermitProhibitedCipherSuites bool ++ CountError func(errType string) ++} ++ ++// configFromServer merges configuration settings from ++// net/http.Server.HTTP2Config and http2.Server. ++func configFromServer(h1 *http.Server, h2 *Server) http2Config { ++ conf := http2Config{ ++ MaxConcurrentStreams: h2.MaxConcurrentStreams, ++ MaxEncoderHeaderTableSize: h2.MaxEncoderHeaderTableSize, ++ MaxDecoderHeaderTableSize: h2.MaxDecoderHeaderTableSize, ++ MaxReadFrameSize: h2.MaxReadFrameSize, ++ MaxUploadBufferPerConnection: h2.MaxUploadBufferPerConnection, ++ MaxUploadBufferPerStream: h2.MaxUploadBufferPerStream, ++ SendPingTimeout: h2.ReadIdleTimeout, ++ PingTimeout: h2.PingTimeout, ++ WriteByteTimeout: h2.WriteByteTimeout, ++ PermitProhibitedCipherSuites: h2.PermitProhibitedCipherSuites, ++ CountError: h2.CountError, ++ } ++ fillNetHTTPServerConfig(&conf, h1) ++ setConfigDefaults(&conf, true) ++ return conf ++} ++ ++// configFromServer merges configuration settings from h2 and h2.t1.HTTP2 ++// (the net/http Transport). ++func configFromTransport(h2 *Transport) http2Config { ++ conf := http2Config{ ++ MaxEncoderHeaderTableSize: h2.MaxEncoderHeaderTableSize, ++ MaxDecoderHeaderTableSize: h2.MaxDecoderHeaderTableSize, ++ MaxReadFrameSize: h2.MaxReadFrameSize, ++ SendPingTimeout: h2.ReadIdleTimeout, ++ PingTimeout: h2.PingTimeout, ++ WriteByteTimeout: h2.WriteByteTimeout, ++ } ++ ++ // Unlike most config fields, where out-of-range values revert to the default, ++ // Transport.MaxReadFrameSize clips. ++ if conf.MaxReadFrameSize < minMaxFrameSize { ++ conf.MaxReadFrameSize = minMaxFrameSize ++ } else if conf.MaxReadFrameSize > maxFrameSize { ++ conf.MaxReadFrameSize = maxFrameSize ++ } ++ ++ if h2.t1 != nil { ++ fillNetHTTPTransportConfig(&conf, h2.t1) ++ } ++ setConfigDefaults(&conf, false) ++ return conf ++} ++ ++func setDefault[T ~int | ~int32 | ~uint32 | ~int64](v *T, minval, maxval, defval T) { ++ if *v < minval || *v > maxval { ++ *v = defval ++ } ++} ++ ++func setConfigDefaults(conf *http2Config, server bool) { ++ setDefault(&conf.MaxConcurrentStreams, 1, math.MaxUint32, defaultMaxStreams) ++ setDefault(&conf.MaxEncoderHeaderTableSize, 1, math.MaxUint32, initialHeaderTableSize) ++ setDefault(&conf.MaxDecoderHeaderTableSize, 1, math.MaxUint32, initialHeaderTableSize) ++ if server { ++ setDefault(&conf.MaxUploadBufferPerConnection, initialWindowSize, math.MaxInt32, 1<<20) ++ } else { ++ setDefault(&conf.MaxUploadBufferPerConnection, initialWindowSize, math.MaxInt32, transportDefaultConnFlow) ++ } ++ if server { ++ setDefault(&conf.MaxUploadBufferPerStream, 1, math.MaxInt32, 1<<20) ++ } else { ++ setDefault(&conf.MaxUploadBufferPerStream, 1, math.MaxInt32, transportDefaultStreamFlow) ++ } ++ setDefault(&conf.MaxReadFrameSize, minMaxFrameSize, maxFrameSize, defaultMaxReadFrameSize) ++ setDefault(&conf.PingTimeout, 1, math.MaxInt64, 15*time.Second) ++} ++ ++// adjustHTTP1MaxHeaderSize converts a limit in bytes on the size of an HTTP/1 header ++// to an HTTP/2 MAX_HEADER_LIST_SIZE value. ++func adjustHTTP1MaxHeaderSize(n int64) int64 { ++ // http2's count is in a slightly different unit and includes 32 bytes per pair. ++ // So, take the net/http.Server value and pad it up a bit, assuming 10 headers. ++ const perFieldOverhead = 32 // per http2 spec ++ const typicalHeaders = 10 // conservative ++ return n + typicalHeaders*perFieldOverhead ++} +diff --git a/vendor/golang.org/x/net/http2/config_go124.go b/vendor/golang.org/x/net/http2/config_go124.go +new file mode 100644 +index 0000000..e378412 +--- /dev/null ++++ b/vendor/golang.org/x/net/http2/config_go124.go +@@ -0,0 +1,61 @@ ++// Copyright 2024 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. ++ ++//go:build go1.24 ++ ++package http2 ++ ++import "net/http" ++ ++// fillNetHTTPServerConfig sets fields in conf from srv.HTTP2. ++func fillNetHTTPServerConfig(conf *http2Config, srv *http.Server) { ++ fillNetHTTPConfig(conf, srv.HTTP2) ++} ++ ++// fillNetHTTPServerConfig sets fields in conf from tr.HTTP2. ++func fillNetHTTPTransportConfig(conf *http2Config, tr *http.Transport) { ++ fillNetHTTPConfig(conf, tr.HTTP2) ++} ++ ++func fillNetHTTPConfig(conf *http2Config, h2 *http.HTTP2Config) { ++ if h2 == nil { ++ return ++ } ++ if h2.MaxConcurrentStreams != 0 { ++ conf.MaxConcurrentStreams = uint32(h2.MaxConcurrentStreams) ++ } ++ if h2.MaxEncoderHeaderTableSize != 0 { ++ conf.MaxEncoderHeaderTableSize = uint32(h2.MaxEncoderHeaderTableSize) ++ } ++ if h2.MaxDecoderHeaderTableSize != 0 { ++ conf.MaxDecoderHeaderTableSize = uint32(h2.MaxDecoderHeaderTableSize) ++ } ++ if h2.MaxConcurrentStreams != 0 { ++ conf.MaxConcurrentStreams = uint32(h2.MaxConcurrentStreams) ++ } ++ if h2.MaxReadFrameSize != 0 { ++ conf.MaxReadFrameSize = uint32(h2.MaxReadFrameSize) ++ } ++ if h2.MaxReceiveBufferPerConnection != 0 { ++ conf.MaxUploadBufferPerConnection = int32(h2.MaxReceiveBufferPerConnection) ++ } ++ if h2.MaxReceiveBufferPerStream != 0 { ++ conf.MaxUploadBufferPerStream = int32(h2.MaxReceiveBufferPerStream) ++ } ++ if h2.SendPingTimeout != 0 { ++ conf.SendPingTimeout = h2.SendPingTimeout ++ } ++ if h2.PingTimeout != 0 { ++ conf.PingTimeout = h2.PingTimeout ++ } ++ if h2.WriteByteTimeout != 0 { ++ conf.WriteByteTimeout = h2.WriteByteTimeout ++ } ++ if h2.PermitProhibitedCipherSuites { ++ conf.PermitProhibitedCipherSuites = true ++ } ++ if h2.CountError != nil { ++ conf.CountError = h2.CountError ++ } ++} +diff --git a/vendor/golang.org/x/net/http2/config_pre_go124.go b/vendor/golang.org/x/net/http2/config_pre_go124.go +new file mode 100644 +index 0000000..060fd6c +--- /dev/null ++++ b/vendor/golang.org/x/net/http2/config_pre_go124.go +@@ -0,0 +1,16 @@ ++// Copyright 2024 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. ++ ++//go:build !go1.24 ++ ++package http2 ++ ++import "net/http" ++ ++// Pre-Go 1.24 fallback. ++// The Server.HTTP2 and Transport.HTTP2 config fields were added in Go 1.24. ++ ++func fillNetHTTPServerConfig(conf *http2Config, srv *http.Server) {} ++ ++func fillNetHTTPTransportConfig(conf *http2Config, tr *http.Transport) {} +diff --git a/vendor/golang.org/x/net/http2/frame.go b/vendor/golang.org/x/net/http2/frame.go +index 105c3b2..81faec7 100644 +--- a/vendor/golang.org/x/net/http2/frame.go ++++ b/vendor/golang.org/x/net/http2/frame.go +@@ -1490,7 +1490,7 @@ func (mh *MetaHeadersFrame) checkPseudos() error { + pf := mh.PseudoFields() + for i, hf := range pf { + switch hf.Name { +- case ":method", ":path", ":scheme", ":authority": ++ case ":method", ":path", ":scheme", ":authority", ":protocol": + isRequest = true + case ":status": + isResponse = true +@@ -1498,7 +1498,7 @@ func (mh *MetaHeadersFrame) checkPseudos() error { + return pseudoHeaderError(hf.Name) + } + // Check for duplicates. +- // This would be a bad algorithm, but N is 4. ++ // This would be a bad algorithm, but N is 5. + // And this doesn't allocate. + for _, hf2 := range pf[:i] { + if hf.Name == hf2.Name { +diff --git a/vendor/golang.org/x/net/http2/http2.go b/vendor/golang.org/x/net/http2/http2.go +index 003e649..c7601c9 100644 +--- a/vendor/golang.org/x/net/http2/http2.go ++++ b/vendor/golang.org/x/net/http2/http2.go +@@ -19,8 +19,9 @@ import ( + "bufio" + "context" + "crypto/tls" ++ "errors" + "fmt" +- "io" ++ "net" + "net/http" + "os" + "sort" +@@ -33,10 +34,11 @@ import ( + ) + + var ( +- VerboseLogs bool +- logFrameWrites bool +- logFrameReads bool +- inTests bool ++ VerboseLogs bool ++ logFrameWrites bool ++ logFrameReads bool ++ inTests bool ++ disableExtendedConnectProtocol bool + ) + + func init() { +@@ -49,6 +51,9 @@ func init() { + logFrameWrites = true + logFrameReads = true + } ++ if strings.Contains(e, "http2xconnect=0") { ++ disableExtendedConnectProtocol = true ++ } + } + + const ( +@@ -140,6 +145,10 @@ func (s Setting) Valid() error { + if s.Val < 16384 || s.Val > 1<<24-1 { + return ConnectionError(ErrCodeProtocol) + } ++ case SettingEnableConnectProtocol: ++ if s.Val != 1 && s.Val != 0 { ++ return ConnectionError(ErrCodeProtocol) ++ } + } + return nil + } +@@ -149,21 +158,23 @@ func (s Setting) Valid() error { + type SettingID uint16 + + const ( +- SettingHeaderTableSize SettingID = 0x1 +- SettingEnablePush SettingID = 0x2 +- SettingMaxConcurrentStreams SettingID = 0x3 +- SettingInitialWindowSize SettingID = 0x4 +- SettingMaxFrameSize SettingID = 0x5 +- SettingMaxHeaderListSize SettingID = 0x6 ++ SettingHeaderTableSize SettingID = 0x1 ++ SettingEnablePush SettingID = 0x2 ++ SettingMaxConcurrentStreams SettingID = 0x3 ++ SettingInitialWindowSize SettingID = 0x4 ++ SettingMaxFrameSize SettingID = 0x5 ++ SettingMaxHeaderListSize SettingID = 0x6 ++ SettingEnableConnectProtocol SettingID = 0x8 + ) + + var settingName = map[SettingID]string{ +- SettingHeaderTableSize: "HEADER_TABLE_SIZE", +- SettingEnablePush: "ENABLE_PUSH", +- SettingMaxConcurrentStreams: "MAX_CONCURRENT_STREAMS", +- SettingInitialWindowSize: "INITIAL_WINDOW_SIZE", +- SettingMaxFrameSize: "MAX_FRAME_SIZE", +- SettingMaxHeaderListSize: "MAX_HEADER_LIST_SIZE", ++ SettingHeaderTableSize: "HEADER_TABLE_SIZE", ++ SettingEnablePush: "ENABLE_PUSH", ++ SettingMaxConcurrentStreams: "MAX_CONCURRENT_STREAMS", ++ SettingInitialWindowSize: "INITIAL_WINDOW_SIZE", ++ SettingMaxFrameSize: "MAX_FRAME_SIZE", ++ SettingMaxHeaderListSize: "MAX_HEADER_LIST_SIZE", ++ SettingEnableConnectProtocol: "ENABLE_CONNECT_PROTOCOL", + } + + func (s SettingID) String() string { +@@ -237,13 +248,19 @@ func (cw closeWaiter) Wait() { + // Its buffered writer is lazily allocated as needed, to minimize + // idle memory usage with many connections. + type bufferedWriter struct { +- _ incomparable +- w io.Writer // immutable +- bw *bufio.Writer // non-nil when data is buffered ++ _ incomparable ++ group synctestGroupInterface // immutable ++ conn net.Conn // immutable ++ bw *bufio.Writer // non-nil when data is buffered ++ byteTimeout time.Duration // immutable, WriteByteTimeout + } + +-func newBufferedWriter(w io.Writer) *bufferedWriter { +- return &bufferedWriter{w: w} ++func newBufferedWriter(group synctestGroupInterface, conn net.Conn, timeout time.Duration) *bufferedWriter { ++ return &bufferedWriter{ ++ group: group, ++ conn: conn, ++ byteTimeout: timeout, ++ } + } + + // bufWriterPoolBufferSize is the size of bufio.Writer's +@@ -270,7 +287,7 @@ func (w *bufferedWriter) Available() int { + func (w *bufferedWriter) Write(p []byte) (n int, err error) { + if w.bw == nil { + bw := bufWriterPool.Get().(*bufio.Writer) +- bw.Reset(w.w) ++ bw.Reset((*bufferedWriterTimeoutWriter)(w)) + w.bw = bw + } + return w.bw.Write(p) +@@ -288,6 +305,38 @@ func (w *bufferedWriter) Flush() error { + return err + } + ++type bufferedWriterTimeoutWriter bufferedWriter ++ ++func (w *bufferedWriterTimeoutWriter) Write(p []byte) (n int, err error) { ++ return writeWithByteTimeout(w.group, w.conn, w.byteTimeout, p) ++} ++ ++// writeWithByteTimeout writes to conn. ++// If more than timeout passes without any bytes being written to the connection, ++// the write fails. ++func writeWithByteTimeout(group synctestGroupInterface, conn net.Conn, timeout time.Duration, p []byte) (n int, err error) { ++ if timeout <= 0 { ++ return conn.Write(p) ++ } ++ for { ++ var now time.Time ++ if group == nil { ++ now = time.Now() ++ } else { ++ now = group.Now() ++ } ++ conn.SetWriteDeadline(now.Add(timeout)) ++ nn, err := conn.Write(p[n:]) ++ n += nn ++ if n == len(p) || nn == 0 || !errors.Is(err, os.ErrDeadlineExceeded) { ++ // Either we finished the write, made no progress, or hit the deadline. ++ // Whichever it is, we're done now. ++ conn.SetWriteDeadline(time.Time{}) ++ return n, err ++ } ++ } ++} ++ + func mustUint31(v int32) uint32 { + if v < 0 || v > 2147483647 { + panic("out of range") +diff --git a/vendor/golang.org/x/net/http2/server.go b/vendor/golang.org/x/net/http2/server.go +index 6c349f3..b55547a 100644 +--- a/vendor/golang.org/x/net/http2/server.go ++++ b/vendor/golang.org/x/net/http2/server.go +@@ -29,6 +29,7 @@ import ( + "bufio" + "bytes" + "context" ++ "crypto/rand" + "crypto/tls" + "errors" + "fmt" +@@ -52,10 +53,14 @@ import ( + ) + + const ( +- prefaceTimeout = 10 * time.Second +- firstSettingsTimeout = 2 * time.Second // should be in-flight with preface anyway +- handlerChunkWriteSize = 4 << 10 +- defaultMaxStreams = 250 // TODO: make this 100 as the GFE seems to? ++ prefaceTimeout = 10 * time.Second ++ firstSettingsTimeout = 2 * time.Second // should be in-flight with preface anyway ++ handlerChunkWriteSize = 4 << 10 ++ defaultMaxStreams = 250 // TODO: make this 100 as the GFE seems to? ++ ++ // maxQueuedControlFrames is the maximum number of control frames like ++ // SETTINGS, PING and RST_STREAM that will be queued for writing before ++ // the connection is closed to prevent memory exhaustion attacks. + maxQueuedControlFrames = 10000 + ) + +@@ -127,6 +132,22 @@ type Server struct { + // If zero or negative, there is no timeout. + IdleTimeout time.Duration + ++ // ReadIdleTimeout is the timeout after which a health check using a ping ++ // frame will be carried out if no frame is received on the connection. ++ // If zero, no health check is performed. ++ ReadIdleTimeout time.Duration ++ ++ // PingTimeout is the timeout after which the connection will be closed ++ // if a response to a ping is not received. ++ // If zero, a default of 15 seconds is used. ++ PingTimeout time.Duration ++ ++ // WriteByteTimeout is the timeout after which a connection will be ++ // closed if no data can be written to it. The timeout begins when data is ++ // available to write, and is extended whenever any bytes are written. ++ // If zero or negative, there is no timeout. ++ WriteByteTimeout time.Duration ++ + // MaxUploadBufferPerConnection is the size of the initial flow + // control window for each connections. The HTTP/2 spec does not + // allow this to be smaller than 65535 or larger than 2^32-1. +@@ -189,57 +210,6 @@ func (s *Server) afterFunc(d time.Duration, f func()) timer { + return timeTimer{time.AfterFunc(d, f)} + } + +-func (s *Server) initialConnRecvWindowSize() int32 { +- if s.MaxUploadBufferPerConnection >= initialWindowSize { +- return s.MaxUploadBufferPerConnection +- } +- return 1 << 20 +-} +- +-func (s *Server) initialStreamRecvWindowSize() int32 { +- if s.MaxUploadBufferPerStream > 0 { +- return s.MaxUploadBufferPerStream +- } +- return 1 << 20 +-} +- +-func (s *Server) maxReadFrameSize() uint32 { +- if v := s.MaxReadFrameSize; v >= minMaxFrameSize && v <= maxFrameSize { +- return v +- } +- return defaultMaxReadFrameSize +-} +- +-func (s *Server) maxConcurrentStreams() uint32 { +- if v := s.MaxConcurrentStreams; v > 0 { +- return v +- } +- return defaultMaxStreams +-} +- +-func (s *Server) maxDecoderHeaderTableSize() uint32 { +- if v := s.MaxDecoderHeaderTableSize; v > 0 { +- return v +- } +- return initialHeaderTableSize +-} +- +-func (s *Server) maxEncoderHeaderTableSize() uint32 { +- if v := s.MaxEncoderHeaderTableSize; v > 0 { +- return v +- } +- return initialHeaderTableSize +-} +- +-// maxQueuedControlFrames is the maximum number of control frames like +-// SETTINGS, PING and RST_STREAM that will be queued for writing before +-// the connection is closed to prevent memory exhaustion attacks. +-func (s *Server) maxQueuedControlFrames() int { +- // TODO: if anybody asks, add a Server field, and remember to define the +- // behavior of negative values. +- return maxQueuedControlFrames +-} +- + type serverInternalState struct { + mu sync.Mutex + activeConns map[*serverConn]struct{} +@@ -336,7 +306,7 @@ func ConfigureServer(s *http.Server, conf *Server) error { + if s.TLSNextProto == nil { + s.TLSNextProto = map[string]func(*http.Server, *tls.Conn, http.Handler){} + } +- protoHandler := func(hs *http.Server, c *tls.Conn, h http.Handler) { ++ protoHandler := func(hs *http.Server, c net.Conn, h http.Handler, sawClientPreface bool) { + if testHookOnConn != nil { + testHookOnConn() + } +@@ -353,12 +323,31 @@ func ConfigureServer(s *http.Server, conf *Server) error { + ctx = bc.BaseContext() + } + conf.ServeConn(c, &ServeConnOpts{ +- Context: ctx, +- Handler: h, +- BaseConfig: hs, ++ Context: ctx, ++ Handler: h, ++ BaseConfig: hs, ++ SawClientPreface: sawClientPreface, + }) + } +- s.TLSNextProto[NextProtoTLS] = protoHandler ++ s.TLSNextProto[NextProtoTLS] = func(hs *http.Server, c *tls.Conn, h http.Handler) { ++ protoHandler(hs, c, h, false) ++ } ++ // The "unencrypted_http2" TLSNextProto key is used to pass off non-TLS HTTP/2 conns. ++ // ++ // A connection passed in this method has already had the HTTP/2 preface read from it. ++ s.TLSNextProto[nextProtoUnencryptedHTTP2] = func(hs *http.Server, c *tls.Conn, h http.Handler) { ++ nc, err := unencryptedNetConnFromTLSConn(c) ++ if err != nil { ++ if lg := hs.ErrorLog; lg != nil { ++ lg.Print(err) ++ } else { ++ log.Print(err) ++ } ++ go c.Close() ++ return ++ } ++ protoHandler(hs, nc, h, true) ++ } + return nil + } + +@@ -440,13 +429,15 @@ func (s *Server) serveConn(c net.Conn, opts *ServeConnOpts, newf func(*serverCon + baseCtx, cancel := serverConnBaseContext(c, opts) + defer cancel() + ++ http1srv := opts.baseConfig() ++ conf := configFromServer(http1srv, s) + sc := &serverConn{ + srv: s, +- hs: opts.baseConfig(), ++ hs: http1srv, + conn: c, + baseCtx: baseCtx, + remoteAddrStr: c.RemoteAddr().String(), +- bw: newBufferedWriter(c), ++ bw: newBufferedWriter(s.group, c, conf.WriteByteTimeout), + handler: opts.handler(), + streams: make(map[uint32]*stream), + readFrameCh: make(chan readFrameResult), +@@ -456,9 +447,12 @@ func (s *Server) serveConn(c net.Conn, opts *ServeConnOpts, newf func(*serverCon + bodyReadCh: make(chan bodyReadMsg), // buffering doesn't matter either way + doneServing: make(chan struct{}), + clientMaxStreams: math.MaxUint32, // Section 6.5.2: "Initially, there is no limit to this value" +- advMaxStreams: s.maxConcurrentStreams(), ++ advMaxStreams: conf.MaxConcurrentStreams, + initialStreamSendWindowSize: initialWindowSize, ++ initialStreamRecvWindowSize: conf.MaxUploadBufferPerStream, + maxFrameSize: initialMaxFrameSize, ++ pingTimeout: conf.PingTimeout, ++ countErrorFunc: conf.CountError, + serveG: newGoroutineLock(), + pushEnabled: true, + sawClientPreface: opts.SawClientPreface, +@@ -491,15 +485,15 @@ func (s *Server) serveConn(c net.Conn, opts *ServeConnOpts, newf func(*serverCon + sc.flow.add(initialWindowSize) + sc.inflow.init(initialWindowSize) + sc.hpackEncoder = hpack.NewEncoder(&sc.headerWriteBuf) +- sc.hpackEncoder.SetMaxDynamicTableSizeLimit(s.maxEncoderHeaderTableSize()) ++ sc.hpackEncoder.SetMaxDynamicTableSizeLimit(conf.MaxEncoderHeaderTableSize) + + fr := NewFramer(sc.bw, c) +- if s.CountError != nil { +- fr.countError = s.CountError ++ if conf.CountError != nil { ++ fr.countError = conf.CountError + } +- fr.ReadMetaHeaders = hpack.NewDecoder(s.maxDecoderHeaderTableSize(), nil) ++ fr.ReadMetaHeaders = hpack.NewDecoder(conf.MaxDecoderHeaderTableSize, nil) + fr.MaxHeaderListSize = sc.maxHeaderListSize() +- fr.SetMaxReadFrameSize(s.maxReadFrameSize()) ++ fr.SetMaxReadFrameSize(conf.MaxReadFrameSize) + sc.framer = fr + + if tc, ok := c.(connectionStater); ok { +@@ -532,7 +526,7 @@ func (s *Server) serveConn(c net.Conn, opts *ServeConnOpts, newf func(*serverCon + // So for now, do nothing here again. + } + +- if !s.PermitProhibitedCipherSuites && isBadCipher(sc.tlsState.CipherSuite) { ++ if !conf.PermitProhibitedCipherSuites && isBadCipher(sc.tlsState.CipherSuite) { + // "Endpoints MAY choose to generate a connection error + // (Section 5.4.1) of type INADEQUATE_SECURITY if one of + // the prohibited cipher suites are negotiated." +@@ -569,7 +563,7 @@ func (s *Server) serveConn(c net.Conn, opts *ServeConnOpts, newf func(*serverCon + opts.UpgradeRequest = nil + } + +- sc.serve() ++ sc.serve(conf) + } + + func serverConnBaseContext(c net.Conn, opts *ServeConnOpts) (ctx context.Context, cancel func()) { +@@ -609,6 +603,7 @@ type serverConn struct { + tlsState *tls.ConnectionState // shared by all handlers, like net/http + remoteAddrStr string + writeSched WriteScheduler ++ countErrorFunc func(errType string) + + // Everything following is owned by the serve loop; use serveG.check(): + serveG goroutineLock // used to verify funcs are on serve() +@@ -628,6 +623,7 @@ type serverConn struct { + streams map[uint32]*stream + unstartedHandlers []unstartedHandler + initialStreamSendWindowSize int32 ++ initialStreamRecvWindowSize int32 + maxFrameSize int32 + peerMaxHeaderListSize uint32 // zero means unknown (default) + canonHeader map[string]string // http2-lower-case -> Go-Canonical-Case +@@ -638,9 +634,14 @@ type serverConn struct { + inGoAway bool // we've started to or sent GOAWAY + inFrameScheduleLoop bool // whether we're in the scheduleFrameWrite loop + needToSendGoAway bool // we need to schedule a GOAWAY frame write ++ pingSent bool ++ sentPingData [8]byte + goAwayCode ErrCode + shutdownTimer timer // nil until used + idleTimer timer // nil if unused ++ readIdleTimeout time.Duration ++ pingTimeout time.Duration ++ readIdleTimer timer // nil if unused + + // Owned by the writeFrameAsync goroutine: + headerWriteBuf bytes.Buffer +@@ -655,11 +656,7 @@ func (sc *serverConn) maxHeaderListSize() uint32 { + if n <= 0 { + n = http.DefaultMaxHeaderBytes + } +- // http2's count is in a slightly different unit and includes 32 bytes per pair. +- // So, take the net/http.Server value and pad it up a bit, assuming 10 headers. +- const perFieldOverhead = 32 // per http2 spec +- const typicalHeaders = 10 // conservative +- return uint32(n + typicalHeaders*perFieldOverhead) ++ return uint32(adjustHTTP1MaxHeaderSize(int64(n))) + } + + func (sc *serverConn) curOpenStreams() uint32 { +@@ -923,7 +920,7 @@ func (sc *serverConn) notePanic() { + } + } + +-func (sc *serverConn) serve() { ++func (sc *serverConn) serve(conf http2Config) { + sc.serveG.check() + defer sc.notePanic() + defer sc.conn.Close() +@@ -935,20 +932,24 @@ func (sc *serverConn) serve() { + sc.vlogf("http2: server connection from %v on %p", sc.conn.RemoteAddr(), sc.hs) + } + ++ settings := writeSettings{ ++ {SettingMaxFrameSize, conf.MaxReadFrameSize}, ++ {SettingMaxConcurrentStreams, sc.advMaxStreams}, ++ {SettingMaxHeaderListSize, sc.maxHeaderListSize()}, ++ {SettingHeaderTableSize, conf.MaxDecoderHeaderTableSize}, ++ {SettingInitialWindowSize, uint32(sc.initialStreamRecvWindowSize)}, ++ } ++ if !disableExtendedConnectProtocol { ++ settings = append(settings, Setting{SettingEnableConnectProtocol, 1}) ++ } + sc.writeFrame(FrameWriteRequest{ +- write: writeSettings{ +- {SettingMaxFrameSize, sc.srv.maxReadFrameSize()}, +- {SettingMaxConcurrentStreams, sc.advMaxStreams}, +- {SettingMaxHeaderListSize, sc.maxHeaderListSize()}, +- {SettingHeaderTableSize, sc.srv.maxDecoderHeaderTableSize()}, +- {SettingInitialWindowSize, uint32(sc.srv.initialStreamRecvWindowSize())}, +- }, ++ write: settings, + }) + sc.unackedSettings++ + + // Each connection starts with initialWindowSize inflow tokens. + // If a higher value is configured, we add more tokens. +- if diff := sc.srv.initialConnRecvWindowSize() - initialWindowSize; diff > 0 { ++ if diff := conf.MaxUploadBufferPerConnection - initialWindowSize; diff > 0 { + sc.sendWindowUpdate(nil, int(diff)) + } + +@@ -968,11 +969,18 @@ func (sc *serverConn) serve() { + defer sc.idleTimer.Stop() + } + ++ if conf.SendPingTimeout > 0 { ++ sc.readIdleTimeout = conf.SendPingTimeout ++ sc.readIdleTimer = sc.srv.afterFunc(conf.SendPingTimeout, sc.onReadIdleTimer) ++ defer sc.readIdleTimer.Stop() ++ } ++ + go sc.readFrames() // closed by defer sc.conn.Close above + + settingsTimer := sc.srv.afterFunc(firstSettingsTimeout, sc.onSettingsTimer) + defer settingsTimer.Stop() + ++ lastFrameTime := sc.srv.now() + loopNum := 0 + for { + loopNum++ +@@ -986,6 +994,7 @@ func (sc *serverConn) serve() { + case res := <-sc.wroteFrameCh: + sc.wroteFrame(res) + case res := <-sc.readFrameCh: ++ lastFrameTime = sc.srv.now() + // Process any written frames before reading new frames from the client since a + // written frame could have triggered a new stream to be started. + if sc.writingFrameAsync { +@@ -1017,6 +1026,8 @@ func (sc *serverConn) serve() { + case idleTimerMsg: + sc.vlogf("connection is idle") + sc.goAway(ErrCodeNo) ++ case readIdleTimerMsg: ++ sc.handlePingTimer(lastFrameTime) + case shutdownTimerMsg: + sc.vlogf("GOAWAY close timer fired; closing conn from %v", sc.conn.RemoteAddr()) + return +@@ -1039,7 +1050,7 @@ func (sc *serverConn) serve() { + // If the peer is causing us to generate a lot of control frames, + // but not reading them from us, assume they are trying to make us + // run out of memory. +- if sc.queuedControlFrames > sc.srv.maxQueuedControlFrames() { ++ if sc.queuedControlFrames > maxQueuedControlFrames { + sc.vlogf("http2: too many control frames in send queue, closing connection") + return + } +@@ -1055,12 +1066,39 @@ func (sc *serverConn) serve() { + } + } + ++func (sc *serverConn) handlePingTimer(lastFrameReadTime time.Time) { ++ if sc.pingSent { ++ sc.vlogf("timeout waiting for PING response") ++ sc.conn.Close() ++ return ++ } ++ ++ pingAt := lastFrameReadTime.Add(sc.readIdleTimeout) ++ now := sc.srv.now() ++ if pingAt.After(now) { ++ // We received frames since arming the ping timer. ++ // Reset it for the next possible timeout. ++ sc.readIdleTimer.Reset(pingAt.Sub(now)) ++ return ++ } ++ ++ sc.pingSent = true ++ // Ignore crypto/rand.Read errors: It generally can't fail, and worse case if it does ++ // is we send a PING frame containing 0s. ++ _, _ = rand.Read(sc.sentPingData[:]) ++ sc.writeFrame(FrameWriteRequest{ ++ write: &writePing{data: sc.sentPingData}, ++ }) ++ sc.readIdleTimer.Reset(sc.pingTimeout) ++} ++ + type serverMessage int + + // Message values sent to serveMsgCh. + var ( + settingsTimerMsg = new(serverMessage) + idleTimerMsg = new(serverMessage) ++ readIdleTimerMsg = new(serverMessage) + shutdownTimerMsg = new(serverMessage) + gracefulShutdownMsg = new(serverMessage) + handlerDoneMsg = new(serverMessage) +@@ -1068,6 +1106,7 @@ var ( + + func (sc *serverConn) onSettingsTimer() { sc.sendServeMsg(settingsTimerMsg) } + func (sc *serverConn) onIdleTimer() { sc.sendServeMsg(idleTimerMsg) } ++func (sc *serverConn) onReadIdleTimer() { sc.sendServeMsg(readIdleTimerMsg) } + func (sc *serverConn) onShutdownTimer() { sc.sendServeMsg(shutdownTimerMsg) } + + func (sc *serverConn) sendServeMsg(msg interface{}) { +@@ -1320,6 +1359,10 @@ func (sc *serverConn) wroteFrame(res frameWriteResult) { + sc.writingFrame = false + sc.writingFrameAsync = false + ++ if res.err != nil { ++ sc.conn.Close() ++ } ++ + wr := res.wr + + if writeEndsStream(wr.write) { +@@ -1594,6 +1637,11 @@ func (sc *serverConn) processFrame(f Frame) error { + func (sc *serverConn) processPing(f *PingFrame) error { + sc.serveG.check() + if f.IsAck() { ++ if sc.pingSent && sc.sentPingData == f.Data { ++ // This is a response to a PING we sent. ++ sc.pingSent = false ++ sc.readIdleTimer.Reset(sc.readIdleTimeout) ++ } + // 6.7 PING: " An endpoint MUST NOT respond to PING frames + // containing this flag." + return nil +@@ -1757,6 +1805,9 @@ func (sc *serverConn) processSetting(s Setting) error { + sc.maxFrameSize = int32(s.Val) // the maximum valid s.Val is < 2^31 + case SettingMaxHeaderListSize: + sc.peerMaxHeaderListSize = s.Val ++ case SettingEnableConnectProtocol: ++ // Receipt of this parameter by a server does not ++ // have any impact + default: + // Unknown setting: "An endpoint that receives a SETTINGS + // frame with any unknown or unsupported identifier MUST +@@ -2160,7 +2211,7 @@ func (sc *serverConn) newStream(id, pusherID uint32, state streamState) *stream + st.cw.Init() + st.flow.conn = &sc.flow // link to conn-level counter + st.flow.add(sc.initialStreamSendWindowSize) +- st.inflow.init(sc.srv.initialStreamRecvWindowSize()) ++ st.inflow.init(sc.initialStreamRecvWindowSize) + if sc.hs.WriteTimeout > 0 { + st.writeDeadline = sc.srv.afterFunc(sc.hs.WriteTimeout, st.onWriteTimeout) + } +@@ -2187,11 +2238,17 @@ func (sc *serverConn) newWriterAndRequest(st *stream, f *MetaHeadersFrame) (*res + scheme: f.PseudoValue("scheme"), + authority: f.PseudoValue("authority"), + path: f.PseudoValue("path"), ++ protocol: f.PseudoValue("protocol"), ++ } ++ ++ // extended connect is disabled, so we should not see :protocol ++ if disableExtendedConnectProtocol && rp.protocol != "" { ++ return nil, nil, sc.countError("bad_connect", streamError(f.StreamID, ErrCodeProtocol)) + } + + isConnect := rp.method == "CONNECT" + if isConnect { +- if rp.path != "" || rp.scheme != "" || rp.authority == "" { ++ if rp.protocol == "" && (rp.path != "" || rp.scheme != "" || rp.authority == "") { + return nil, nil, sc.countError("bad_connect", streamError(f.StreamID, ErrCodeProtocol)) + } + } else if rp.method == "" || rp.path == "" || (rp.scheme != "https" && rp.scheme != "http") { +@@ -2215,6 +2272,9 @@ func (sc *serverConn) newWriterAndRequest(st *stream, f *MetaHeadersFrame) (*res + if rp.authority == "" { + rp.authority = rp.header.Get("Host") + } ++ if rp.protocol != "" { ++ rp.header.Set(":protocol", rp.protocol) ++ } + + rw, req, err := sc.newWriterAndRequestNoBody(st, rp) + if err != nil { +@@ -2241,6 +2301,7 @@ func (sc *serverConn) newWriterAndRequest(st *stream, f *MetaHeadersFrame) (*res + type requestParam struct { + method string + scheme, authority, path string ++ protocol string + header http.Header + } + +@@ -2282,7 +2343,7 @@ func (sc *serverConn) newWriterAndRequestNoBody(st *stream, rp requestParam) (*r + + var url_ *url.URL + var requestURI string +- if rp.method == "CONNECT" { ++ if rp.method == "CONNECT" && rp.protocol == "" { + url_ = &url.URL{Host: rp.authority} + requestURI = rp.authority // mimic HTTP/1 server behavior + } else { +@@ -2855,6 +2916,11 @@ func (w *responseWriter) SetWriteDeadline(deadline time.Time) error { + return nil + } + ++func (w *responseWriter) EnableFullDuplex() error { ++ // We always support full duplex responses, so this is a no-op. ++ return nil ++} ++ + func (w *responseWriter) Flush() { + w.FlushError() + } +@@ -3301,7 +3367,7 @@ func (sc *serverConn) countError(name string, err error) error { + if sc == nil || sc.srv == nil { + return err + } +- f := sc.srv.CountError ++ f := sc.countErrorFunc + if f == nil { + return err + } +diff --git a/vendor/golang.org/x/net/http2/transport.go b/vendor/golang.org/x/net/http2/transport.go +index 61f511f..090d0e1 100644 +--- a/vendor/golang.org/x/net/http2/transport.go ++++ b/vendor/golang.org/x/net/http2/transport.go +@@ -25,7 +25,6 @@ import ( + "net/http" + "net/http/httptrace" + "net/textproto" +- "os" + "sort" + "strconv" + "strings" +@@ -203,6 +202,20 @@ func (t *Transport) markNewGoroutine() { + } + } + ++func (t *Transport) now() time.Time { ++ if t != nil && t.transportTestHooks != nil { ++ return t.transportTestHooks.group.Now() ++ } ++ return time.Now() ++} ++ ++func (t *Transport) timeSince(when time.Time) time.Duration { ++ if t != nil && t.transportTestHooks != nil { ++ return t.now().Sub(when) ++ } ++ return time.Since(when) ++} ++ + // newTimer creates a new time.Timer, or a synthetic timer in tests. + func (t *Transport) newTimer(d time.Duration) timer { + if t.transportTestHooks != nil { +@@ -227,40 +240,26 @@ func (t *Transport) contextWithTimeout(ctx context.Context, d time.Duration) (co + } + + func (t *Transport) maxHeaderListSize() uint32 { +- if t.MaxHeaderListSize == 0 { ++ n := int64(t.MaxHeaderListSize) ++ if t.t1 != nil && t.t1.MaxResponseHeaderBytes != 0 { ++ n = t.t1.MaxResponseHeaderBytes ++ if n > 0 { ++ n = adjustHTTP1MaxHeaderSize(n) ++ } ++ } ++ if n <= 0 { + return 10 << 20 + } +- if t.MaxHeaderListSize == 0xffffffff { ++ if n >= 0xffffffff { + return 0 + } +- return t.MaxHeaderListSize +-} +- +-func (t *Transport) maxFrameReadSize() uint32 { +- if t.MaxReadFrameSize == 0 { +- return 0 // use the default provided by the peer +- } +- if t.MaxReadFrameSize < minMaxFrameSize { +- return minMaxFrameSize +- } +- if t.MaxReadFrameSize > maxFrameSize { +- return maxFrameSize +- } +- return t.MaxReadFrameSize ++ return uint32(n) + } + + func (t *Transport) disableCompression() bool { + return t.DisableCompression || (t.t1 != nil && t.t1.DisableCompression) + } + +-func (t *Transport) pingTimeout() time.Duration { +- if t.PingTimeout == 0 { +- return 15 * time.Second +- } +- return t.PingTimeout +- +-} +- + // ConfigureTransport configures a net/http HTTP/1 Transport to use HTTP/2. + // It returns an error if t1 has already been HTTP/2-enabled. + // +@@ -296,8 +295,8 @@ func configureTransports(t1 *http.Transport) (*Transport, error) { + if !strSliceContains(t1.TLSClientConfig.NextProtos, "http/1.1") { + t1.TLSClientConfig.NextProtos = append(t1.TLSClientConfig.NextProtos, "http/1.1") + } +- upgradeFn := func(authority string, c *tls.Conn) http.RoundTripper { +- addr := authorityAddr("https", authority) ++ upgradeFn := func(scheme, authority string, c net.Conn) http.RoundTripper { ++ addr := authorityAddr(scheme, authority) + if used, err := connPool.addConnIfNeeded(addr, t2, c); err != nil { + go c.Close() + return erringRoundTripper{err} +@@ -308,18 +307,37 @@ func configureTransports(t1 *http.Transport) (*Transport, error) { + // was unknown) + go c.Close() + } ++ if scheme == "http" { ++ return (*unencryptedTransport)(t2) ++ } + return t2 + } +- if m := t1.TLSNextProto; len(m) == 0 { +- t1.TLSNextProto = map[string]func(string, *tls.Conn) http.RoundTripper{ +- "h2": upgradeFn, ++ if t1.TLSNextProto == nil { ++ t1.TLSNextProto = make(map[string]func(string, *tls.Conn) http.RoundTripper) ++ } ++ t1.TLSNextProto[NextProtoTLS] = func(authority string, c *tls.Conn) http.RoundTripper { ++ return upgradeFn("https", authority, c) ++ } ++ // The "unencrypted_http2" TLSNextProto key is used to pass off non-TLS HTTP/2 conns. ++ t1.TLSNextProto[nextProtoUnencryptedHTTP2] = func(authority string, c *tls.Conn) http.RoundTripper { ++ nc, err := unencryptedNetConnFromTLSConn(c) ++ if err != nil { ++ go c.Close() ++ return erringRoundTripper{err} + } +- } else { +- m["h2"] = upgradeFn ++ return upgradeFn("http", authority, nc) + } + return t2, nil + } + ++// unencryptedTransport is a Transport with a RoundTrip method that ++// always permits http:// URLs. ++type unencryptedTransport Transport ++ ++func (t *unencryptedTransport) RoundTrip(req *http.Request) (*http.Response, error) { ++ return (*Transport)(t).RoundTripOpt(req, RoundTripOpt{allowHTTP: true}) ++} ++ + func (t *Transport) connPool() ClientConnPool { + t.connPoolOnce.Do(t.initConnPool) + return t.connPoolOrDef +@@ -339,7 +357,7 @@ type ClientConn struct { + t *Transport + tconn net.Conn // usually *tls.Conn, except specialized impls + tlsState *tls.ConnectionState // nil only for specialized impls +- reused uint32 // whether conn is being reused; atomic ++ atomicReused uint32 // whether conn is being reused; atomic + singleUse bool // whether being used for a single http.Request + getConnCalled bool // used by clientConnPool + +@@ -350,31 +368,54 @@ type ClientConn struct { + idleTimeout time.Duration // or 0 for never + idleTimer timer + +- mu sync.Mutex // guards following +- cond *sync.Cond // hold mu; broadcast on flow/closed changes +- flow outflow // our conn-level flow control quota (cs.outflow is per stream) +- inflow inflow // peer's conn-level flow control +- doNotReuse bool // whether conn is marked to not be reused for any future requests +- closing bool +- closed bool +- seenSettings bool // true if we've seen a settings frame, false otherwise +- wantSettingsAck bool // we sent a SETTINGS frame and haven't heard back +- goAway *GoAwayFrame // if non-nil, the GoAwayFrame we received +- goAwayDebug string // goAway frame's debug data, retained as a string +- streams map[uint32]*clientStream // client-initiated +- streamsReserved int // incr by ReserveNewRequest; decr on RoundTrip +- nextStreamID uint32 +- pendingRequests int // requests blocked and waiting to be sent because len(streams) == maxConcurrentStreams +- pings map[[8]byte]chan struct{} // in flight ping data to notification channel +- br *bufio.Reader +- lastActive time.Time +- lastIdle time.Time // time last idle ++ mu sync.Mutex // guards following ++ cond *sync.Cond // hold mu; broadcast on flow/closed changes ++ flow outflow // our conn-level flow control quota (cs.outflow is per stream) ++ inflow inflow // peer's conn-level flow control ++ doNotReuse bool // whether conn is marked to not be reused for any future requests ++ closing bool ++ closed bool ++ seenSettings bool // true if we've seen a settings frame, false otherwise ++ seenSettingsChan chan struct{} // closed when seenSettings is true or frame reading fails ++ wantSettingsAck bool // we sent a SETTINGS frame and haven't heard back ++ goAway *GoAwayFrame // if non-nil, the GoAwayFrame we received ++ goAwayDebug string // goAway frame's debug data, retained as a string ++ streams map[uint32]*clientStream // client-initiated ++ streamsReserved int // incr by ReserveNewRequest; decr on RoundTrip ++ nextStreamID uint32 ++ pendingRequests int // requests blocked and waiting to be sent because len(streams) == maxConcurrentStreams ++ pings map[[8]byte]chan struct{} // in flight ping data to notification channel ++ br *bufio.Reader ++ lastActive time.Time ++ lastIdle time.Time // time last idle + // Settings from peer: (also guarded by wmu) +- maxFrameSize uint32 +- maxConcurrentStreams uint32 +- peerMaxHeaderListSize uint64 +- peerMaxHeaderTableSize uint32 +- initialWindowSize uint32 ++ maxFrameSize uint32 ++ maxConcurrentStreams uint32 ++ peerMaxHeaderListSize uint64 ++ peerMaxHeaderTableSize uint32 ++ initialWindowSize uint32 ++ initialStreamRecvWindowSize int32 ++ readIdleTimeout time.Duration ++ pingTimeout time.Duration ++ extendedConnectAllowed bool ++ ++ // rstStreamPingsBlocked works around an unfortunate gRPC behavior. ++ // gRPC strictly limits the number of PING frames that it will receive. ++ // The default is two pings per two hours, but the limit resets every time ++ // the gRPC endpoint sends a HEADERS or DATA frame. See golang/go#70575. ++ // ++ // rstStreamPingsBlocked is set after receiving a response to a PING frame ++ // bundled with an RST_STREAM (see pendingResets below), and cleared after ++ // receiving a HEADERS or DATA frame. ++ rstStreamPingsBlocked bool ++ ++ // pendingResets is the number of RST_STREAM frames we have sent to the peer, ++ // without confirming that the peer has received them. When we send a RST_STREAM, ++ // we bundle it with a PING frame, unless a PING is already in flight. We count ++ // the reset stream against the connection's concurrency limit until we get ++ // a PING response. This limits the number of requests we'll try to send to a ++ // completely unresponsive connection. ++ pendingResets int + + // reqHeaderMu is a 1-element semaphore channel controlling access to sending new requests. + // Write to reqHeaderMu to lock it, read from it to unlock. +@@ -432,12 +473,12 @@ type clientStream struct { + sentHeaders bool + + // owned by clientConnReadLoop: +- firstByte bool // got the first response byte +- pastHeaders bool // got first MetaHeadersFrame (actual headers) +- pastTrailers bool // got optional second MetaHeadersFrame (trailers) +- num1xx uint8 // number of 1xx responses seen +- readClosed bool // peer sent an END_STREAM flag +- readAborted bool // read loop reset the stream ++ firstByte bool // got the first response byte ++ pastHeaders bool // got first MetaHeadersFrame (actual headers) ++ pastTrailers bool // got optional second MetaHeadersFrame (trailers) ++ readClosed bool // peer sent an END_STREAM flag ++ readAborted bool // read loop reset the stream ++ totalHeaderSize int64 // total size of 1xx headers seen + + trailer http.Header // accumulated trailers + resTrailer *http.Header // client's Response.Trailer +@@ -499,6 +540,7 @@ func (cs *clientStream) closeReqBodyLocked() { + } + + type stickyErrWriter struct { ++ group synctestGroupInterface + conn net.Conn + timeout time.Duration + err *error +@@ -508,22 +550,9 @@ func (sew stickyErrWriter) Write(p []byte) (n int, err error) { + if *sew.err != nil { + return 0, *sew.err + } +- for { +- if sew.timeout != 0 { +- sew.conn.SetWriteDeadline(time.Now().Add(sew.timeout)) +- } +- nn, err := sew.conn.Write(p[n:]) +- n += nn +- if n < len(p) && nn > 0 && errors.Is(err, os.ErrDeadlineExceeded) { +- // Keep extending the deadline so long as we're making progress. +- continue +- } +- if sew.timeout != 0 { +- sew.conn.SetWriteDeadline(time.Time{}) +- } +- *sew.err = err +- return n, err +- } ++ n, err = writeWithByteTimeout(sew.group, sew.conn, sew.timeout, p) ++ *sew.err = err ++ return n, err + } + + // noCachedConnError is the concrete type of ErrNoCachedConn, which +@@ -554,6 +583,8 @@ type RoundTripOpt struct { + // no cached connection is available, RoundTripOpt + // will return ErrNoCachedConn. + OnlyCachedConn bool ++ ++ allowHTTP bool // allow http:// URLs + } + + func (t *Transport) RoundTrip(req *http.Request) (*http.Response, error) { +@@ -586,7 +617,14 @@ func authorityAddr(scheme string, authority string) (addr string) { + + // RoundTripOpt is like RoundTrip, but takes options. + func (t *Transport) RoundTripOpt(req *http.Request, opt RoundTripOpt) (*http.Response, error) { +- if !(req.URL.Scheme == "https" || (req.URL.Scheme == "http" && t.AllowHTTP)) { ++ switch req.URL.Scheme { ++ case "https": ++ // Always okay. ++ case "http": ++ if !t.AllowHTTP && !opt.allowHTTP { ++ return nil, errors.New("http2: unencrypted HTTP/2 not enabled") ++ } ++ default: + return nil, errors.New("http2: unsupported scheme") + } + +@@ -597,7 +635,7 @@ func (t *Transport) RoundTripOpt(req *http.Request, opt RoundTripOpt) (*http.Res + t.vlogf("http2: Transport failed to get client conn for %s: %v", addr, err) + return nil, err + } +- reused := !atomic.CompareAndSwapUint32(&cc.reused, 0, 1) ++ reused := !atomic.CompareAndSwapUint32(&cc.atomicReused, 0, 1) + traceGotConn(req, cc, reused) + res, err := cc.RoundTrip(req) + if err != nil && retry <= 6 { +@@ -622,6 +660,22 @@ func (t *Transport) RoundTripOpt(req *http.Request, opt RoundTripOpt) (*http.Res + } + } + } ++ if err == errClientConnNotEstablished { ++ // This ClientConn was created recently, ++ // this is the first request to use it, ++ // and the connection is closed and not usable. ++ // ++ // In this state, cc.idleTimer will remove the conn from the pool ++ // when it fires. Stop the timer and remove it here so future requests ++ // won't try to use this connection. ++ // ++ // If the timer has already fired and we're racing it, the redundant ++ // call to MarkDead is harmless. ++ if cc.idleTimer != nil { ++ cc.idleTimer.Stop() ++ } ++ t.connPool().MarkDead(cc) ++ } + if err != nil { + t.vlogf("RoundTrip failure: %v", err) + return nil, err +@@ -640,9 +694,10 @@ func (t *Transport) CloseIdleConnections() { + } + + var ( +- errClientConnClosed = errors.New("http2: client conn is closed") +- errClientConnUnusable = errors.New("http2: client conn not usable") +- errClientConnGotGoAway = errors.New("http2: Transport received Server's graceful shutdown GOAWAY") ++ errClientConnClosed = errors.New("http2: client conn is closed") ++ errClientConnUnusable = errors.New("http2: client conn not usable") ++ errClientConnNotEstablished = errors.New("http2: client conn could not be established") ++ errClientConnGotGoAway = errors.New("http2: Transport received Server's graceful shutdown GOAWAY") + ) + + // shouldRetryRequest is called by RoundTrip when a request fails to get +@@ -758,44 +813,38 @@ func (t *Transport) expectContinueTimeout() time.Duration { + return t.t1.ExpectContinueTimeout + } + +-func (t *Transport) maxDecoderHeaderTableSize() uint32 { +- if v := t.MaxDecoderHeaderTableSize; v > 0 { +- return v +- } +- return initialHeaderTableSize +-} +- +-func (t *Transport) maxEncoderHeaderTableSize() uint32 { +- if v := t.MaxEncoderHeaderTableSize; v > 0 { +- return v +- } +- return initialHeaderTableSize +-} +- + func (t *Transport) NewClientConn(c net.Conn) (*ClientConn, error) { + return t.newClientConn(c, t.disableKeepAlives()) + } + + func (t *Transport) newClientConn(c net.Conn, singleUse bool) (*ClientConn, error) { ++ conf := configFromTransport(t) + cc := &ClientConn{ +- t: t, +- tconn: c, +- readerDone: make(chan struct{}), +- nextStreamID: 1, +- maxFrameSize: 16 << 10, // spec default +- initialWindowSize: 65535, // spec default +- maxConcurrentStreams: initialMaxConcurrentStreams, // "infinite", per spec. Use a smaller value until we have received server settings. +- peerMaxHeaderListSize: 0xffffffffffffffff, // "infinite", per spec. Use 2^64-1 instead. +- streams: make(map[uint32]*clientStream), +- singleUse: singleUse, +- wantSettingsAck: true, +- pings: make(map[[8]byte]chan struct{}), +- reqHeaderMu: make(chan struct{}, 1), +- } ++ t: t, ++ tconn: c, ++ readerDone: make(chan struct{}), ++ nextStreamID: 1, ++ maxFrameSize: 16 << 10, // spec default ++ initialWindowSize: 65535, // spec default ++ initialStreamRecvWindowSize: conf.MaxUploadBufferPerStream, ++ maxConcurrentStreams: initialMaxConcurrentStreams, // "infinite", per spec. Use a smaller value until we have received server settings. ++ peerMaxHeaderListSize: 0xffffffffffffffff, // "infinite", per spec. Use 2^64-1 instead. ++ streams: make(map[uint32]*clientStream), ++ singleUse: singleUse, ++ seenSettingsChan: make(chan struct{}), ++ wantSettingsAck: true, ++ readIdleTimeout: conf.SendPingTimeout, ++ pingTimeout: conf.PingTimeout, ++ pings: make(map[[8]byte]chan struct{}), ++ reqHeaderMu: make(chan struct{}, 1), ++ lastActive: t.now(), ++ } ++ var group synctestGroupInterface + if t.transportTestHooks != nil { + t.markNewGoroutine() + t.transportTestHooks.newclientconn(cc) + c = cc.tconn ++ group = t.group + } + if VerboseLogs { + t.vlogf("http2: Transport creating client conn %p to %v", cc, c.RemoteAddr()) +@@ -807,24 +856,23 @@ func (t *Transport) newClientConn(c net.Conn, singleUse bool) (*ClientConn, erro + // TODO: adjust this writer size to account for frame size + + // MTU + crypto/tls record padding. + cc.bw = bufio.NewWriter(stickyErrWriter{ ++ group: group, + conn: c, +- timeout: t.WriteByteTimeout, ++ timeout: conf.WriteByteTimeout, + err: &cc.werr, + }) + cc.br = bufio.NewReader(c) + cc.fr = NewFramer(cc.bw, cc.br) +- if t.maxFrameReadSize() != 0 { +- cc.fr.SetMaxReadFrameSize(t.maxFrameReadSize()) +- } ++ cc.fr.SetMaxReadFrameSize(conf.MaxReadFrameSize) + if t.CountError != nil { + cc.fr.countError = t.CountError + } +- maxHeaderTableSize := t.maxDecoderHeaderTableSize() ++ maxHeaderTableSize := conf.MaxDecoderHeaderTableSize + cc.fr.ReadMetaHeaders = hpack.NewDecoder(maxHeaderTableSize, nil) + cc.fr.MaxHeaderListSize = t.maxHeaderListSize() + + cc.henc = hpack.NewEncoder(&cc.hbuf) +- cc.henc.SetMaxDynamicTableSizeLimit(t.maxEncoderHeaderTableSize()) ++ cc.henc.SetMaxDynamicTableSizeLimit(conf.MaxEncoderHeaderTableSize) + cc.peerMaxHeaderTableSize = initialHeaderTableSize + + if cs, ok := c.(connectionStater); ok { +@@ -834,11 +882,9 @@ func (t *Transport) newClientConn(c net.Conn, singleUse bool) (*ClientConn, erro + + initialSettings := []Setting{ + {ID: SettingEnablePush, Val: 0}, +- {ID: SettingInitialWindowSize, Val: transportDefaultStreamFlow}, +- } +- if max := t.maxFrameReadSize(); max != 0 { +- initialSettings = append(initialSettings, Setting{ID: SettingMaxFrameSize, Val: max}) ++ {ID: SettingInitialWindowSize, Val: uint32(cc.initialStreamRecvWindowSize)}, + } ++ initialSettings = append(initialSettings, Setting{ID: SettingMaxFrameSize, Val: conf.MaxReadFrameSize}) + if max := t.maxHeaderListSize(); max != 0 { + initialSettings = append(initialSettings, Setting{ID: SettingMaxHeaderListSize, Val: max}) + } +@@ -848,8 +894,8 @@ func (t *Transport) newClientConn(c net.Conn, singleUse bool) (*ClientConn, erro + + cc.bw.Write(clientPreface) + cc.fr.WriteSettings(initialSettings...) +- cc.fr.WriteWindowUpdate(0, transportDefaultConnFlow) +- cc.inflow.init(transportDefaultConnFlow + initialWindowSize) ++ cc.fr.WriteWindowUpdate(0, uint32(conf.MaxUploadBufferPerConnection)) ++ cc.inflow.init(conf.MaxUploadBufferPerConnection + initialWindowSize) + cc.bw.Flush() + if cc.werr != nil { + cc.Close() +@@ -867,7 +913,7 @@ func (t *Transport) newClientConn(c net.Conn, singleUse bool) (*ClientConn, erro + } + + func (cc *ClientConn) healthCheck() { +- pingTimeout := cc.t.pingTimeout() ++ pingTimeout := cc.pingTimeout + // We don't need to periodically ping in the health check, because the readLoop of ClientConn will + // trigger the healthCheck again if there is no frame received. + ctx, cancel := cc.t.contextWithTimeout(context.Background(), pingTimeout) +@@ -995,7 +1041,7 @@ func (cc *ClientConn) State() ClientConnState { + return ClientConnState{ + Closed: cc.closed, + Closing: cc.closing || cc.singleUse || cc.doNotReuse || cc.goAway != nil, +- StreamsActive: len(cc.streams), ++ StreamsActive: len(cc.streams) + cc.pendingResets, + StreamsReserved: cc.streamsReserved, + StreamsPending: cc.pendingRequests, + LastIdle: cc.lastIdle, +@@ -1027,16 +1073,38 @@ func (cc *ClientConn) idleStateLocked() (st clientConnIdleState) { + // writing it. + maxConcurrentOkay = true + } else { +- maxConcurrentOkay = int64(len(cc.streams)+cc.streamsReserved+1) <= int64(cc.maxConcurrentStreams) ++ // We can take a new request if the total of ++ // - active streams; ++ // - reservation slots for new streams; and ++ // - streams for which we have sent a RST_STREAM and a PING, ++ // but received no subsequent frame ++ // is less than the concurrency limit. ++ maxConcurrentOkay = cc.currentRequestCountLocked() < int(cc.maxConcurrentStreams) + } + + st.canTakeNewRequest = cc.goAway == nil && !cc.closed && !cc.closing && maxConcurrentOkay && + !cc.doNotReuse && + int64(cc.nextStreamID)+2*int64(cc.pendingRequests) < math.MaxInt32 && + !cc.tooIdleLocked() ++ ++ // If this connection has never been used for a request and is closed, ++ // then let it take a request (which will fail). ++ // ++ // This avoids a situation where an error early in a connection's lifetime ++ // goes unreported. ++ if cc.nextStreamID == 1 && cc.streamsReserved == 0 && cc.closed { ++ st.canTakeNewRequest = true ++ } ++ + return + } + ++// currentRequestCountLocked reports the number of concurrency slots currently in use, ++// including active streams, reserved slots, and reset streams waiting for acknowledgement. ++func (cc *ClientConn) currentRequestCountLocked() int { ++ return len(cc.streams) + cc.streamsReserved + cc.pendingResets ++} ++ + func (cc *ClientConn) canTakeNewRequestLocked() bool { + st := cc.idleStateLocked() + return st.canTakeNewRequest +@@ -1049,7 +1117,7 @@ func (cc *ClientConn) tooIdleLocked() bool { + // times are compared based on their wall time. We don't want + // to reuse a connection that's been sitting idle during + // VM/laptop suspend if monotonic time was also frozen. +- return cc.idleTimeout != 0 && !cc.lastIdle.IsZero() && time.Since(cc.lastIdle.Round(0)) > cc.idleTimeout ++ return cc.idleTimeout != 0 && !cc.lastIdle.IsZero() && cc.t.timeSince(cc.lastIdle.Round(0)) > cc.idleTimeout + } + + // onIdleTimeout is called from a time.AfterFunc goroutine. It will +@@ -1411,6 +1479,8 @@ func (cs *clientStream) doRequest(req *http.Request, streamf func(*clientStream) + cs.cleanupWriteRequest(err) + } + ++var errExtendedConnectNotSupported = errors.New("net/http: extended connect not supported by peer") ++ + // writeRequest sends a request. + // + // It returns nil after the request is written, the response read, +@@ -1426,12 +1496,31 @@ func (cs *clientStream) writeRequest(req *http.Request, streamf func(*clientStre + return err + } + ++ // wait for setting frames to be received, a server can change this value later, ++ // but we just wait for the first settings frame ++ var isExtendedConnect bool ++ if req.Method == "CONNECT" && req.Header.Get(":protocol") != "" { ++ isExtendedConnect = true ++ } ++ + // Acquire the new-request lock by writing to reqHeaderMu. + // This lock guards the critical section covering allocating a new stream ID + // (requires mu) and creating the stream (requires wmu). + if cc.reqHeaderMu == nil { + panic("RoundTrip on uninitialized ClientConn") // for tests + } ++ if isExtendedConnect { ++ select { ++ case <-cs.reqCancel: ++ return errRequestCanceled ++ case <-ctx.Done(): ++ return ctx.Err() ++ case <-cc.seenSettingsChan: ++ if !cc.extendedConnectAllowed { ++ return errExtendedConnectNotSupported ++ } ++ } ++ } + select { + case cc.reqHeaderMu <- struct{}{}: + case <-cs.reqCancel: +@@ -1613,6 +1702,7 @@ func (cs *clientStream) cleanupWriteRequest(err error) { + cs.reqBodyClosed = make(chan struct{}) + } + bodyClosed := cs.reqBodyClosed ++ closeOnIdle := cc.singleUse || cc.doNotReuse || cc.t.disableKeepAlives() || cc.goAway != nil + cc.mu.Unlock() + if mustCloseBody { + cs.reqBody.Close() +@@ -1637,16 +1727,44 @@ func (cs *clientStream) cleanupWriteRequest(err error) { + if cs.sentHeaders { + if se, ok := err.(StreamError); ok { + if se.Cause != errFromPeer { +- cc.writeStreamReset(cs.ID, se.Code, err) ++ cc.writeStreamReset(cs.ID, se.Code, false, err) + } + } else { +- cc.writeStreamReset(cs.ID, ErrCodeCancel, err) ++ // We're cancelling an in-flight request. ++ // ++ // This could be due to the server becoming unresponsive. ++ // To avoid sending too many requests on a dead connection, ++ // we let the request continue to consume a concurrency slot ++ // until we can confirm the server is still responding. ++ // We do this by sending a PING frame along with the RST_STREAM ++ // (unless a ping is already in flight). ++ // ++ // For simplicity, we don't bother tracking the PING payload: ++ // We reset cc.pendingResets any time we receive a PING ACK. ++ // ++ // We skip this if the conn is going to be closed on idle, ++ // because it's short lived and will probably be closed before ++ // we get the ping response. ++ ping := false ++ if !closeOnIdle { ++ cc.mu.Lock() ++ // rstStreamPingsBlocked works around a gRPC behavior: ++ // see comment on the field for details. ++ if !cc.rstStreamPingsBlocked { ++ if cc.pendingResets == 0 { ++ ping = true ++ } ++ cc.pendingResets++ ++ } ++ cc.mu.Unlock() ++ } ++ cc.writeStreamReset(cs.ID, ErrCodeCancel, ping, err) + } + } + cs.bufPipe.CloseWithError(err) // no-op if already closed + } else { + if cs.sentHeaders && !cs.sentEndStream { +- cc.writeStreamReset(cs.ID, ErrCodeNo, nil) ++ cc.writeStreamReset(cs.ID, ErrCodeNo, false, nil) + } + cs.bufPipe.CloseWithError(errRequestCanceled) + } +@@ -1668,12 +1786,17 @@ func (cs *clientStream) cleanupWriteRequest(err error) { + // Must hold cc.mu. + func (cc *ClientConn) awaitOpenSlotForStreamLocked(cs *clientStream) error { + for { +- cc.lastActive = time.Now() ++ if cc.closed && cc.nextStreamID == 1 && cc.streamsReserved == 0 { ++ // This is the very first request sent to this connection. ++ // Return a fatal error which aborts the retry loop. ++ return errClientConnNotEstablished ++ } ++ cc.lastActive = cc.t.now() + if cc.closed || !cc.canTakeNewRequestLocked() { + return errClientConnUnusable + } + cc.lastIdle = time.Time{} +- if int64(len(cc.streams)) < int64(cc.maxConcurrentStreams) { ++ if cc.currentRequestCountLocked() < int(cc.maxConcurrentStreams) { + return nil + } + cc.pendingRequests++ +@@ -1945,7 +2068,7 @@ func (cs *clientStream) awaitFlowControl(maxBytes int) (taken int32, err error) + + func validateHeaders(hdrs http.Header) string { + for k, vv := range hdrs { +- if !httpguts.ValidHeaderFieldName(k) { ++ if !httpguts.ValidHeaderFieldName(k) && k != ":protocol" { + return fmt.Sprintf("name %q", k) + } + for _, v := range vv { +@@ -1961,6 +2084,10 @@ func validateHeaders(hdrs http.Header) string { + + var errNilRequestURL = errors.New("http2: Request.URI is nil") + ++func isNormalConnect(req *http.Request) bool { ++ return req.Method == "CONNECT" && req.Header.Get(":protocol") == "" ++} ++ + // requires cc.wmu be held. + func (cc *ClientConn) encodeHeaders(req *http.Request, addGzipHeader bool, trailers string, contentLength int64) ([]byte, error) { + cc.hbuf.Reset() +@@ -1981,7 +2108,7 @@ func (cc *ClientConn) encodeHeaders(req *http.Request, addGzipHeader bool, trail + } + + var path string +- if req.Method != "CONNECT" { ++ if !isNormalConnect(req) { + path = req.URL.RequestURI() + if !validPseudoPath(path) { + orig := path +@@ -2018,7 +2145,7 @@ func (cc *ClientConn) encodeHeaders(req *http.Request, addGzipHeader bool, trail + m = http.MethodGet + } + f(":method", m) +- if req.Method != "CONNECT" { ++ if !isNormalConnect(req) { + f(":path", path) + f(":scheme", req.URL.Scheme) + } +@@ -2199,7 +2326,7 @@ type resAndError struct { + func (cc *ClientConn) addStreamLocked(cs *clientStream) { + cs.flow.add(int32(cc.initialWindowSize)) + cs.flow.setConnFlow(&cc.flow) +- cs.inflow.init(transportDefaultStreamFlow) ++ cs.inflow.init(cc.initialStreamRecvWindowSize) + cs.ID = cc.nextStreamID + cc.nextStreamID += 2 + cc.streams[cs.ID] = cs +@@ -2215,10 +2342,10 @@ func (cc *ClientConn) forgetStreamID(id uint32) { + if len(cc.streams) != slen-1 { + panic("forgetting unknown stream id") + } +- cc.lastActive = time.Now() ++ cc.lastActive = cc.t.now() + if len(cc.streams) == 0 && cc.idleTimer != nil { + cc.idleTimer.Reset(cc.idleTimeout) +- cc.lastIdle = time.Now() ++ cc.lastIdle = cc.t.now() + } + // Wake up writeRequestBody via clientStream.awaitFlowControl and + // wake up RoundTrip if there is a pending request. +@@ -2278,7 +2405,6 @@ func isEOFOrNetReadError(err error) bool { + + func (rl *clientConnReadLoop) cleanup() { + cc := rl.cc +- cc.t.connPool().MarkDead(cc) + defer cc.closeConn() + defer close(cc.readerDone) + +@@ -2302,6 +2428,24 @@ func (rl *clientConnReadLoop) cleanup() { + } + cc.closed = true + ++ // If the connection has never been used, and has been open for only a short time, ++ // leave it in the connection pool for a little while. ++ // ++ // This avoids a situation where new connections are constantly created, ++ // added to the pool, fail, and are removed from the pool, without any error ++ // being surfaced to the user. ++ const unusedWaitTime = 5 * time.Second ++ idleTime := cc.t.now().Sub(cc.lastActive) ++ if atomic.LoadUint32(&cc.atomicReused) == 0 && idleTime < unusedWaitTime { ++ cc.idleTimer = cc.t.afterFunc(unusedWaitTime-idleTime, func() { ++ cc.t.connPool().MarkDead(cc) ++ }) ++ } else { ++ cc.mu.Unlock() // avoid any deadlocks in MarkDead ++ cc.t.connPool().MarkDead(cc) ++ cc.mu.Lock() ++ } ++ + for _, cs := range cc.streams { + select { + case <-cs.peerClosed: +@@ -2345,7 +2489,7 @@ func (cc *ClientConn) countReadFrameError(err error) { + func (rl *clientConnReadLoop) run() error { + cc := rl.cc + gotSettings := false +- readIdleTimeout := cc.t.ReadIdleTimeout ++ readIdleTimeout := cc.readIdleTimeout + var t timer + if readIdleTimeout != 0 { + t = cc.t.afterFunc(readIdleTimeout, cc.healthCheck) +@@ -2359,7 +2503,7 @@ func (rl *clientConnReadLoop) run() error { + cc.vlogf("http2: Transport readFrame error on conn %p: (%T) %v", cc, err, err) + } + if se, ok := err.(StreamError); ok { +- if cs := rl.streamByID(se.StreamID); cs != nil { ++ if cs := rl.streamByID(se.StreamID, notHeaderOrDataFrame); cs != nil { + if se.Cause == nil { + se.Cause = cc.fr.errDetail + } +@@ -2405,13 +2549,16 @@ func (rl *clientConnReadLoop) run() error { + if VerboseLogs { + cc.vlogf("http2: Transport conn %p received error from processing frame %v: %v", cc, summarizeFrame(f), err) + } ++ if !cc.seenSettings { ++ close(cc.seenSettingsChan) ++ } + return err + } + } + } + + func (rl *clientConnReadLoop) processHeaders(f *MetaHeadersFrame) error { +- cs := rl.streamByID(f.StreamID) ++ cs := rl.streamByID(f.StreamID, headerOrDataFrame) + if cs == nil { + // We'd get here if we canceled a request while the + // server had its response still in flight. So if this +@@ -2529,15 +2676,34 @@ func (rl *clientConnReadLoop) handleResponse(cs *clientStream, f *MetaHeadersFra + if f.StreamEnded() { + return nil, errors.New("1xx informational response with END_STREAM flag") + } +- cs.num1xx++ +- const max1xxResponses = 5 // arbitrary bound on number of informational responses, same as net/http +- if cs.num1xx > max1xxResponses { +- return nil, errors.New("http2: too many 1xx informational responses") +- } + if fn := cs.get1xxTraceFunc(); fn != nil { ++ // If the 1xx response is being delivered to the user, ++ // then they're responsible for limiting the number ++ // of responses. + if err := fn(statusCode, textproto.MIMEHeader(header)); err != nil { + return nil, err + } ++ } else { ++ // If the user didn't examine the 1xx response, then we ++ // limit the size of all 1xx headers. ++ // ++ // This differs a bit from the HTTP/1 implementation, which ++ // limits the size of all 1xx headers plus the final response. ++ // Use the larger limit of MaxHeaderListSize and ++ // net/http.Transport.MaxResponseHeaderBytes. ++ limit := int64(cs.cc.t.maxHeaderListSize()) ++ if t1 := cs.cc.t.t1; t1 != nil && t1.MaxResponseHeaderBytes > limit { ++ limit = t1.MaxResponseHeaderBytes ++ } ++ for _, h := range f.Fields { ++ cs.totalHeaderSize += int64(h.Size()) ++ } ++ if cs.totalHeaderSize > limit { ++ if VerboseLogs { ++ log.Printf("http2: 1xx informational responses too large") ++ } ++ return nil, errors.New("header list too large") ++ } + } + if statusCode == 100 { + traceGot100Continue(cs.trace) +@@ -2721,7 +2887,7 @@ func (b transportResponseBody) Close() error { + + func (rl *clientConnReadLoop) processData(f *DataFrame) error { + cc := rl.cc +- cs := rl.streamByID(f.StreamID) ++ cs := rl.streamByID(f.StreamID, headerOrDataFrame) + data := f.Data() + if cs == nil { + cc.mu.Lock() +@@ -2856,9 +3022,22 @@ func (rl *clientConnReadLoop) endStreamError(cs *clientStream, err error) { + cs.abortStream(err) + } + +-func (rl *clientConnReadLoop) streamByID(id uint32) *clientStream { ++// Constants passed to streamByID for documentation purposes. ++const ( ++ headerOrDataFrame = true ++ notHeaderOrDataFrame = false ++) ++ ++// streamByID returns the stream with the given id, or nil if no stream has that id. ++// If headerOrData is true, it clears rst.StreamPingsBlocked. ++func (rl *clientConnReadLoop) streamByID(id uint32, headerOrData bool) *clientStream { + rl.cc.mu.Lock() + defer rl.cc.mu.Unlock() ++ if headerOrData { ++ // Work around an unfortunate gRPC behavior. ++ // See comment on ClientConn.rstStreamPingsBlocked for details. ++ rl.cc.rstStreamPingsBlocked = false ++ } + cs := rl.cc.streams[id] + if cs != nil && !cs.readAborted { + return cs +@@ -2952,6 +3131,21 @@ func (rl *clientConnReadLoop) processSettingsNoWrite(f *SettingsFrame) error { + case SettingHeaderTableSize: + cc.henc.SetMaxDynamicTableSize(s.Val) + cc.peerMaxHeaderTableSize = s.Val ++ case SettingEnableConnectProtocol: ++ if err := s.Valid(); err != nil { ++ return err ++ } ++ // If the peer wants to send us SETTINGS_ENABLE_CONNECT_PROTOCOL, ++ // we require that it do so in the first SETTINGS frame. ++ // ++ // When we attempt to use extended CONNECT, we wait for the first ++ // SETTINGS frame to see if the server supports it. If we let the ++ // server enable the feature with a later SETTINGS frame, then ++ // users will see inconsistent results depending on whether we've ++ // seen that frame or not. ++ if !cc.seenSettings { ++ cc.extendedConnectAllowed = s.Val == 1 ++ } + default: + cc.vlogf("Unhandled Setting: %v", s) + } +@@ -2969,6 +3163,7 @@ func (rl *clientConnReadLoop) processSettingsNoWrite(f *SettingsFrame) error { + // connection can establish to our default. + cc.maxConcurrentStreams = defaultMaxConcurrentStreams + } ++ close(cc.seenSettingsChan) + cc.seenSettings = true + } + +@@ -2977,7 +3172,7 @@ func (rl *clientConnReadLoop) processSettingsNoWrite(f *SettingsFrame) error { + + func (rl *clientConnReadLoop) processWindowUpdate(f *WindowUpdateFrame) error { + cc := rl.cc +- cs := rl.streamByID(f.StreamID) ++ cs := rl.streamByID(f.StreamID, notHeaderOrDataFrame) + if f.StreamID != 0 && cs == nil { + return nil + } +@@ -3006,7 +3201,7 @@ func (rl *clientConnReadLoop) processWindowUpdate(f *WindowUpdateFrame) error { + } + + func (rl *clientConnReadLoop) processResetStream(f *RSTStreamFrame) error { +- cs := rl.streamByID(f.StreamID) ++ cs := rl.streamByID(f.StreamID, notHeaderOrDataFrame) + if cs == nil { + // TODO: return error if server tries to RST_STREAM an idle stream + return nil +@@ -3081,6 +3276,12 @@ func (rl *clientConnReadLoop) processPing(f *PingFrame) error { + close(c) + delete(cc.pings, f.Data) + } ++ if cc.pendingResets > 0 { ++ // See clientStream.cleanupWriteRequest. ++ cc.pendingResets = 0 ++ cc.rstStreamPingsBlocked = true ++ cc.cond.Broadcast() ++ } + return nil + } + cc := rl.cc +@@ -3103,13 +3304,20 @@ func (rl *clientConnReadLoop) processPushPromise(f *PushPromiseFrame) error { + return ConnectionError(ErrCodeProtocol) + } + +-func (cc *ClientConn) writeStreamReset(streamID uint32, code ErrCode, err error) { ++// writeStreamReset sends a RST_STREAM frame. ++// When ping is true, it also sends a PING frame with a random payload. ++func (cc *ClientConn) writeStreamReset(streamID uint32, code ErrCode, ping bool, err error) { + // TODO: map err to more interesting error codes, once the + // HTTP community comes up with some. But currently for + // RST_STREAM there's no equivalent to GOAWAY frame's debug + // data, and the error codes are all pretty vague ("cancel"). + cc.wmu.Lock() + cc.fr.WriteRSTStream(streamID, code) ++ if ping { ++ var payload [8]byte ++ rand.Read(payload[:]) ++ cc.fr.WritePing(false, payload) ++ } + cc.bw.Flush() + cc.wmu.Unlock() + } +@@ -3263,7 +3471,7 @@ func traceGotConn(req *http.Request, cc *ClientConn, reused bool) { + cc.mu.Lock() + ci.WasIdle = len(cc.streams) == 0 && reused + if ci.WasIdle && !cc.lastActive.IsZero() { +- ci.IdleTime = time.Since(cc.lastActive) ++ ci.IdleTime = cc.t.timeSince(cc.lastActive) + } + cc.mu.Unlock() + +diff --git a/vendor/golang.org/x/net/http2/unencrypted.go b/vendor/golang.org/x/net/http2/unencrypted.go +new file mode 100644 +index 0000000..b2de211 +--- /dev/null ++++ b/vendor/golang.org/x/net/http2/unencrypted.go +@@ -0,0 +1,32 @@ ++// Copyright 2024 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 http2 ++ ++import ( ++ "crypto/tls" ++ "errors" ++ "net" ++) ++ ++const nextProtoUnencryptedHTTP2 = "unencrypted_http2" ++ ++// unencryptedNetConnFromTLSConn retrieves a net.Conn wrapped in a *tls.Conn. ++// ++// TLSNextProto functions accept a *tls.Conn. ++// ++// When passing an unencrypted HTTP/2 connection to a TLSNextProto function, ++// we pass a *tls.Conn with an underlying net.Conn containing the unencrypted connection. ++// To be extra careful about mistakes (accidentally dropping TLS encryption in a place ++// where we want it), the tls.Conn contains a net.Conn with an UnencryptedNetConn method ++// that returns the actual connection we want to use. ++func unencryptedNetConnFromTLSConn(tc *tls.Conn) (net.Conn, error) { ++ conner, ok := tc.NetConn().(interface { ++ UnencryptedNetConn() net.Conn ++ }) ++ if !ok { ++ return nil, errors.New("http2: TLS conn unexpectedly found in unencrypted handoff") ++ } ++ return conner.UnencryptedNetConn(), nil ++} +diff --git a/vendor/golang.org/x/net/http2/write.go b/vendor/golang.org/x/net/http2/write.go +index 33f6139..6ff6bee 100644 +--- a/vendor/golang.org/x/net/http2/write.go ++++ b/vendor/golang.org/x/net/http2/write.go +@@ -131,6 +131,16 @@ func (se StreamError) writeFrame(ctx writeContext) error { + + func (se StreamError) staysWithinBuffer(max int) bool { return frameHeaderLen+4 <= max } + ++type writePing struct { ++ data [8]byte ++} ++ ++func (w writePing) writeFrame(ctx writeContext) error { ++ return ctx.Framer().WritePing(false, w.data) ++} ++ ++func (w writePing) staysWithinBuffer(max int) bool { return frameHeaderLen+len(w.data) <= max } ++ + type writePingAck struct{ pf *PingFrame } + + func (w writePingAck) writeFrame(ctx writeContext) error { +diff --git a/vendor/golang.org/x/sys/unix/README.md b/vendor/golang.org/x/sys/unix/README.md +index 7d3c060..6e08a76 100644 +--- a/vendor/golang.org/x/sys/unix/README.md ++++ b/vendor/golang.org/x/sys/unix/README.md +@@ -156,7 +156,7 @@ from the generated architecture-specific files listed below, and merge these + into a common file for each OS. + + The merge is performed in the following steps: +-1. Construct the set of common code that is idential in all architecture-specific files. ++1. Construct the set of common code that is identical in all architecture-specific files. + 2. Write this common code to the merged file. + 3. Remove the common code from all architecture-specific files. + +diff --git a/vendor/golang.org/x/sys/unix/ioctl_linux.go b/vendor/golang.org/x/sys/unix/ioctl_linux.go +index dbe680e..7ca4fa1 100644 +--- a/vendor/golang.org/x/sys/unix/ioctl_linux.go ++++ b/vendor/golang.org/x/sys/unix/ioctl_linux.go +@@ -58,6 +58,102 @@ func IoctlGetEthtoolDrvinfo(fd int, ifname string) (*EthtoolDrvinfo, error) { + return &value, err + } + ++// IoctlGetEthtoolTsInfo fetches ethtool timestamping and PHC ++// association for the network device specified by ifname. ++func IoctlGetEthtoolTsInfo(fd int, ifname string) (*EthtoolTsInfo, error) { ++ ifr, err := NewIfreq(ifname) ++ if err != nil { ++ return nil, err ++ } ++ ++ value := EthtoolTsInfo{Cmd: ETHTOOL_GET_TS_INFO} ++ ifrd := ifr.withData(unsafe.Pointer(&value)) ++ ++ err = ioctlIfreqData(fd, SIOCETHTOOL, &ifrd) ++ return &value, err ++} ++ ++// IoctlGetHwTstamp retrieves the hardware timestamping configuration ++// for the network device specified by ifname. ++func IoctlGetHwTstamp(fd int, ifname string) (*HwTstampConfig, error) { ++ ifr, err := NewIfreq(ifname) ++ if err != nil { ++ return nil, err ++ } ++ ++ value := HwTstampConfig{} ++ ifrd := ifr.withData(unsafe.Pointer(&value)) ++ ++ err = ioctlIfreqData(fd, SIOCGHWTSTAMP, &ifrd) ++ return &value, err ++} ++ ++// IoctlSetHwTstamp updates the hardware timestamping configuration for ++// the network device specified by ifname. ++func IoctlSetHwTstamp(fd int, ifname string, cfg *HwTstampConfig) error { ++ ifr, err := NewIfreq(ifname) ++ if err != nil { ++ return err ++ } ++ ifrd := ifr.withData(unsafe.Pointer(cfg)) ++ return ioctlIfreqData(fd, SIOCSHWTSTAMP, &ifrd) ++} ++ ++// FdToClockID derives the clock ID from the file descriptor number ++// - see clock_gettime(3), FD_TO_CLOCKID macros. The resulting ID is ++// suitable for system calls like ClockGettime. ++func FdToClockID(fd int) int32 { return int32((int(^fd) << 3) | 3) } ++ ++// IoctlPtpClockGetcaps returns the description of a given PTP device. ++func IoctlPtpClockGetcaps(fd int) (*PtpClockCaps, error) { ++ var value PtpClockCaps ++ err := ioctlPtr(fd, PTP_CLOCK_GETCAPS2, unsafe.Pointer(&value)) ++ return &value, err ++} ++ ++// IoctlPtpSysOffsetPrecise returns a description of the clock ++// offset compared to the system clock. ++func IoctlPtpSysOffsetPrecise(fd int) (*PtpSysOffsetPrecise, error) { ++ var value PtpSysOffsetPrecise ++ err := ioctlPtr(fd, PTP_SYS_OFFSET_PRECISE2, unsafe.Pointer(&value)) ++ return &value, err ++} ++ ++// IoctlPtpSysOffsetExtended returns an extended description of the ++// clock offset compared to the system clock. The samples parameter ++// specifies the desired number of measurements. ++func IoctlPtpSysOffsetExtended(fd int, samples uint) (*PtpSysOffsetExtended, error) { ++ value := PtpSysOffsetExtended{Samples: uint32(samples)} ++ err := ioctlPtr(fd, PTP_SYS_OFFSET_EXTENDED2, unsafe.Pointer(&value)) ++ return &value, err ++} ++ ++// IoctlPtpPinGetfunc returns the configuration of the specified ++// I/O pin on given PTP device. ++func IoctlPtpPinGetfunc(fd int, index uint) (*PtpPinDesc, error) { ++ value := PtpPinDesc{Index: uint32(index)} ++ err := ioctlPtr(fd, PTP_PIN_GETFUNC2, unsafe.Pointer(&value)) ++ return &value, err ++} ++ ++// IoctlPtpPinSetfunc updates configuration of the specified PTP ++// I/O pin. ++func IoctlPtpPinSetfunc(fd int, pd *PtpPinDesc) error { ++ return ioctlPtr(fd, PTP_PIN_SETFUNC2, unsafe.Pointer(pd)) ++} ++ ++// IoctlPtpPeroutRequest configures the periodic output mode of the ++// PTP I/O pins. ++func IoctlPtpPeroutRequest(fd int, r *PtpPeroutRequest) error { ++ return ioctlPtr(fd, PTP_PEROUT_REQUEST2, unsafe.Pointer(r)) ++} ++ ++// IoctlPtpExttsRequest configures the external timestamping mode ++// of the PTP I/O pins. ++func IoctlPtpExttsRequest(fd int, r *PtpExttsRequest) error { ++ return ioctlPtr(fd, PTP_EXTTS_REQUEST2, unsafe.Pointer(r)) ++} ++ + // IoctlGetWatchdogInfo fetches information about a watchdog device from the + // Linux watchdog API. For more information, see: + // https://www.kernel.org/doc/html/latest/watchdog/watchdog-api.html. +diff --git a/vendor/golang.org/x/sys/unix/mkerrors.sh b/vendor/golang.org/x/sys/unix/mkerrors.sh +index d07dd09..6ab02b6 100644 +--- a/vendor/golang.org/x/sys/unix/mkerrors.sh ++++ b/vendor/golang.org/x/sys/unix/mkerrors.sh +@@ -158,6 +158,16 @@ includes_Linux=' + #endif + #define _GNU_SOURCE + ++// See the description in unix/linux/types.go ++#if defined(__ARM_EABI__) || \ ++ (defined(__mips__) && (_MIPS_SIM == _ABIO32)) || \ ++ (defined(__powerpc__) && (!defined(__powerpc64__))) ++# ifdef _TIME_BITS ++# undef _TIME_BITS ++# endif ++# define _TIME_BITS 32 ++#endif ++ + // is broken on powerpc64, as it fails to include definitions of + // these structures. We just include them copied from . + #if defined(__powerpc__) +@@ -256,6 +266,7 @@ struct ltchars { + #include + #include + #include ++#include + #include + #include + #include +@@ -527,6 +538,7 @@ ccflags="$@" + $2 ~ /^(AF|SOCK|SO|SOL|IPPROTO|IP|IPV6|TCP|MCAST|EVFILT|NOTE|SHUT|PROT|MAP|MREMAP|MFD|T?PACKET|MSG|SCM|MCL|DT|MADV|PR|LOCAL|TCPOPT|UDP)_/ || + $2 ~ /^NFC_(GENL|PROTO|COMM|RF|SE|DIRECTION|LLCP|SOCKPROTO)_/ || + $2 ~ /^NFC_.*_(MAX)?SIZE$/ || ++ $2 ~ /^PTP_/ || + $2 ~ /^RAW_PAYLOAD_/ || + $2 ~ /^[US]F_/ || + $2 ~ /^TP_STATUS_/ || +@@ -552,6 +564,7 @@ ccflags="$@" + $2 !~ /^RTC_VL_(ACCURACY|BACKUP|DATA)/ && + $2 ~ /^(NETLINK|NLM|NLMSG|NLA|IFA|IFAN|RT|RTC|RTCF|RTN|RTPROT|RTNH|ARPHRD|ETH_P|NETNSA)_/ || + $2 ~ /^SOCK_|SK_DIAG_|SKNLGRP_$/ || ++ $2 ~ /^(CONNECT|SAE)_/ || + $2 ~ /^FIORDCHK$/ || + $2 ~ /^SIOC/ || + $2 ~ /^TIOC/ || +@@ -655,7 +668,7 @@ errors=$( + signals=$( + echo '#include ' | $CC -x c - -E -dM $ccflags | + awk '$1=="#define" && $2 ~ /^SIG[A-Z0-9]+$/ { print $2 }' | +- grep -v 'SIGSTKSIZE\|SIGSTKSZ\|SIGRT\|SIGMAX64' | ++ grep -E -v '(SIGSTKSIZE|SIGSTKSZ|SIGRT|SIGMAX64)' | + sort + ) + +@@ -665,7 +678,7 @@ echo '#include ' | $CC -x c - -E -dM $ccflags | + sort >_error.grep + echo '#include ' | $CC -x c - -E -dM $ccflags | + awk '$1=="#define" && $2 ~ /^SIG[A-Z0-9]+$/ { print "^\t" $2 "[ \t]*=" }' | +- grep -v 'SIGSTKSIZE\|SIGSTKSZ\|SIGRT\|SIGMAX64' | ++ grep -E -v '(SIGSTKSIZE|SIGSTKSZ|SIGRT|SIGMAX64)' | + sort >_signal.grep + + echo '// mkerrors.sh' "$@" +diff --git a/vendor/golang.org/x/sys/unix/syscall_aix.go b/vendor/golang.org/x/sys/unix/syscall_aix.go +index 67ce6ce..6f15ba1 100644 +--- a/vendor/golang.org/x/sys/unix/syscall_aix.go ++++ b/vendor/golang.org/x/sys/unix/syscall_aix.go +@@ -360,7 +360,7 @@ func Wait4(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (wpid int, + var status _C_int + var r Pid_t + err = ERESTART +- // AIX wait4 may return with ERESTART errno, while the processus is still ++ // AIX wait4 may return with ERESTART errno, while the process is still + // active. + for err == ERESTART { + r, err = wait4(Pid_t(pid), &status, options, rusage) +diff --git a/vendor/golang.org/x/sys/unix/syscall_darwin.go b/vendor/golang.org/x/sys/unix/syscall_darwin.go +index 2d15200..099867d 100644 +--- a/vendor/golang.org/x/sys/unix/syscall_darwin.go ++++ b/vendor/golang.org/x/sys/unix/syscall_darwin.go +@@ -566,6 +566,43 @@ func PthreadFchdir(fd int) (err error) { + return pthread_fchdir_np(fd) + } + ++// Connectx calls connectx(2) to initiate a connection on a socket. ++// ++// srcIf, srcAddr, and dstAddr are filled into a [SaEndpoints] struct and passed as the endpoints argument. ++// ++// - srcIf is the optional source interface index. 0 means unspecified. ++// - srcAddr is the optional source address. nil means unspecified. ++// - dstAddr is the destination address. ++// ++// On success, Connectx returns the number of bytes enqueued for transmission. ++func Connectx(fd int, srcIf uint32, srcAddr, dstAddr Sockaddr, associd SaeAssocID, flags uint32, iov []Iovec, connid *SaeConnID) (n uintptr, err error) { ++ endpoints := SaEndpoints{ ++ Srcif: srcIf, ++ } ++ ++ if srcAddr != nil { ++ addrp, addrlen, err := srcAddr.sockaddr() ++ if err != nil { ++ return 0, err ++ } ++ endpoints.Srcaddr = (*RawSockaddr)(addrp) ++ endpoints.Srcaddrlen = uint32(addrlen) ++ } ++ ++ if dstAddr != nil { ++ addrp, addrlen, err := dstAddr.sockaddr() ++ if err != nil { ++ return 0, err ++ } ++ endpoints.Dstaddr = (*RawSockaddr)(addrp) ++ endpoints.Dstaddrlen = uint32(addrlen) ++ } ++ ++ err = connectx(fd, &endpoints, associd, flags, iov, &n, connid) ++ return ++} ++ ++//sys connectx(fd int, endpoints *SaEndpoints, associd SaeAssocID, flags uint32, iov []Iovec, n *uintptr, connid *SaeConnID) (err error) + //sys sendfile(infd int, outfd int, offset int64, len *int64, hdtr unsafe.Pointer, flags int) (err error) + + //sys shmat(id int, addr uintptr, flag int) (ret uintptr, err error) +diff --git a/vendor/golang.org/x/sys/unix/syscall_hurd.go b/vendor/golang.org/x/sys/unix/syscall_hurd.go +index ba46651..a6a2d2f 100644 +--- a/vendor/golang.org/x/sys/unix/syscall_hurd.go ++++ b/vendor/golang.org/x/sys/unix/syscall_hurd.go +@@ -11,6 +11,7 @@ package unix + int ioctl(int, unsigned long int, uintptr_t); + */ + import "C" ++import "unsafe" + + func ioctl(fd int, req uint, arg uintptr) (err error) { + r0, er := C.ioctl(C.int(fd), C.ulong(req), C.uintptr_t(arg)) +diff --git a/vendor/golang.org/x/sys/unix/syscall_linux.go b/vendor/golang.org/x/sys/unix/syscall_linux.go +index 3f1d3d4..230a945 100644 +--- a/vendor/golang.org/x/sys/unix/syscall_linux.go ++++ b/vendor/golang.org/x/sys/unix/syscall_linux.go +@@ -1295,6 +1295,48 @@ func GetsockoptTCPInfo(fd, level, opt int) (*TCPInfo, error) { + return &value, err + } + ++// GetsockoptTCPCCVegasInfo returns algorithm specific congestion control information for a socket using the "vegas" ++// algorithm. ++// ++// The socket's congestion control algorighm can be retrieved via [GetsockoptString] with the [TCP_CONGESTION] option: ++// ++// algo, err := unix.GetsockoptString(fd, unix.IPPROTO_TCP, unix.TCP_CONGESTION) ++func GetsockoptTCPCCVegasInfo(fd, level, opt int) (*TCPVegasInfo, error) { ++ var value [SizeofTCPCCInfo / 4]uint32 // ensure proper alignment ++ vallen := _Socklen(SizeofTCPCCInfo) ++ err := getsockopt(fd, level, opt, unsafe.Pointer(&value[0]), &vallen) ++ out := (*TCPVegasInfo)(unsafe.Pointer(&value[0])) ++ return out, err ++} ++ ++// GetsockoptTCPCCDCTCPInfo returns algorithm specific congestion control information for a socket using the "dctp" ++// algorithm. ++// ++// The socket's congestion control algorighm can be retrieved via [GetsockoptString] with the [TCP_CONGESTION] option: ++// ++// algo, err := unix.GetsockoptString(fd, unix.IPPROTO_TCP, unix.TCP_CONGESTION) ++func GetsockoptTCPCCDCTCPInfo(fd, level, opt int) (*TCPDCTCPInfo, error) { ++ var value [SizeofTCPCCInfo / 4]uint32 // ensure proper alignment ++ vallen := _Socklen(SizeofTCPCCInfo) ++ err := getsockopt(fd, level, opt, unsafe.Pointer(&value[0]), &vallen) ++ out := (*TCPDCTCPInfo)(unsafe.Pointer(&value[0])) ++ return out, err ++} ++ ++// GetsockoptTCPCCBBRInfo returns algorithm specific congestion control information for a socket using the "bbr" ++// algorithm. ++// ++// The socket's congestion control algorighm can be retrieved via [GetsockoptString] with the [TCP_CONGESTION] option: ++// ++// algo, err := unix.GetsockoptString(fd, unix.IPPROTO_TCP, unix.TCP_CONGESTION) ++func GetsockoptTCPCCBBRInfo(fd, level, opt int) (*TCPBBRInfo, error) { ++ var value [SizeofTCPCCInfo / 4]uint32 // ensure proper alignment ++ vallen := _Socklen(SizeofTCPCCInfo) ++ err := getsockopt(fd, level, opt, unsafe.Pointer(&value[0]), &vallen) ++ out := (*TCPBBRInfo)(unsafe.Pointer(&value[0])) ++ return out, err ++} ++ + // GetsockoptString returns the string value of the socket option opt for the + // socket associated with fd at the given socket level. + func GetsockoptString(fd, level, opt int) (string, error) { +@@ -1818,6 +1860,7 @@ func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err e + //sys ClockAdjtime(clockid int32, buf *Timex) (state int, err error) + //sys ClockGetres(clockid int32, res *Timespec) (err error) + //sys ClockGettime(clockid int32, time *Timespec) (err error) ++//sys ClockSettime(clockid int32, time *Timespec) (err error) + //sys ClockNanosleep(clockid int32, flags int, request *Timespec, remain *Timespec) (err error) + //sys Close(fd int) (err error) + //sys CloseRange(first uint, last uint, flags uint) (err error) +@@ -1959,7 +2002,26 @@ func Getpgrp() (pid int) { + //sysnb Getpid() (pid int) + //sysnb Getppid() (ppid int) + //sys Getpriority(which int, who int) (prio int, err error) +-//sys Getrandom(buf []byte, flags int) (n int, err error) ++ ++func Getrandom(buf []byte, flags int) (n int, err error) { ++ vdsoRet, supported := vgetrandom(buf, uint32(flags)) ++ if supported { ++ if vdsoRet < 0 { ++ return 0, errnoErr(syscall.Errno(-vdsoRet)) ++ } ++ return vdsoRet, nil ++ } ++ var p *byte ++ if len(buf) > 0 { ++ p = &buf[0] ++ } ++ r, _, e := Syscall(SYS_GETRANDOM, uintptr(unsafe.Pointer(p)), uintptr(len(buf)), uintptr(flags)) ++ if e != 0 { ++ return 0, errnoErr(e) ++ } ++ return int(r), nil ++} ++ + //sysnb Getrusage(who int, rusage *Rusage) (err error) + //sysnb Getsid(pid int) (sid int, err error) + //sysnb Gettid() (tid int) +diff --git a/vendor/golang.org/x/sys/unix/syscall_linux_arm64.go b/vendor/golang.org/x/sys/unix/syscall_linux_arm64.go +index cf2ee6c..745e5c7 100644 +--- a/vendor/golang.org/x/sys/unix/syscall_linux_arm64.go ++++ b/vendor/golang.org/x/sys/unix/syscall_linux_arm64.go +@@ -182,3 +182,5 @@ func KexecFileLoad(kernelFd int, initrdFd int, cmdline string, flags int) error + } + return kexecFileLoad(kernelFd, initrdFd, cmdlineLen, cmdline, flags) + } ++ ++const SYS_FSTATAT = SYS_NEWFSTATAT +diff --git a/vendor/golang.org/x/sys/unix/syscall_linux_loong64.go b/vendor/golang.org/x/sys/unix/syscall_linux_loong64.go +index 3d0e984..dd2262a 100644 +--- a/vendor/golang.org/x/sys/unix/syscall_linux_loong64.go ++++ b/vendor/golang.org/x/sys/unix/syscall_linux_loong64.go +@@ -214,3 +214,5 @@ func KexecFileLoad(kernelFd int, initrdFd int, cmdline string, flags int) error + } + return kexecFileLoad(kernelFd, initrdFd, cmdlineLen, cmdline, flags) + } ++ ++const SYS_FSTATAT = SYS_NEWFSTATAT +diff --git a/vendor/golang.org/x/sys/unix/syscall_linux_riscv64.go b/vendor/golang.org/x/sys/unix/syscall_linux_riscv64.go +index 6f5a288..8cf3670 100644 +--- a/vendor/golang.org/x/sys/unix/syscall_linux_riscv64.go ++++ b/vendor/golang.org/x/sys/unix/syscall_linux_riscv64.go +@@ -187,3 +187,5 @@ func RISCVHWProbe(pairs []RISCVHWProbePairs, set *CPUSet, flags uint) (err error + } + return riscvHWProbe(pairs, setSize, set, flags) + } ++ ++const SYS_FSTATAT = SYS_NEWFSTATAT +diff --git a/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go b/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go +index 312ae6a..7bf5c04 100644 +--- a/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go ++++ b/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go +@@ -768,6 +768,15 @@ func Munmap(b []byte) (err error) { + return mapper.Munmap(b) + } + ++func MmapPtr(fd int, offset int64, addr unsafe.Pointer, length uintptr, prot int, flags int) (ret unsafe.Pointer, err error) { ++ xaddr, err := mapper.mmap(uintptr(addr), length, prot, flags, fd, offset) ++ return unsafe.Pointer(xaddr), err ++} ++ ++func MunmapPtr(addr unsafe.Pointer, length uintptr) (err error) { ++ return mapper.munmap(uintptr(addr), length) ++} ++ + //sys Gethostname(buf []byte) (err error) = SYS___GETHOSTNAME_A + //sysnb Getgid() (gid int) + //sysnb Getpid() (pid int) +@@ -816,10 +825,10 @@ func Lstat(path string, stat *Stat_t) (err error) { + // for checking symlinks begins with $VERSION/ $SYSNAME/ $SYSSYMR/ $SYSSYMA/ + func isSpecialPath(path []byte) (v bool) { + var special = [4][8]byte{ +- [8]byte{'V', 'E', 'R', 'S', 'I', 'O', 'N', '/'}, +- [8]byte{'S', 'Y', 'S', 'N', 'A', 'M', 'E', '/'}, +- [8]byte{'S', 'Y', 'S', 'S', 'Y', 'M', 'R', '/'}, +- [8]byte{'S', 'Y', 'S', 'S', 'Y', 'M', 'A', '/'}} ++ {'V', 'E', 'R', 'S', 'I', 'O', 'N', '/'}, ++ {'S', 'Y', 'S', 'N', 'A', 'M', 'E', '/'}, ++ {'S', 'Y', 'S', 'S', 'Y', 'M', 'R', '/'}, ++ {'S', 'Y', 'S', 'S', 'Y', 'M', 'A', '/'}} + + var i, j int + for i = 0; i < len(special); i++ { +@@ -3115,3 +3124,90 @@ func legacy_Mkfifoat(dirfd int, path string, mode uint32) (err error) { + //sys Posix_openpt(oflag int) (fd int, err error) = SYS_POSIX_OPENPT + //sys Grantpt(fildes int) (rc int, err error) = SYS_GRANTPT + //sys Unlockpt(fildes int) (rc int, err error) = SYS_UNLOCKPT ++ ++func fcntlAsIs(fd uintptr, cmd int, arg uintptr) (val int, err error) { ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_FCNTL<<4, uintptr(fd), uintptr(cmd), arg) ++ runtime.ExitSyscall() ++ val = int(r0) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++func Fcntl(fd uintptr, cmd int, op interface{}) (ret int, err error) { ++ switch op.(type) { ++ case *Flock_t: ++ err = FcntlFlock(fd, cmd, op.(*Flock_t)) ++ if err != nil { ++ ret = -1 ++ } ++ return ++ case int: ++ return FcntlInt(fd, cmd, op.(int)) ++ case *F_cnvrt: ++ return fcntlAsIs(fd, cmd, uintptr(unsafe.Pointer(op.(*F_cnvrt)))) ++ case unsafe.Pointer: ++ return fcntlAsIs(fd, cmd, uintptr(op.(unsafe.Pointer))) ++ default: ++ return -1, EINVAL ++ } ++ return ++} ++ ++func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) { ++ if raceenabled { ++ raceReleaseMerge(unsafe.Pointer(&ioSync)) ++ } ++ return sendfile(outfd, infd, offset, count) ++} ++ ++func sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) { ++ // TODO: use LE call instead if the call is implemented ++ originalOffset, err := Seek(infd, 0, SEEK_CUR) ++ if err != nil { ++ return -1, err ++ } ++ //start reading data from in_fd ++ if offset != nil { ++ _, err := Seek(infd, *offset, SEEK_SET) ++ if err != nil { ++ return -1, err ++ } ++ } ++ ++ buf := make([]byte, count) ++ readBuf := make([]byte, 0) ++ var n int = 0 ++ for i := 0; i < count; i += n { ++ n, err := Read(infd, buf) ++ if n == 0 { ++ if err != nil { ++ return -1, err ++ } else { // EOF ++ break ++ } ++ } ++ readBuf = append(readBuf, buf...) ++ buf = buf[0:0] ++ } ++ ++ n2, err := Write(outfd, readBuf) ++ if err != nil { ++ return -1, err ++ } ++ ++ //When sendfile() returns, this variable will be set to the ++ // offset of the byte following the last byte that was read. ++ if offset != nil { ++ *offset = *offset + int64(n) ++ // If offset is not NULL, then sendfile() does not modify the file ++ // offset of in_fd ++ _, err := Seek(infd, originalOffset, SEEK_SET) ++ if err != nil { ++ return -1, err ++ } ++ } ++ return n2, nil ++} +diff --git a/vendor/golang.org/x/sys/unix/vgetrandom_linux.go b/vendor/golang.org/x/sys/unix/vgetrandom_linux.go +new file mode 100644 +index 0000000..07ac8e0 +--- /dev/null ++++ b/vendor/golang.org/x/sys/unix/vgetrandom_linux.go +@@ -0,0 +1,13 @@ ++// Copyright 2024 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. ++ ++//go:build linux && go1.24 ++ ++package unix ++ ++import _ "unsafe" ++ ++//go:linkname vgetrandom runtime.vgetrandom ++//go:noescape ++func vgetrandom(p []byte, flags uint32) (ret int, supported bool) +diff --git a/vendor/golang.org/x/sys/unix/vgetrandom_unsupported.go b/vendor/golang.org/x/sys/unix/vgetrandom_unsupported.go +new file mode 100644 +index 0000000..297e97b +--- /dev/null ++++ b/vendor/golang.org/x/sys/unix/vgetrandom_unsupported.go +@@ -0,0 +1,11 @@ ++// Copyright 2024 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. ++ ++//go:build !linux || !go1.24 ++ ++package unix ++ ++func vgetrandom(p []byte, flags uint32) (ret int, supported bool) { ++ return -1, false ++} +diff --git a/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go b/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go +index 4308ac1..d73c465 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go +@@ -237,6 +237,9 @@ const ( + CLOCK_UPTIME_RAW_APPROX = 0x9 + CLONE_NOFOLLOW = 0x1 + CLONE_NOOWNERCOPY = 0x2 ++ CONNECT_DATA_AUTHENTICATED = 0x4 ++ CONNECT_DATA_IDEMPOTENT = 0x2 ++ CONNECT_RESUME_ON_READ_WRITE = 0x1 + CR0 = 0x0 + CR1 = 0x1000 + CR2 = 0x2000 +@@ -1265,6 +1268,10 @@ const ( + RTV_SSTHRESH = 0x20 + RUSAGE_CHILDREN = -0x1 + RUSAGE_SELF = 0x0 ++ SAE_ASSOCID_ALL = 0xffffffff ++ SAE_ASSOCID_ANY = 0x0 ++ SAE_CONNID_ALL = 0xffffffff ++ SAE_CONNID_ANY = 0x0 + SCM_CREDS = 0x3 + SCM_RIGHTS = 0x1 + SCM_TIMESTAMP = 0x2 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go b/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go +index c8068a7..4a55a40 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go +@@ -237,6 +237,9 @@ const ( + CLOCK_UPTIME_RAW_APPROX = 0x9 + CLONE_NOFOLLOW = 0x1 + CLONE_NOOWNERCOPY = 0x2 ++ CONNECT_DATA_AUTHENTICATED = 0x4 ++ CONNECT_DATA_IDEMPOTENT = 0x2 ++ CONNECT_RESUME_ON_READ_WRITE = 0x1 + CR0 = 0x0 + CR1 = 0x1000 + CR2 = 0x2000 +@@ -1265,6 +1268,10 @@ const ( + RTV_SSTHRESH = 0x20 + RUSAGE_CHILDREN = -0x1 + RUSAGE_SELF = 0x0 ++ SAE_ASSOCID_ALL = 0xffffffff ++ SAE_ASSOCID_ANY = 0x0 ++ SAE_CONNID_ALL = 0xffffffff ++ SAE_CONNID_ANY = 0x0 + SCM_CREDS = 0x3 + SCM_RIGHTS = 0x1 + SCM_TIMESTAMP = 0x2 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux.go b/vendor/golang.org/x/sys/unix/zerrors_linux.go +index 01a70b2..6ebc48b 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux.go +@@ -321,6 +321,9 @@ const ( + AUDIT_INTEGRITY_STATUS = 0x70a + AUDIT_IPC = 0x517 + AUDIT_IPC_SET_PERM = 0x51f ++ AUDIT_IPE_ACCESS = 0x58c ++ AUDIT_IPE_CONFIG_CHANGE = 0x58d ++ AUDIT_IPE_POLICY_LOAD = 0x58e + AUDIT_KERNEL = 0x7d0 + AUDIT_KERNEL_OTHER = 0x524 + AUDIT_KERN_MODULE = 0x532 +@@ -489,12 +492,14 @@ const ( + BPF_F_ID = 0x20 + BPF_F_NETFILTER_IP_DEFRAG = 0x1 + BPF_F_QUERY_EFFECTIVE = 0x1 ++ BPF_F_REDIRECT_FLAGS = 0x19 + BPF_F_REPLACE = 0x4 + BPF_F_SLEEPABLE = 0x10 + BPF_F_STRICT_ALIGNMENT = 0x1 + BPF_F_TEST_REG_INVARIANTS = 0x80 + BPF_F_TEST_RND_HI32 = 0x4 + BPF_F_TEST_RUN_ON_CPU = 0x1 ++ BPF_F_TEST_SKB_CHECKSUM_COMPLETE = 0x4 + BPF_F_TEST_STATE_FREQ = 0x8 + BPF_F_TEST_XDP_LIVE_FRAMES = 0x2 + BPF_F_XDP_DEV_BOUND_ONLY = 0x40 +@@ -1165,6 +1170,7 @@ const ( + EXTA = 0xe + EXTB = 0xf + F2FS_SUPER_MAGIC = 0xf2f52010 ++ FALLOC_FL_ALLOCATE_RANGE = 0x0 + FALLOC_FL_COLLAPSE_RANGE = 0x8 + FALLOC_FL_INSERT_RANGE = 0x20 + FALLOC_FL_KEEP_SIZE = 0x1 +@@ -1798,6 +1804,8 @@ const ( + LANDLOCK_ACCESS_NET_BIND_TCP = 0x1 + LANDLOCK_ACCESS_NET_CONNECT_TCP = 0x2 + LANDLOCK_CREATE_RULESET_VERSION = 0x1 ++ LANDLOCK_SCOPE_ABSTRACT_UNIX_SOCKET = 0x1 ++ LANDLOCK_SCOPE_SIGNAL = 0x2 + LINUX_REBOOT_CMD_CAD_OFF = 0x0 + LINUX_REBOOT_CMD_CAD_ON = 0x89abcdef + LINUX_REBOOT_CMD_HALT = 0xcdef0123 +@@ -1922,6 +1930,8 @@ const ( + MNT_EXPIRE = 0x4 + MNT_FORCE = 0x1 + MNT_ID_REQ_SIZE_VER0 = 0x18 ++ MNT_ID_REQ_SIZE_VER1 = 0x20 ++ MNT_NS_INFO_SIZE_VER0 = 0x10 + MODULE_INIT_COMPRESSED_FILE = 0x4 + MODULE_INIT_IGNORE_MODVERSIONS = 0x1 + MODULE_INIT_IGNORE_VERMAGIC = 0x2 +@@ -2187,7 +2197,7 @@ const ( + NFT_REG_SIZE = 0x10 + NFT_REJECT_ICMPX_MAX = 0x3 + NFT_RT_MAX = 0x4 +- NFT_SECMARK_CTX_MAXLEN = 0x100 ++ NFT_SECMARK_CTX_MAXLEN = 0x1000 + NFT_SET_MAXNAMELEN = 0x100 + NFT_SOCKET_MAX = 0x3 + NFT_TABLE_F_MASK = 0x7 +@@ -2356,9 +2366,11 @@ const ( + PERF_MEM_LVLNUM_IO = 0xa + PERF_MEM_LVLNUM_L1 = 0x1 + PERF_MEM_LVLNUM_L2 = 0x2 ++ PERF_MEM_LVLNUM_L2_MHB = 0x5 + PERF_MEM_LVLNUM_L3 = 0x3 + PERF_MEM_LVLNUM_L4 = 0x4 + PERF_MEM_LVLNUM_LFB = 0xc ++ PERF_MEM_LVLNUM_MSC = 0x6 + PERF_MEM_LVLNUM_NA = 0xf + PERF_MEM_LVLNUM_PMEM = 0xe + PERF_MEM_LVLNUM_RAM = 0xd +@@ -2431,6 +2443,7 @@ const ( + PRIO_PGRP = 0x1 + PRIO_PROCESS = 0x0 + PRIO_USER = 0x2 ++ PROCFS_IOCTL_MAGIC = 'f' + PROC_SUPER_MAGIC = 0x9fa0 + PROT_EXEC = 0x4 + PROT_GROWSDOWN = 0x1000000 +@@ -2620,6 +2633,28 @@ const ( + PR_UNALIGN_NOPRINT = 0x1 + PR_UNALIGN_SIGBUS = 0x2 + PSTOREFS_MAGIC = 0x6165676c ++ PTP_CLK_MAGIC = '=' ++ PTP_ENABLE_FEATURE = 0x1 ++ PTP_EXTTS_EDGES = 0x6 ++ PTP_EXTTS_EVENT_VALID = 0x1 ++ PTP_EXTTS_V1_VALID_FLAGS = 0x7 ++ PTP_EXTTS_VALID_FLAGS = 0x1f ++ PTP_EXT_OFFSET = 0x10 ++ PTP_FALLING_EDGE = 0x4 ++ PTP_MAX_SAMPLES = 0x19 ++ PTP_PEROUT_DUTY_CYCLE = 0x2 ++ PTP_PEROUT_ONE_SHOT = 0x1 ++ PTP_PEROUT_PHASE = 0x4 ++ PTP_PEROUT_V1_VALID_FLAGS = 0x0 ++ PTP_PEROUT_VALID_FLAGS = 0x7 ++ PTP_PIN_GETFUNC = 0xc0603d06 ++ PTP_PIN_GETFUNC2 = 0xc0603d0f ++ PTP_RISING_EDGE = 0x2 ++ PTP_STRICT_FLAGS = 0x8 ++ PTP_SYS_OFFSET_EXTENDED = 0xc4c03d09 ++ PTP_SYS_OFFSET_EXTENDED2 = 0xc4c03d12 ++ PTP_SYS_OFFSET_PRECISE = 0xc0403d08 ++ PTP_SYS_OFFSET_PRECISE2 = 0xc0403d11 + PTRACE_ATTACH = 0x10 + PTRACE_CONT = 0x7 + PTRACE_DETACH = 0x11 +@@ -2933,15 +2968,17 @@ const ( + RUSAGE_SELF = 0x0 + RUSAGE_THREAD = 0x1 + RWF_APPEND = 0x10 ++ RWF_ATOMIC = 0x40 + RWF_DSYNC = 0x2 + RWF_HIPRI = 0x1 + RWF_NOAPPEND = 0x20 + RWF_NOWAIT = 0x8 +- RWF_SUPPORTED = 0x3f ++ RWF_SUPPORTED = 0x7f + RWF_SYNC = 0x4 + RWF_WRITE_LIFE_NOT_SET = 0x0 + SCHED_BATCH = 0x3 + SCHED_DEADLINE = 0x6 ++ SCHED_EXT = 0x7 + SCHED_FIFO = 0x1 + SCHED_FLAG_ALL = 0x7f + SCHED_FLAG_DL_OVERRUN = 0x4 +@@ -3210,6 +3247,7 @@ const ( + STATX_ATTR_MOUNT_ROOT = 0x2000 + STATX_ATTR_NODUMP = 0x40 + STATX_ATTR_VERITY = 0x100000 ++ STATX_ATTR_WRITE_ATOMIC = 0x400000 + STATX_BASIC_STATS = 0x7ff + STATX_BLOCKS = 0x400 + STATX_BTIME = 0x800 +@@ -3226,6 +3264,7 @@ const ( + STATX_SUBVOL = 0x8000 + STATX_TYPE = 0x1 + STATX_UID = 0x8 ++ STATX_WRITE_ATOMIC = 0x10000 + STATX__RESERVED = 0x80000000 + SYNC_FILE_RANGE_WAIT_AFTER = 0x4 + SYNC_FILE_RANGE_WAIT_BEFORE = 0x1 +@@ -3624,6 +3663,7 @@ const ( + XDP_UMEM_PGOFF_COMPLETION_RING = 0x180000000 + XDP_UMEM_PGOFF_FILL_RING = 0x100000000 + XDP_UMEM_REG = 0x4 ++ XDP_UMEM_TX_METADATA_LEN = 0x4 + XDP_UMEM_TX_SW_CSUM = 0x2 + XDP_UMEM_UNALIGNED_CHUNK_FLAG = 0x1 + XDP_USE_NEED_WAKEUP = 0x8 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_386.go b/vendor/golang.org/x/sys/unix/zerrors_linux_386.go +index 684a516..c0d45e3 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_386.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_386.go +@@ -109,6 +109,7 @@ const ( + HIDIOCGRAWINFO = 0x80084803 + HIDIOCGRDESC = 0x90044802 + HIDIOCGRDESCSIZE = 0x80044801 ++ HIDIOCREVOKE = 0x4004480d + HUPCL = 0x400 + ICANON = 0x2 + IEXTEN = 0x8000 +@@ -153,9 +154,14 @@ const ( + NFDBITS = 0x20 + NLDLY = 0x100 + NOFLSH = 0x80 ++ NS_GET_MNTNS_ID = 0x8008b705 + NS_GET_NSTYPE = 0xb703 + NS_GET_OWNER_UID = 0xb704 + NS_GET_PARENT = 0xb702 ++ NS_GET_PID_FROM_PIDNS = 0x8004b706 ++ NS_GET_PID_IN_PIDNS = 0x8004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x8004b707 ++ NS_GET_TGID_IN_PIDNS = 0x8004b709 + NS_GET_USERNS = 0xb701 + OLCUC = 0x2 + ONLCR = 0x4 +@@ -232,6 +238,20 @@ const ( + PPPIOCUNBRIDGECHAN = 0x7434 + PPPIOCXFERUNIT = 0x744e + PR_SET_PTRACER_ANY = 0xffffffff ++ PTP_CLOCK_GETCAPS = 0x80503d01 ++ PTP_CLOCK_GETCAPS2 = 0x80503d0a ++ PTP_ENABLE_PPS = 0x40043d04 ++ PTP_ENABLE_PPS2 = 0x40043d0d ++ PTP_EXTTS_REQUEST = 0x40103d02 ++ PTP_EXTTS_REQUEST2 = 0x40103d0b ++ PTP_MASK_CLEAR_ALL = 0x3d13 ++ PTP_MASK_EN_SINGLE = 0x40043d14 ++ PTP_PEROUT_REQUEST = 0x40383d03 ++ PTP_PEROUT_REQUEST2 = 0x40383d0c ++ PTP_PIN_SETFUNC = 0x40603d07 ++ PTP_PIN_SETFUNC2 = 0x40603d10 ++ PTP_SYS_OFFSET = 0x43403d05 ++ PTP_SYS_OFFSET2 = 0x43403d0e + PTRACE_GETFPREGS = 0xe + PTRACE_GETFPXREGS = 0x12 + PTRACE_GET_THREAD_AREA = 0x19 +@@ -278,6 +298,8 @@ const ( + RTC_WIE_ON = 0x700f + RTC_WKALM_RD = 0x80287010 + RTC_WKALM_SET = 0x4028700f ++ SCM_DEVMEM_DMABUF = 0x4f ++ SCM_DEVMEM_LINEAR = 0x4e + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a +@@ -316,6 +338,9 @@ const ( + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DEVMEM_DMABUF = 0x4f ++ SO_DEVMEM_DONTNEED = 0x50 ++ SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x27 + SO_DONTROUTE = 0x5 + SO_ERROR = 0x4 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go +index 61d74b5..c731d24 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go +@@ -109,6 +109,7 @@ const ( + HIDIOCGRAWINFO = 0x80084803 + HIDIOCGRDESC = 0x90044802 + HIDIOCGRDESCSIZE = 0x80044801 ++ HIDIOCREVOKE = 0x4004480d + HUPCL = 0x400 + ICANON = 0x2 + IEXTEN = 0x8000 +@@ -153,9 +154,14 @@ const ( + NFDBITS = 0x40 + NLDLY = 0x100 + NOFLSH = 0x80 ++ NS_GET_MNTNS_ID = 0x8008b705 + NS_GET_NSTYPE = 0xb703 + NS_GET_OWNER_UID = 0xb704 + NS_GET_PARENT = 0xb702 ++ NS_GET_PID_FROM_PIDNS = 0x8004b706 ++ NS_GET_PID_IN_PIDNS = 0x8004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x8004b707 ++ NS_GET_TGID_IN_PIDNS = 0x8004b709 + NS_GET_USERNS = 0xb701 + OLCUC = 0x2 + ONLCR = 0x4 +@@ -232,6 +238,20 @@ const ( + PPPIOCUNBRIDGECHAN = 0x7434 + PPPIOCXFERUNIT = 0x744e + PR_SET_PTRACER_ANY = 0xffffffffffffffff ++ PTP_CLOCK_GETCAPS = 0x80503d01 ++ PTP_CLOCK_GETCAPS2 = 0x80503d0a ++ PTP_ENABLE_PPS = 0x40043d04 ++ PTP_ENABLE_PPS2 = 0x40043d0d ++ PTP_EXTTS_REQUEST = 0x40103d02 ++ PTP_EXTTS_REQUEST2 = 0x40103d0b ++ PTP_MASK_CLEAR_ALL = 0x3d13 ++ PTP_MASK_EN_SINGLE = 0x40043d14 ++ PTP_PEROUT_REQUEST = 0x40383d03 ++ PTP_PEROUT_REQUEST2 = 0x40383d0c ++ PTP_PIN_SETFUNC = 0x40603d07 ++ PTP_PIN_SETFUNC2 = 0x40603d10 ++ PTP_SYS_OFFSET = 0x43403d05 ++ PTP_SYS_OFFSET2 = 0x43403d0e + PTRACE_ARCH_PRCTL = 0x1e + PTRACE_GETFPREGS = 0xe + PTRACE_GETFPXREGS = 0x12 +@@ -279,6 +299,8 @@ const ( + RTC_WIE_ON = 0x700f + RTC_WKALM_RD = 0x80287010 + RTC_WKALM_SET = 0x4028700f ++ SCM_DEVMEM_DMABUF = 0x4f ++ SCM_DEVMEM_LINEAR = 0x4e + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a +@@ -317,6 +339,9 @@ const ( + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DEVMEM_DMABUF = 0x4f ++ SO_DEVMEM_DONTNEED = 0x50 ++ SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x27 + SO_DONTROUTE = 0x5 + SO_ERROR = 0x4 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go b/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go +index a28c9e3..680018a 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go +@@ -108,6 +108,7 @@ const ( + HIDIOCGRAWINFO = 0x80084803 + HIDIOCGRDESC = 0x90044802 + HIDIOCGRDESCSIZE = 0x80044801 ++ HIDIOCREVOKE = 0x4004480d + HUPCL = 0x400 + ICANON = 0x2 + IEXTEN = 0x8000 +@@ -150,9 +151,14 @@ const ( + NFDBITS = 0x20 + NLDLY = 0x100 + NOFLSH = 0x80 ++ NS_GET_MNTNS_ID = 0x8008b705 + NS_GET_NSTYPE = 0xb703 + NS_GET_OWNER_UID = 0xb704 + NS_GET_PARENT = 0xb702 ++ NS_GET_PID_FROM_PIDNS = 0x8004b706 ++ NS_GET_PID_IN_PIDNS = 0x8004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x8004b707 ++ NS_GET_TGID_IN_PIDNS = 0x8004b709 + NS_GET_USERNS = 0xb701 + OLCUC = 0x2 + ONLCR = 0x4 +@@ -229,6 +235,20 @@ const ( + PPPIOCUNBRIDGECHAN = 0x7434 + PPPIOCXFERUNIT = 0x744e + PR_SET_PTRACER_ANY = 0xffffffff ++ PTP_CLOCK_GETCAPS = 0x80503d01 ++ PTP_CLOCK_GETCAPS2 = 0x80503d0a ++ PTP_ENABLE_PPS = 0x40043d04 ++ PTP_ENABLE_PPS2 = 0x40043d0d ++ PTP_EXTTS_REQUEST = 0x40103d02 ++ PTP_EXTTS_REQUEST2 = 0x40103d0b ++ PTP_MASK_CLEAR_ALL = 0x3d13 ++ PTP_MASK_EN_SINGLE = 0x40043d14 ++ PTP_PEROUT_REQUEST = 0x40383d03 ++ PTP_PEROUT_REQUEST2 = 0x40383d0c ++ PTP_PIN_SETFUNC = 0x40603d07 ++ PTP_PIN_SETFUNC2 = 0x40603d10 ++ PTP_SYS_OFFSET = 0x43403d05 ++ PTP_SYS_OFFSET2 = 0x43403d0e + PTRACE_GETCRUNCHREGS = 0x19 + PTRACE_GETFDPIC = 0x1f + PTRACE_GETFDPIC_EXEC = 0x0 +@@ -284,6 +304,8 @@ const ( + RTC_WIE_ON = 0x700f + RTC_WKALM_RD = 0x80287010 + RTC_WKALM_SET = 0x4028700f ++ SCM_DEVMEM_DMABUF = 0x4f ++ SCM_DEVMEM_LINEAR = 0x4e + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a +@@ -322,6 +344,9 @@ const ( + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DEVMEM_DMABUF = 0x4f ++ SO_DEVMEM_DONTNEED = 0x50 ++ SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x27 + SO_DONTROUTE = 0x5 + SO_ERROR = 0x4 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go +index ab5d1fe..a63909f 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go +@@ -112,6 +112,7 @@ const ( + HIDIOCGRAWINFO = 0x80084803 + HIDIOCGRDESC = 0x90044802 + HIDIOCGRDESCSIZE = 0x80044801 ++ HIDIOCREVOKE = 0x4004480d + HUPCL = 0x400 + ICANON = 0x2 + IEXTEN = 0x8000 +@@ -154,9 +155,14 @@ const ( + NFDBITS = 0x40 + NLDLY = 0x100 + NOFLSH = 0x80 ++ NS_GET_MNTNS_ID = 0x8008b705 + NS_GET_NSTYPE = 0xb703 + NS_GET_OWNER_UID = 0xb704 + NS_GET_PARENT = 0xb702 ++ NS_GET_PID_FROM_PIDNS = 0x8004b706 ++ NS_GET_PID_IN_PIDNS = 0x8004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x8004b707 ++ NS_GET_TGID_IN_PIDNS = 0x8004b709 + NS_GET_USERNS = 0xb701 + OLCUC = 0x2 + ONLCR = 0x4 +@@ -200,6 +206,7 @@ const ( + PERF_EVENT_IOC_SET_BPF = 0x40042408 + PERF_EVENT_IOC_SET_FILTER = 0x40082406 + PERF_EVENT_IOC_SET_OUTPUT = 0x2405 ++ POE_MAGIC = 0x504f4530 + PPPIOCATTACH = 0x4004743d + PPPIOCATTCHAN = 0x40047438 + PPPIOCBRIDGECHAN = 0x40047435 +@@ -235,6 +242,20 @@ const ( + PROT_BTI = 0x10 + PROT_MTE = 0x20 + PR_SET_PTRACER_ANY = 0xffffffffffffffff ++ PTP_CLOCK_GETCAPS = 0x80503d01 ++ PTP_CLOCK_GETCAPS2 = 0x80503d0a ++ PTP_ENABLE_PPS = 0x40043d04 ++ PTP_ENABLE_PPS2 = 0x40043d0d ++ PTP_EXTTS_REQUEST = 0x40103d02 ++ PTP_EXTTS_REQUEST2 = 0x40103d0b ++ PTP_MASK_CLEAR_ALL = 0x3d13 ++ PTP_MASK_EN_SINGLE = 0x40043d14 ++ PTP_PEROUT_REQUEST = 0x40383d03 ++ PTP_PEROUT_REQUEST2 = 0x40383d0c ++ PTP_PIN_SETFUNC = 0x40603d07 ++ PTP_PIN_SETFUNC2 = 0x40603d10 ++ PTP_SYS_OFFSET = 0x43403d05 ++ PTP_SYS_OFFSET2 = 0x43403d0e + PTRACE_PEEKMTETAGS = 0x21 + PTRACE_POKEMTETAGS = 0x22 + PTRACE_SYSEMU = 0x1f +@@ -275,6 +296,8 @@ const ( + RTC_WIE_ON = 0x700f + RTC_WKALM_RD = 0x80287010 + RTC_WKALM_SET = 0x4028700f ++ SCM_DEVMEM_DMABUF = 0x4f ++ SCM_DEVMEM_LINEAR = 0x4e + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a +@@ -313,6 +336,9 @@ const ( + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DEVMEM_DMABUF = 0x4f ++ SO_DEVMEM_DONTNEED = 0x50 ++ SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x27 + SO_DONTROUTE = 0x5 + SO_ERROR = 0x4 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go +index c523090..9b0a257 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go +@@ -109,6 +109,7 @@ const ( + HIDIOCGRAWINFO = 0x80084803 + HIDIOCGRDESC = 0x90044802 + HIDIOCGRDESCSIZE = 0x80044801 ++ HIDIOCREVOKE = 0x4004480d + HUPCL = 0x400 + ICANON = 0x2 + IEXTEN = 0x8000 +@@ -154,9 +155,14 @@ const ( + NFDBITS = 0x40 + NLDLY = 0x100 + NOFLSH = 0x80 ++ NS_GET_MNTNS_ID = 0x8008b705 + NS_GET_NSTYPE = 0xb703 + NS_GET_OWNER_UID = 0xb704 + NS_GET_PARENT = 0xb702 ++ NS_GET_PID_FROM_PIDNS = 0x8004b706 ++ NS_GET_PID_IN_PIDNS = 0x8004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x8004b707 ++ NS_GET_TGID_IN_PIDNS = 0x8004b709 + NS_GET_USERNS = 0xb701 + OLCUC = 0x2 + ONLCR = 0x4 +@@ -233,6 +239,20 @@ const ( + PPPIOCUNBRIDGECHAN = 0x7434 + PPPIOCXFERUNIT = 0x744e + PR_SET_PTRACER_ANY = 0xffffffffffffffff ++ PTP_CLOCK_GETCAPS = 0x80503d01 ++ PTP_CLOCK_GETCAPS2 = 0x80503d0a ++ PTP_ENABLE_PPS = 0x40043d04 ++ PTP_ENABLE_PPS2 = 0x40043d0d ++ PTP_EXTTS_REQUEST = 0x40103d02 ++ PTP_EXTTS_REQUEST2 = 0x40103d0b ++ PTP_MASK_CLEAR_ALL = 0x3d13 ++ PTP_MASK_EN_SINGLE = 0x40043d14 ++ PTP_PEROUT_REQUEST = 0x40383d03 ++ PTP_PEROUT_REQUEST2 = 0x40383d0c ++ PTP_PIN_SETFUNC = 0x40603d07 ++ PTP_PIN_SETFUNC2 = 0x40603d10 ++ PTP_SYS_OFFSET = 0x43403d05 ++ PTP_SYS_OFFSET2 = 0x43403d0e + PTRACE_SYSEMU = 0x1f + PTRACE_SYSEMU_SINGLESTEP = 0x20 + RLIMIT_AS = 0x9 +@@ -271,6 +291,8 @@ const ( + RTC_WIE_ON = 0x700f + RTC_WKALM_RD = 0x80287010 + RTC_WKALM_SET = 0x4028700f ++ SCM_DEVMEM_DMABUF = 0x4f ++ SCM_DEVMEM_LINEAR = 0x4e + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a +@@ -309,6 +331,9 @@ const ( + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DEVMEM_DMABUF = 0x4f ++ SO_DEVMEM_DONTNEED = 0x50 ++ SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x27 + SO_DONTROUTE = 0x5 + SO_ERROR = 0x4 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go b/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go +index 01e6ea7..958e6e0 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go +@@ -108,6 +108,7 @@ const ( + HIDIOCGRAWINFO = 0x40084803 + HIDIOCGRDESC = 0x50044802 + HIDIOCGRDESCSIZE = 0x40044801 ++ HIDIOCREVOKE = 0x8004480d + HUPCL = 0x400 + ICANON = 0x2 + IEXTEN = 0x100 +@@ -150,9 +151,14 @@ const ( + NFDBITS = 0x20 + NLDLY = 0x100 + NOFLSH = 0x80 ++ NS_GET_MNTNS_ID = 0x4008b705 + NS_GET_NSTYPE = 0x2000b703 + NS_GET_OWNER_UID = 0x2000b704 + NS_GET_PARENT = 0x2000b702 ++ NS_GET_PID_FROM_PIDNS = 0x4004b706 ++ NS_GET_PID_IN_PIDNS = 0x4004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x4004b707 ++ NS_GET_TGID_IN_PIDNS = 0x4004b709 + NS_GET_USERNS = 0x2000b701 + OLCUC = 0x2 + ONLCR = 0x4 +@@ -229,6 +235,20 @@ const ( + PPPIOCUNBRIDGECHAN = 0x20007434 + PPPIOCXFERUNIT = 0x2000744e + PR_SET_PTRACER_ANY = 0xffffffff ++ PTP_CLOCK_GETCAPS = 0x40503d01 ++ PTP_CLOCK_GETCAPS2 = 0x40503d0a ++ PTP_ENABLE_PPS = 0x80043d04 ++ PTP_ENABLE_PPS2 = 0x80043d0d ++ PTP_EXTTS_REQUEST = 0x80103d02 ++ PTP_EXTTS_REQUEST2 = 0x80103d0b ++ PTP_MASK_CLEAR_ALL = 0x20003d13 ++ PTP_MASK_EN_SINGLE = 0x80043d14 ++ PTP_PEROUT_REQUEST = 0x80383d03 ++ PTP_PEROUT_REQUEST2 = 0x80383d0c ++ PTP_PIN_SETFUNC = 0x80603d07 ++ PTP_PIN_SETFUNC2 = 0x80603d10 ++ PTP_SYS_OFFSET = 0x83403d05 ++ PTP_SYS_OFFSET2 = 0x83403d0e + PTRACE_GETFPREGS = 0xe + PTRACE_GET_THREAD_AREA = 0x19 + PTRACE_GET_THREAD_AREA_3264 = 0xc4 +@@ -277,6 +297,8 @@ const ( + RTC_WIE_ON = 0x2000700f + RTC_WKALM_RD = 0x40287010 + RTC_WKALM_SET = 0x8028700f ++ SCM_DEVMEM_DMABUF = 0x4f ++ SCM_DEVMEM_LINEAR = 0x4e + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a +@@ -315,6 +337,9 @@ const ( + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DEVMEM_DMABUF = 0x4f ++ SO_DEVMEM_DONTNEED = 0x50 ++ SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x1029 + SO_DONTROUTE = 0x10 + SO_ERROR = 0x1007 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go +index 7aa610b..50c7f25 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go +@@ -108,6 +108,7 @@ const ( + HIDIOCGRAWINFO = 0x40084803 + HIDIOCGRDESC = 0x50044802 + HIDIOCGRDESCSIZE = 0x40044801 ++ HIDIOCREVOKE = 0x8004480d + HUPCL = 0x400 + ICANON = 0x2 + IEXTEN = 0x100 +@@ -150,9 +151,14 @@ const ( + NFDBITS = 0x40 + NLDLY = 0x100 + NOFLSH = 0x80 ++ NS_GET_MNTNS_ID = 0x4008b705 + NS_GET_NSTYPE = 0x2000b703 + NS_GET_OWNER_UID = 0x2000b704 + NS_GET_PARENT = 0x2000b702 ++ NS_GET_PID_FROM_PIDNS = 0x4004b706 ++ NS_GET_PID_IN_PIDNS = 0x4004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x4004b707 ++ NS_GET_TGID_IN_PIDNS = 0x4004b709 + NS_GET_USERNS = 0x2000b701 + OLCUC = 0x2 + ONLCR = 0x4 +@@ -229,6 +235,20 @@ const ( + PPPIOCUNBRIDGECHAN = 0x20007434 + PPPIOCXFERUNIT = 0x2000744e + PR_SET_PTRACER_ANY = 0xffffffffffffffff ++ PTP_CLOCK_GETCAPS = 0x40503d01 ++ PTP_CLOCK_GETCAPS2 = 0x40503d0a ++ PTP_ENABLE_PPS = 0x80043d04 ++ PTP_ENABLE_PPS2 = 0x80043d0d ++ PTP_EXTTS_REQUEST = 0x80103d02 ++ PTP_EXTTS_REQUEST2 = 0x80103d0b ++ PTP_MASK_CLEAR_ALL = 0x20003d13 ++ PTP_MASK_EN_SINGLE = 0x80043d14 ++ PTP_PEROUT_REQUEST = 0x80383d03 ++ PTP_PEROUT_REQUEST2 = 0x80383d0c ++ PTP_PIN_SETFUNC = 0x80603d07 ++ PTP_PIN_SETFUNC2 = 0x80603d10 ++ PTP_SYS_OFFSET = 0x83403d05 ++ PTP_SYS_OFFSET2 = 0x83403d0e + PTRACE_GETFPREGS = 0xe + PTRACE_GET_THREAD_AREA = 0x19 + PTRACE_GET_THREAD_AREA_3264 = 0xc4 +@@ -277,6 +297,8 @@ const ( + RTC_WIE_ON = 0x2000700f + RTC_WKALM_RD = 0x40287010 + RTC_WKALM_SET = 0x8028700f ++ SCM_DEVMEM_DMABUF = 0x4f ++ SCM_DEVMEM_LINEAR = 0x4e + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a +@@ -315,6 +337,9 @@ const ( + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DEVMEM_DMABUF = 0x4f ++ SO_DEVMEM_DONTNEED = 0x50 ++ SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x1029 + SO_DONTROUTE = 0x10 + SO_ERROR = 0x1007 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go b/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go +index 92af771..ced21d6 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go +@@ -108,6 +108,7 @@ const ( + HIDIOCGRAWINFO = 0x40084803 + HIDIOCGRDESC = 0x50044802 + HIDIOCGRDESCSIZE = 0x40044801 ++ HIDIOCREVOKE = 0x8004480d + HUPCL = 0x400 + ICANON = 0x2 + IEXTEN = 0x100 +@@ -150,9 +151,14 @@ const ( + NFDBITS = 0x40 + NLDLY = 0x100 + NOFLSH = 0x80 ++ NS_GET_MNTNS_ID = 0x4008b705 + NS_GET_NSTYPE = 0x2000b703 + NS_GET_OWNER_UID = 0x2000b704 + NS_GET_PARENT = 0x2000b702 ++ NS_GET_PID_FROM_PIDNS = 0x4004b706 ++ NS_GET_PID_IN_PIDNS = 0x4004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x4004b707 ++ NS_GET_TGID_IN_PIDNS = 0x4004b709 + NS_GET_USERNS = 0x2000b701 + OLCUC = 0x2 + ONLCR = 0x4 +@@ -229,6 +235,20 @@ const ( + PPPIOCUNBRIDGECHAN = 0x20007434 + PPPIOCXFERUNIT = 0x2000744e + PR_SET_PTRACER_ANY = 0xffffffffffffffff ++ PTP_CLOCK_GETCAPS = 0x40503d01 ++ PTP_CLOCK_GETCAPS2 = 0x40503d0a ++ PTP_ENABLE_PPS = 0x80043d04 ++ PTP_ENABLE_PPS2 = 0x80043d0d ++ PTP_EXTTS_REQUEST = 0x80103d02 ++ PTP_EXTTS_REQUEST2 = 0x80103d0b ++ PTP_MASK_CLEAR_ALL = 0x20003d13 ++ PTP_MASK_EN_SINGLE = 0x80043d14 ++ PTP_PEROUT_REQUEST = 0x80383d03 ++ PTP_PEROUT_REQUEST2 = 0x80383d0c ++ PTP_PIN_SETFUNC = 0x80603d07 ++ PTP_PIN_SETFUNC2 = 0x80603d10 ++ PTP_SYS_OFFSET = 0x83403d05 ++ PTP_SYS_OFFSET2 = 0x83403d0e + PTRACE_GETFPREGS = 0xe + PTRACE_GET_THREAD_AREA = 0x19 + PTRACE_GET_THREAD_AREA_3264 = 0xc4 +@@ -277,6 +297,8 @@ const ( + RTC_WIE_ON = 0x2000700f + RTC_WKALM_RD = 0x40287010 + RTC_WKALM_SET = 0x8028700f ++ SCM_DEVMEM_DMABUF = 0x4f ++ SCM_DEVMEM_LINEAR = 0x4e + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a +@@ -315,6 +337,9 @@ const ( + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DEVMEM_DMABUF = 0x4f ++ SO_DEVMEM_DONTNEED = 0x50 ++ SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x1029 + SO_DONTROUTE = 0x10 + SO_ERROR = 0x1007 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go b/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go +index b27ef5e..226c044 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go +@@ -108,6 +108,7 @@ const ( + HIDIOCGRAWINFO = 0x40084803 + HIDIOCGRDESC = 0x50044802 + HIDIOCGRDESCSIZE = 0x40044801 ++ HIDIOCREVOKE = 0x8004480d + HUPCL = 0x400 + ICANON = 0x2 + IEXTEN = 0x100 +@@ -150,9 +151,14 @@ const ( + NFDBITS = 0x20 + NLDLY = 0x100 + NOFLSH = 0x80 ++ NS_GET_MNTNS_ID = 0x4008b705 + NS_GET_NSTYPE = 0x2000b703 + NS_GET_OWNER_UID = 0x2000b704 + NS_GET_PARENT = 0x2000b702 ++ NS_GET_PID_FROM_PIDNS = 0x4004b706 ++ NS_GET_PID_IN_PIDNS = 0x4004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x4004b707 ++ NS_GET_TGID_IN_PIDNS = 0x4004b709 + NS_GET_USERNS = 0x2000b701 + OLCUC = 0x2 + ONLCR = 0x4 +@@ -229,6 +235,20 @@ const ( + PPPIOCUNBRIDGECHAN = 0x20007434 + PPPIOCXFERUNIT = 0x2000744e + PR_SET_PTRACER_ANY = 0xffffffff ++ PTP_CLOCK_GETCAPS = 0x40503d01 ++ PTP_CLOCK_GETCAPS2 = 0x40503d0a ++ PTP_ENABLE_PPS = 0x80043d04 ++ PTP_ENABLE_PPS2 = 0x80043d0d ++ PTP_EXTTS_REQUEST = 0x80103d02 ++ PTP_EXTTS_REQUEST2 = 0x80103d0b ++ PTP_MASK_CLEAR_ALL = 0x20003d13 ++ PTP_MASK_EN_SINGLE = 0x80043d14 ++ PTP_PEROUT_REQUEST = 0x80383d03 ++ PTP_PEROUT_REQUEST2 = 0x80383d0c ++ PTP_PIN_SETFUNC = 0x80603d07 ++ PTP_PIN_SETFUNC2 = 0x80603d10 ++ PTP_SYS_OFFSET = 0x83403d05 ++ PTP_SYS_OFFSET2 = 0x83403d0e + PTRACE_GETFPREGS = 0xe + PTRACE_GET_THREAD_AREA = 0x19 + PTRACE_GET_THREAD_AREA_3264 = 0xc4 +@@ -277,6 +297,8 @@ const ( + RTC_WIE_ON = 0x2000700f + RTC_WKALM_RD = 0x40287010 + RTC_WKALM_SET = 0x8028700f ++ SCM_DEVMEM_DMABUF = 0x4f ++ SCM_DEVMEM_LINEAR = 0x4e + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a +@@ -315,6 +337,9 @@ const ( + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DEVMEM_DMABUF = 0x4f ++ SO_DEVMEM_DONTNEED = 0x50 ++ SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x1029 + SO_DONTROUTE = 0x10 + SO_ERROR = 0x1007 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go +index 237a2ce..3122737 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go +@@ -108,6 +108,7 @@ const ( + HIDIOCGRAWINFO = 0x40084803 + HIDIOCGRDESC = 0x50044802 + HIDIOCGRDESCSIZE = 0x40044801 ++ HIDIOCREVOKE = 0x8004480d + HUPCL = 0x4000 + ICANON = 0x100 + IEXTEN = 0x400 +@@ -152,9 +153,14 @@ const ( + NL3 = 0x300 + NLDLY = 0x300 + NOFLSH = 0x80000000 ++ NS_GET_MNTNS_ID = 0x4008b705 + NS_GET_NSTYPE = 0x2000b703 + NS_GET_OWNER_UID = 0x2000b704 + NS_GET_PARENT = 0x2000b702 ++ NS_GET_PID_FROM_PIDNS = 0x4004b706 ++ NS_GET_PID_IN_PIDNS = 0x4004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x4004b707 ++ NS_GET_TGID_IN_PIDNS = 0x4004b709 + NS_GET_USERNS = 0x2000b701 + OLCUC = 0x4 + ONLCR = 0x2 +@@ -232,6 +238,20 @@ const ( + PPPIOCXFERUNIT = 0x2000744e + PROT_SAO = 0x10 + PR_SET_PTRACER_ANY = 0xffffffff ++ PTP_CLOCK_GETCAPS = 0x40503d01 ++ PTP_CLOCK_GETCAPS2 = 0x40503d0a ++ PTP_ENABLE_PPS = 0x80043d04 ++ PTP_ENABLE_PPS2 = 0x80043d0d ++ PTP_EXTTS_REQUEST = 0x80103d02 ++ PTP_EXTTS_REQUEST2 = 0x80103d0b ++ PTP_MASK_CLEAR_ALL = 0x20003d13 ++ PTP_MASK_EN_SINGLE = 0x80043d14 ++ PTP_PEROUT_REQUEST = 0x80383d03 ++ PTP_PEROUT_REQUEST2 = 0x80383d0c ++ PTP_PIN_SETFUNC = 0x80603d07 ++ PTP_PIN_SETFUNC2 = 0x80603d10 ++ PTP_SYS_OFFSET = 0x83403d05 ++ PTP_SYS_OFFSET2 = 0x83403d0e + PTRACE_GETEVRREGS = 0x14 + PTRACE_GETFPREGS = 0xe + PTRACE_GETREGS64 = 0x16 +@@ -332,6 +352,8 @@ const ( + RTC_WIE_ON = 0x2000700f + RTC_WKALM_RD = 0x40287010 + RTC_WKALM_SET = 0x8028700f ++ SCM_DEVMEM_DMABUF = 0x4f ++ SCM_DEVMEM_LINEAR = 0x4e + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a +@@ -370,6 +392,9 @@ const ( + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DEVMEM_DMABUF = 0x4f ++ SO_DEVMEM_DONTNEED = 0x50 ++ SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x27 + SO_DONTROUTE = 0x5 + SO_ERROR = 0x4 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go +index 4a5c555..eb5d346 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go +@@ -108,6 +108,7 @@ const ( + HIDIOCGRAWINFO = 0x40084803 + HIDIOCGRDESC = 0x50044802 + HIDIOCGRDESCSIZE = 0x40044801 ++ HIDIOCREVOKE = 0x8004480d + HUPCL = 0x4000 + ICANON = 0x100 + IEXTEN = 0x400 +@@ -152,9 +153,14 @@ const ( + NL3 = 0x300 + NLDLY = 0x300 + NOFLSH = 0x80000000 ++ NS_GET_MNTNS_ID = 0x4008b705 + NS_GET_NSTYPE = 0x2000b703 + NS_GET_OWNER_UID = 0x2000b704 + NS_GET_PARENT = 0x2000b702 ++ NS_GET_PID_FROM_PIDNS = 0x4004b706 ++ NS_GET_PID_IN_PIDNS = 0x4004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x4004b707 ++ NS_GET_TGID_IN_PIDNS = 0x4004b709 + NS_GET_USERNS = 0x2000b701 + OLCUC = 0x4 + ONLCR = 0x2 +@@ -232,6 +238,20 @@ const ( + PPPIOCXFERUNIT = 0x2000744e + PROT_SAO = 0x10 + PR_SET_PTRACER_ANY = 0xffffffffffffffff ++ PTP_CLOCK_GETCAPS = 0x40503d01 ++ PTP_CLOCK_GETCAPS2 = 0x40503d0a ++ PTP_ENABLE_PPS = 0x80043d04 ++ PTP_ENABLE_PPS2 = 0x80043d0d ++ PTP_EXTTS_REQUEST = 0x80103d02 ++ PTP_EXTTS_REQUEST2 = 0x80103d0b ++ PTP_MASK_CLEAR_ALL = 0x20003d13 ++ PTP_MASK_EN_SINGLE = 0x80043d14 ++ PTP_PEROUT_REQUEST = 0x80383d03 ++ PTP_PEROUT_REQUEST2 = 0x80383d0c ++ PTP_PIN_SETFUNC = 0x80603d07 ++ PTP_PIN_SETFUNC2 = 0x80603d10 ++ PTP_SYS_OFFSET = 0x83403d05 ++ PTP_SYS_OFFSET2 = 0x83403d0e + PTRACE_GETEVRREGS = 0x14 + PTRACE_GETFPREGS = 0xe + PTRACE_GETREGS64 = 0x16 +@@ -336,6 +356,8 @@ const ( + RTC_WIE_ON = 0x2000700f + RTC_WKALM_RD = 0x40287010 + RTC_WKALM_SET = 0x8028700f ++ SCM_DEVMEM_DMABUF = 0x4f ++ SCM_DEVMEM_LINEAR = 0x4e + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a +@@ -374,6 +396,9 @@ const ( + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DEVMEM_DMABUF = 0x4f ++ SO_DEVMEM_DONTNEED = 0x50 ++ SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x27 + SO_DONTROUTE = 0x5 + SO_ERROR = 0x4 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go +index a02fb49..e921ebc 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go +@@ -108,6 +108,7 @@ const ( + HIDIOCGRAWINFO = 0x40084803 + HIDIOCGRDESC = 0x50044802 + HIDIOCGRDESCSIZE = 0x40044801 ++ HIDIOCREVOKE = 0x8004480d + HUPCL = 0x4000 + ICANON = 0x100 + IEXTEN = 0x400 +@@ -152,9 +153,14 @@ const ( + NL3 = 0x300 + NLDLY = 0x300 + NOFLSH = 0x80000000 ++ NS_GET_MNTNS_ID = 0x4008b705 + NS_GET_NSTYPE = 0x2000b703 + NS_GET_OWNER_UID = 0x2000b704 + NS_GET_PARENT = 0x2000b702 ++ NS_GET_PID_FROM_PIDNS = 0x4004b706 ++ NS_GET_PID_IN_PIDNS = 0x4004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x4004b707 ++ NS_GET_TGID_IN_PIDNS = 0x4004b709 + NS_GET_USERNS = 0x2000b701 + OLCUC = 0x4 + ONLCR = 0x2 +@@ -232,6 +238,20 @@ const ( + PPPIOCXFERUNIT = 0x2000744e + PROT_SAO = 0x10 + PR_SET_PTRACER_ANY = 0xffffffffffffffff ++ PTP_CLOCK_GETCAPS = 0x40503d01 ++ PTP_CLOCK_GETCAPS2 = 0x40503d0a ++ PTP_ENABLE_PPS = 0x80043d04 ++ PTP_ENABLE_PPS2 = 0x80043d0d ++ PTP_EXTTS_REQUEST = 0x80103d02 ++ PTP_EXTTS_REQUEST2 = 0x80103d0b ++ PTP_MASK_CLEAR_ALL = 0x20003d13 ++ PTP_MASK_EN_SINGLE = 0x80043d14 ++ PTP_PEROUT_REQUEST = 0x80383d03 ++ PTP_PEROUT_REQUEST2 = 0x80383d0c ++ PTP_PIN_SETFUNC = 0x80603d07 ++ PTP_PIN_SETFUNC2 = 0x80603d10 ++ PTP_SYS_OFFSET = 0x83403d05 ++ PTP_SYS_OFFSET2 = 0x83403d0e + PTRACE_GETEVRREGS = 0x14 + PTRACE_GETFPREGS = 0xe + PTRACE_GETREGS64 = 0x16 +@@ -336,6 +356,8 @@ const ( + RTC_WIE_ON = 0x2000700f + RTC_WKALM_RD = 0x40287010 + RTC_WKALM_SET = 0x8028700f ++ SCM_DEVMEM_DMABUF = 0x4f ++ SCM_DEVMEM_LINEAR = 0x4e + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a +@@ -374,6 +396,9 @@ const ( + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DEVMEM_DMABUF = 0x4f ++ SO_DEVMEM_DONTNEED = 0x50 ++ SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x27 + SO_DONTROUTE = 0x5 + SO_ERROR = 0x4 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go +index e26a7c6..38ba81c 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go +@@ -108,6 +108,7 @@ const ( + HIDIOCGRAWINFO = 0x80084803 + HIDIOCGRDESC = 0x90044802 + HIDIOCGRDESCSIZE = 0x80044801 ++ HIDIOCREVOKE = 0x4004480d + HUPCL = 0x400 + ICANON = 0x2 + IEXTEN = 0x8000 +@@ -150,9 +151,14 @@ const ( + NFDBITS = 0x40 + NLDLY = 0x100 + NOFLSH = 0x80 ++ NS_GET_MNTNS_ID = 0x8008b705 + NS_GET_NSTYPE = 0xb703 + NS_GET_OWNER_UID = 0xb704 + NS_GET_PARENT = 0xb702 ++ NS_GET_PID_FROM_PIDNS = 0x8004b706 ++ NS_GET_PID_IN_PIDNS = 0x8004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x8004b707 ++ NS_GET_TGID_IN_PIDNS = 0x8004b709 + NS_GET_USERNS = 0xb701 + OLCUC = 0x2 + ONLCR = 0x4 +@@ -229,6 +235,20 @@ const ( + PPPIOCUNBRIDGECHAN = 0x7434 + PPPIOCXFERUNIT = 0x744e + PR_SET_PTRACER_ANY = 0xffffffffffffffff ++ PTP_CLOCK_GETCAPS = 0x80503d01 ++ PTP_CLOCK_GETCAPS2 = 0x80503d0a ++ PTP_ENABLE_PPS = 0x40043d04 ++ PTP_ENABLE_PPS2 = 0x40043d0d ++ PTP_EXTTS_REQUEST = 0x40103d02 ++ PTP_EXTTS_REQUEST2 = 0x40103d0b ++ PTP_MASK_CLEAR_ALL = 0x3d13 ++ PTP_MASK_EN_SINGLE = 0x40043d14 ++ PTP_PEROUT_REQUEST = 0x40383d03 ++ PTP_PEROUT_REQUEST2 = 0x40383d0c ++ PTP_PIN_SETFUNC = 0x40603d07 ++ PTP_PIN_SETFUNC2 = 0x40603d10 ++ PTP_SYS_OFFSET = 0x43403d05 ++ PTP_SYS_OFFSET2 = 0x43403d0e + PTRACE_GETFDPIC = 0x21 + PTRACE_GETFDPIC_EXEC = 0x0 + PTRACE_GETFDPIC_INTERP = 0x1 +@@ -268,6 +288,8 @@ const ( + RTC_WIE_ON = 0x700f + RTC_WKALM_RD = 0x80287010 + RTC_WKALM_SET = 0x4028700f ++ SCM_DEVMEM_DMABUF = 0x4f ++ SCM_DEVMEM_LINEAR = 0x4e + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a +@@ -306,6 +328,9 @@ const ( + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DEVMEM_DMABUF = 0x4f ++ SO_DEVMEM_DONTNEED = 0x50 ++ SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x27 + SO_DONTROUTE = 0x5 + SO_ERROR = 0x4 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go b/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go +index c48f7c2..71f0400 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go +@@ -108,6 +108,7 @@ const ( + HIDIOCGRAWINFO = 0x80084803 + HIDIOCGRDESC = 0x90044802 + HIDIOCGRDESCSIZE = 0x80044801 ++ HIDIOCREVOKE = 0x4004480d + HUPCL = 0x400 + ICANON = 0x2 + IEXTEN = 0x8000 +@@ -150,9 +151,14 @@ const ( + NFDBITS = 0x40 + NLDLY = 0x100 + NOFLSH = 0x80 ++ NS_GET_MNTNS_ID = 0x8008b705 + NS_GET_NSTYPE = 0xb703 + NS_GET_OWNER_UID = 0xb704 + NS_GET_PARENT = 0xb702 ++ NS_GET_PID_FROM_PIDNS = 0x8004b706 ++ NS_GET_PID_IN_PIDNS = 0x8004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x8004b707 ++ NS_GET_TGID_IN_PIDNS = 0x8004b709 + NS_GET_USERNS = 0xb701 + OLCUC = 0x2 + ONLCR = 0x4 +@@ -229,6 +235,20 @@ const ( + PPPIOCUNBRIDGECHAN = 0x7434 + PPPIOCXFERUNIT = 0x744e + PR_SET_PTRACER_ANY = 0xffffffffffffffff ++ PTP_CLOCK_GETCAPS = 0x80503d01 ++ PTP_CLOCK_GETCAPS2 = 0x80503d0a ++ PTP_ENABLE_PPS = 0x40043d04 ++ PTP_ENABLE_PPS2 = 0x40043d0d ++ PTP_EXTTS_REQUEST = 0x40103d02 ++ PTP_EXTTS_REQUEST2 = 0x40103d0b ++ PTP_MASK_CLEAR_ALL = 0x3d13 ++ PTP_MASK_EN_SINGLE = 0x40043d14 ++ PTP_PEROUT_REQUEST = 0x40383d03 ++ PTP_PEROUT_REQUEST2 = 0x40383d0c ++ PTP_PIN_SETFUNC = 0x40603d07 ++ PTP_PIN_SETFUNC2 = 0x40603d10 ++ PTP_SYS_OFFSET = 0x43403d05 ++ PTP_SYS_OFFSET2 = 0x43403d0e + PTRACE_DISABLE_TE = 0x5010 + PTRACE_ENABLE_TE = 0x5009 + PTRACE_GET_LAST_BREAK = 0x5006 +@@ -340,6 +360,8 @@ const ( + RTC_WIE_ON = 0x700f + RTC_WKALM_RD = 0x80287010 + RTC_WKALM_SET = 0x4028700f ++ SCM_DEVMEM_DMABUF = 0x4f ++ SCM_DEVMEM_LINEAR = 0x4e + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a +@@ -378,6 +400,9 @@ const ( + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DEVMEM_DMABUF = 0x4f ++ SO_DEVMEM_DONTNEED = 0x50 ++ SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x27 + SO_DONTROUTE = 0x5 + SO_ERROR = 0x4 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go +index ad4b9aa..c44a313 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go +@@ -112,6 +112,7 @@ const ( + HIDIOCGRAWINFO = 0x40084803 + HIDIOCGRDESC = 0x50044802 + HIDIOCGRDESCSIZE = 0x40044801 ++ HIDIOCREVOKE = 0x8004480d + HUPCL = 0x400 + ICANON = 0x2 + IEXTEN = 0x8000 +@@ -155,9 +156,14 @@ const ( + NFDBITS = 0x40 + NLDLY = 0x100 + NOFLSH = 0x80 ++ NS_GET_MNTNS_ID = 0x4008b705 + NS_GET_NSTYPE = 0x2000b703 + NS_GET_OWNER_UID = 0x2000b704 + NS_GET_PARENT = 0x2000b702 ++ NS_GET_PID_FROM_PIDNS = 0x4004b706 ++ NS_GET_PID_IN_PIDNS = 0x4004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x4004b707 ++ NS_GET_TGID_IN_PIDNS = 0x4004b709 + NS_GET_USERNS = 0x2000b701 + OLCUC = 0x2 + ONLCR = 0x4 +@@ -234,6 +240,20 @@ const ( + PPPIOCUNBRIDGECHAN = 0x20007434 + PPPIOCXFERUNIT = 0x2000744e + PR_SET_PTRACER_ANY = 0xffffffffffffffff ++ PTP_CLOCK_GETCAPS = 0x40503d01 ++ PTP_CLOCK_GETCAPS2 = 0x40503d0a ++ PTP_ENABLE_PPS = 0x80043d04 ++ PTP_ENABLE_PPS2 = 0x80043d0d ++ PTP_EXTTS_REQUEST = 0x80103d02 ++ PTP_EXTTS_REQUEST2 = 0x80103d0b ++ PTP_MASK_CLEAR_ALL = 0x20003d13 ++ PTP_MASK_EN_SINGLE = 0x80043d14 ++ PTP_PEROUT_REQUEST = 0x80383d03 ++ PTP_PEROUT_REQUEST2 = 0x80383d0c ++ PTP_PIN_SETFUNC = 0x80603d07 ++ PTP_PIN_SETFUNC2 = 0x80603d10 ++ PTP_SYS_OFFSET = 0x83403d05 ++ PTP_SYS_OFFSET2 = 0x83403d0e + PTRACE_GETFPAREGS = 0x14 + PTRACE_GETFPREGS = 0xe + PTRACE_GETFPREGS64 = 0x19 +@@ -331,6 +351,8 @@ const ( + RTC_WIE_ON = 0x2000700f + RTC_WKALM_RD = 0x40287010 + RTC_WKALM_SET = 0x8028700f ++ SCM_DEVMEM_DMABUF = 0x58 ++ SCM_DEVMEM_LINEAR = 0x57 + SCM_TIMESTAMPING = 0x23 + SCM_TIMESTAMPING_OPT_STATS = 0x38 + SCM_TIMESTAMPING_PKTINFO = 0x3c +@@ -417,6 +439,9 @@ const ( + SO_CNX_ADVICE = 0x37 + SO_COOKIE = 0x3b + SO_DETACH_REUSEPORT_BPF = 0x47 ++ SO_DEVMEM_DMABUF = 0x58 ++ SO_DEVMEM_DONTNEED = 0x59 ++ SO_DEVMEM_LINEAR = 0x57 + SO_DOMAIN = 0x1029 + SO_DONTROUTE = 0x10 + SO_ERROR = 0x1007 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_zos_s390x.go b/vendor/golang.org/x/sys/unix/zerrors_zos_s390x.go +index da08b2a..1ec2b14 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_zos_s390x.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_zos_s390x.go +@@ -581,6 +581,8 @@ const ( + AT_EMPTY_PATH = 0x1000 + AT_REMOVEDIR = 0x200 + RENAME_NOREPLACE = 1 << 0 ++ ST_RDONLY = 1 ++ ST_NOSUID = 2 + ) + + const ( +diff --git a/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go b/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go +index b622533..24b346e 100644 +--- a/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go ++++ b/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go +@@ -841,6 +841,26 @@ var libc_pthread_fchdir_np_trampoline_addr uintptr + + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + ++func connectx(fd int, endpoints *SaEndpoints, associd SaeAssocID, flags uint32, iov []Iovec, n *uintptr, connid *SaeConnID) (err error) { ++ var _p0 unsafe.Pointer ++ if len(iov) > 0 { ++ _p0 = unsafe.Pointer(&iov[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ _, _, e1 := syscall_syscall9(libc_connectx_trampoline_addr, uintptr(fd), uintptr(unsafe.Pointer(endpoints)), uintptr(associd), uintptr(flags), uintptr(_p0), uintptr(len(iov)), uintptr(unsafe.Pointer(n)), uintptr(unsafe.Pointer(connid)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++var libc_connectx_trampoline_addr uintptr ++ ++//go:cgo_import_dynamic libc_connectx connectx "/usr/lib/libSystem.B.dylib" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ + func sendfile(infd int, outfd int, offset int64, len *int64, hdtr unsafe.Pointer, flags int) (err error) { + _, _, e1 := syscall_syscall6(libc_sendfile_trampoline_addr, uintptr(infd), uintptr(outfd), uintptr(offset), uintptr(unsafe.Pointer(len)), uintptr(hdtr), uintptr(flags)) + if e1 != 0 { +diff --git a/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.s b/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.s +index cfe6646..ebd2131 100644 +--- a/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.s ++++ b/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.s +@@ -248,6 +248,11 @@ TEXT libc_pthread_fchdir_np_trampoline<>(SB),NOSPLIT,$0-0 + GLOBL ·libc_pthread_fchdir_np_trampoline_addr(SB), RODATA, $8 + DATA ·libc_pthread_fchdir_np_trampoline_addr(SB)/8, $libc_pthread_fchdir_np_trampoline<>(SB) + ++TEXT libc_connectx_trampoline<>(SB),NOSPLIT,$0-0 ++ JMP libc_connectx(SB) ++GLOBL ·libc_connectx_trampoline_addr(SB), RODATA, $8 ++DATA ·libc_connectx_trampoline_addr(SB)/8, $libc_connectx_trampoline<>(SB) ++ + TEXT libc_sendfile_trampoline<>(SB),NOSPLIT,$0-0 + JMP libc_sendfile(SB) + GLOBL ·libc_sendfile_trampoline_addr(SB), RODATA, $8 +diff --git a/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go b/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go +index 13f624f..824b9c2 100644 +--- a/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go ++++ b/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go +@@ -841,6 +841,26 @@ var libc_pthread_fchdir_np_trampoline_addr uintptr + + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + ++func connectx(fd int, endpoints *SaEndpoints, associd SaeAssocID, flags uint32, iov []Iovec, n *uintptr, connid *SaeConnID) (err error) { ++ var _p0 unsafe.Pointer ++ if len(iov) > 0 { ++ _p0 = unsafe.Pointer(&iov[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ _, _, e1 := syscall_syscall9(libc_connectx_trampoline_addr, uintptr(fd), uintptr(unsafe.Pointer(endpoints)), uintptr(associd), uintptr(flags), uintptr(_p0), uintptr(len(iov)), uintptr(unsafe.Pointer(n)), uintptr(unsafe.Pointer(connid)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++var libc_connectx_trampoline_addr uintptr ++ ++//go:cgo_import_dynamic libc_connectx connectx "/usr/lib/libSystem.B.dylib" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ + func sendfile(infd int, outfd int, offset int64, len *int64, hdtr unsafe.Pointer, flags int) (err error) { + _, _, e1 := syscall_syscall6(libc_sendfile_trampoline_addr, uintptr(infd), uintptr(outfd), uintptr(offset), uintptr(unsafe.Pointer(len)), uintptr(hdtr), uintptr(flags)) + if e1 != 0 { +diff --git a/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.s b/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.s +index fe222b7..4f178a2 100644 +--- a/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.s ++++ b/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.s +@@ -248,6 +248,11 @@ TEXT libc_pthread_fchdir_np_trampoline<>(SB),NOSPLIT,$0-0 + GLOBL ·libc_pthread_fchdir_np_trampoline_addr(SB), RODATA, $8 + DATA ·libc_pthread_fchdir_np_trampoline_addr(SB)/8, $libc_pthread_fchdir_np_trampoline<>(SB) + ++TEXT libc_connectx_trampoline<>(SB),NOSPLIT,$0-0 ++ JMP libc_connectx(SB) ++GLOBL ·libc_connectx_trampoline_addr(SB), RODATA, $8 ++DATA ·libc_connectx_trampoline_addr(SB)/8, $libc_connectx_trampoline<>(SB) ++ + TEXT libc_sendfile_trampoline<>(SB),NOSPLIT,$0-0 + JMP libc_sendfile(SB) + GLOBL ·libc_sendfile_trampoline_addr(SB), RODATA, $8 +diff --git a/vendor/golang.org/x/sys/unix/zsyscall_linux.go b/vendor/golang.org/x/sys/unix/zsyscall_linux.go +index 1bc1a5a..5cc1e8e 100644 +--- a/vendor/golang.org/x/sys/unix/zsyscall_linux.go ++++ b/vendor/golang.org/x/sys/unix/zsyscall_linux.go +@@ -592,6 +592,16 @@ func ClockGettime(clockid int32, time *Timespec) (err error) { + + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + ++func ClockSettime(clockid int32, time *Timespec) (err error) { ++ _, _, e1 := Syscall(SYS_CLOCK_SETTIME, uintptr(clockid), uintptr(unsafe.Pointer(time)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ + func ClockNanosleep(clockid int32, flags int, request *Timespec, remain *Timespec) (err error) { + _, _, e1 := Syscall6(SYS_CLOCK_NANOSLEEP, uintptr(clockid), uintptr(flags), uintptr(unsafe.Pointer(request)), uintptr(unsafe.Pointer(remain)), 0, 0) + if e1 != 0 { +@@ -971,23 +981,6 @@ func Getpriority(which int, who int) (prio int, err error) { + + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +-func Getrandom(buf []byte, flags int) (n int, err error) { +- var _p0 unsafe.Pointer +- if len(buf) > 0 { +- _p0 = unsafe.Pointer(&buf[0]) +- } else { +- _p0 = unsafe.Pointer(&_zero) +- } +- r0, _, e1 := Syscall(SYS_GETRANDOM, uintptr(_p0), uintptr(len(buf)), uintptr(flags)) +- n = int(r0) +- if e1 != 0 { +- err = errnoErr(e1) +- } +- return +-} +- +-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT +- + func Getrusage(who int, rusage *Rusage) (err error) { + _, _, e1 := RawSyscall(SYS_GETRUSAGE, uintptr(who), uintptr(unsafe.Pointer(rusage)), 0) + if e1 != 0 { +diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go +index d3e38f6..f485dbf 100644 +--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go ++++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go +@@ -341,6 +341,7 @@ const ( + SYS_STATX = 332 + SYS_IO_PGETEVENTS = 333 + SYS_RSEQ = 334 ++ SYS_URETPROBE = 335 + SYS_PIDFD_SEND_SIGNAL = 424 + SYS_IO_URING_SETUP = 425 + SYS_IO_URING_ENTER = 426 +diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go +index 6c778c2..1893e2f 100644 +--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go ++++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go +@@ -85,7 +85,7 @@ const ( + SYS_SPLICE = 76 + SYS_TEE = 77 + SYS_READLINKAT = 78 +- SYS_FSTATAT = 79 ++ SYS_NEWFSTATAT = 79 + SYS_FSTAT = 80 + SYS_SYNC = 81 + SYS_FSYNC = 82 +diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_loong64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_loong64.go +index 37281cf..16a4017 100644 +--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_loong64.go ++++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_loong64.go +@@ -84,6 +84,8 @@ const ( + SYS_SPLICE = 76 + SYS_TEE = 77 + SYS_READLINKAT = 78 ++ SYS_NEWFSTATAT = 79 ++ SYS_FSTAT = 80 + SYS_SYNC = 81 + SYS_FSYNC = 82 + SYS_FDATASYNC = 83 +diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go +index 9889f6a..a5459e7 100644 +--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go ++++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go +@@ -84,7 +84,7 @@ const ( + SYS_SPLICE = 76 + SYS_TEE = 77 + SYS_READLINKAT = 78 +- SYS_FSTATAT = 79 ++ SYS_NEWFSTATAT = 79 + SYS_FSTAT = 80 + SYS_SYNC = 81 + SYS_FSYNC = 82 +diff --git a/vendor/golang.org/x/sys/unix/ztypes_darwin_amd64.go b/vendor/golang.org/x/sys/unix/ztypes_darwin_amd64.go +index 091d107..17c53bd 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_darwin_amd64.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_darwin_amd64.go +@@ -306,6 +306,19 @@ type XVSockPgen struct { + + type _Socklen uint32 + ++type SaeAssocID uint32 ++ ++type SaeConnID uint32 ++ ++type SaEndpoints struct { ++ Srcif uint32 ++ Srcaddr *RawSockaddr ++ Srcaddrlen uint32 ++ Dstaddr *RawSockaddr ++ Dstaddrlen uint32 ++ _ [4]byte ++} ++ + type Xucred struct { + Version uint32 + Uid uint32 +@@ -449,11 +462,14 @@ type FdSet struct { + + const ( + SizeofIfMsghdr = 0x70 ++ SizeofIfMsghdr2 = 0xa0 + SizeofIfData = 0x60 ++ SizeofIfData64 = 0x80 + SizeofIfaMsghdr = 0x14 + SizeofIfmaMsghdr = 0x10 + SizeofIfmaMsghdr2 = 0x14 + SizeofRtMsghdr = 0x5c ++ SizeofRtMsghdr2 = 0x5c + SizeofRtMetrics = 0x38 + ) + +@@ -467,6 +483,20 @@ type IfMsghdr struct { + Data IfData + } + ++type IfMsghdr2 struct { ++ Msglen uint16 ++ Version uint8 ++ Type uint8 ++ Addrs int32 ++ Flags int32 ++ Index uint16 ++ Snd_len int32 ++ Snd_maxlen int32 ++ Snd_drops int32 ++ Timer int32 ++ Data IfData64 ++} ++ + type IfData struct { + Type uint8 + Typelen uint8 +@@ -499,6 +529,34 @@ type IfData struct { + Reserved2 uint32 + } + ++type IfData64 struct { ++ Type uint8 ++ Typelen uint8 ++ Physical uint8 ++ Addrlen uint8 ++ Hdrlen uint8 ++ Recvquota uint8 ++ Xmitquota uint8 ++ Unused1 uint8 ++ Mtu uint32 ++ Metric uint32 ++ Baudrate uint64 ++ Ipackets uint64 ++ Ierrors uint64 ++ Opackets uint64 ++ Oerrors uint64 ++ Collisions uint64 ++ Ibytes uint64 ++ Obytes uint64 ++ Imcasts uint64 ++ Omcasts uint64 ++ Iqdrops uint64 ++ Noproto uint64 ++ Recvtiming uint32 ++ Xmittiming uint32 ++ Lastchange Timeval32 ++} ++ + type IfaMsghdr struct { + Msglen uint16 + Version uint8 +@@ -544,6 +602,21 @@ type RtMsghdr struct { + Rmx RtMetrics + } + ++type RtMsghdr2 struct { ++ Msglen uint16 ++ Version uint8 ++ Type uint8 ++ Index uint16 ++ Flags int32 ++ Addrs int32 ++ Refcnt int32 ++ Parentflags int32 ++ Reserved int32 ++ Use int32 ++ Inits uint32 ++ Rmx RtMetrics ++} ++ + type RtMetrics struct { + Locks uint32 + Mtu uint32 +diff --git a/vendor/golang.org/x/sys/unix/ztypes_darwin_arm64.go b/vendor/golang.org/x/sys/unix/ztypes_darwin_arm64.go +index 28ff4ef..2392226 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_darwin_arm64.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_darwin_arm64.go +@@ -306,6 +306,19 @@ type XVSockPgen struct { + + type _Socklen uint32 + ++type SaeAssocID uint32 ++ ++type SaeConnID uint32 ++ ++type SaEndpoints struct { ++ Srcif uint32 ++ Srcaddr *RawSockaddr ++ Srcaddrlen uint32 ++ Dstaddr *RawSockaddr ++ Dstaddrlen uint32 ++ _ [4]byte ++} ++ + type Xucred struct { + Version uint32 + Uid uint32 +@@ -449,11 +462,14 @@ type FdSet struct { + + const ( + SizeofIfMsghdr = 0x70 ++ SizeofIfMsghdr2 = 0xa0 + SizeofIfData = 0x60 ++ SizeofIfData64 = 0x80 + SizeofIfaMsghdr = 0x14 + SizeofIfmaMsghdr = 0x10 + SizeofIfmaMsghdr2 = 0x14 + SizeofRtMsghdr = 0x5c ++ SizeofRtMsghdr2 = 0x5c + SizeofRtMetrics = 0x38 + ) + +@@ -467,6 +483,20 @@ type IfMsghdr struct { + Data IfData + } + ++type IfMsghdr2 struct { ++ Msglen uint16 ++ Version uint8 ++ Type uint8 ++ Addrs int32 ++ Flags int32 ++ Index uint16 ++ Snd_len int32 ++ Snd_maxlen int32 ++ Snd_drops int32 ++ Timer int32 ++ Data IfData64 ++} ++ + type IfData struct { + Type uint8 + Typelen uint8 +@@ -499,6 +529,34 @@ type IfData struct { + Reserved2 uint32 + } + ++type IfData64 struct { ++ Type uint8 ++ Typelen uint8 ++ Physical uint8 ++ Addrlen uint8 ++ Hdrlen uint8 ++ Recvquota uint8 ++ Xmitquota uint8 ++ Unused1 uint8 ++ Mtu uint32 ++ Metric uint32 ++ Baudrate uint64 ++ Ipackets uint64 ++ Ierrors uint64 ++ Opackets uint64 ++ Oerrors uint64 ++ Collisions uint64 ++ Ibytes uint64 ++ Obytes uint64 ++ Imcasts uint64 ++ Omcasts uint64 ++ Iqdrops uint64 ++ Noproto uint64 ++ Recvtiming uint32 ++ Xmittiming uint32 ++ Lastchange Timeval32 ++} ++ + type IfaMsghdr struct { + Msglen uint16 + Version uint8 +@@ -544,6 +602,21 @@ type RtMsghdr struct { + Rmx RtMetrics + } + ++type RtMsghdr2 struct { ++ Msglen uint16 ++ Version uint8 ++ Type uint8 ++ Index uint16 ++ Flags int32 ++ Addrs int32 ++ Refcnt int32 ++ Parentflags int32 ++ Reserved int32 ++ Use int32 ++ Inits uint32 ++ Rmx RtMetrics ++} ++ + type RtMetrics struct { + Locks uint32 + Mtu uint32 +diff --git a/vendor/golang.org/x/sys/unix/ztypes_freebsd_386.go b/vendor/golang.org/x/sys/unix/ztypes_freebsd_386.go +index 6cbd094..51e13eb 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_freebsd_386.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_freebsd_386.go +@@ -625,6 +625,7 @@ const ( + POLLRDNORM = 0x40 + POLLWRBAND = 0x100 + POLLWRNORM = 0x4 ++ POLLRDHUP = 0x4000 + ) + + type CapRights struct { +diff --git a/vendor/golang.org/x/sys/unix/ztypes_freebsd_amd64.go b/vendor/golang.org/x/sys/unix/ztypes_freebsd_amd64.go +index 7c03b6e..d002d8e 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_freebsd_amd64.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_freebsd_amd64.go +@@ -630,6 +630,7 @@ const ( + POLLRDNORM = 0x40 + POLLWRBAND = 0x100 + POLLWRNORM = 0x4 ++ POLLRDHUP = 0x4000 + ) + + type CapRights struct { +diff --git a/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm.go b/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm.go +index 422107e..3f863d8 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm.go +@@ -616,6 +616,7 @@ const ( + POLLRDNORM = 0x40 + POLLWRBAND = 0x100 + POLLWRNORM = 0x4 ++ POLLRDHUP = 0x4000 + ) + + type CapRights struct { +diff --git a/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm64.go b/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm64.go +index 505a12a..61c7293 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm64.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm64.go +@@ -610,6 +610,7 @@ const ( + POLLRDNORM = 0x40 + POLLWRBAND = 0x100 + POLLWRNORM = 0x4 ++ POLLRDHUP = 0x4000 + ) + + type CapRights struct { +diff --git a/vendor/golang.org/x/sys/unix/ztypes_freebsd_riscv64.go b/vendor/golang.org/x/sys/unix/ztypes_freebsd_riscv64.go +index cc986c7..b5d1741 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_freebsd_riscv64.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_freebsd_riscv64.go +@@ -612,6 +612,7 @@ const ( + POLLRDNORM = 0x40 + POLLWRBAND = 0x100 + POLLWRNORM = 0x4 ++ POLLRDHUP = 0x4000 + ) + + type CapRights struct { +diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux.go b/vendor/golang.org/x/sys/unix/ztypes_linux.go +index b102b95..5537148 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_linux.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_linux.go +@@ -87,31 +87,35 @@ type StatxTimestamp struct { + } + + type Statx_t struct { +- Mask uint32 +- Blksize uint32 +- Attributes uint64 +- Nlink uint32 +- Uid uint32 +- Gid uint32 +- Mode uint16 +- _ [1]uint16 +- Ino uint64 +- Size uint64 +- Blocks uint64 +- Attributes_mask uint64 +- Atime StatxTimestamp +- Btime StatxTimestamp +- Ctime StatxTimestamp +- Mtime StatxTimestamp +- Rdev_major uint32 +- Rdev_minor uint32 +- Dev_major uint32 +- Dev_minor uint32 +- Mnt_id uint64 +- Dio_mem_align uint32 +- Dio_offset_align uint32 +- Subvol uint64 +- _ [11]uint64 ++ Mask uint32 ++ Blksize uint32 ++ Attributes uint64 ++ Nlink uint32 ++ Uid uint32 ++ Gid uint32 ++ Mode uint16 ++ _ [1]uint16 ++ Ino uint64 ++ Size uint64 ++ Blocks uint64 ++ Attributes_mask uint64 ++ Atime StatxTimestamp ++ Btime StatxTimestamp ++ Ctime StatxTimestamp ++ Mtime StatxTimestamp ++ Rdev_major uint32 ++ Rdev_minor uint32 ++ Dev_major uint32 ++ Dev_minor uint32 ++ Mnt_id uint64 ++ Dio_mem_align uint32 ++ Dio_offset_align uint32 ++ Subvol uint64 ++ Atomic_write_unit_min uint32 ++ Atomic_write_unit_max uint32 ++ Atomic_write_segments_max uint32 ++ _ [1]uint32 ++ _ [9]uint64 + } + + type Fsid struct { +@@ -516,6 +520,29 @@ type TCPInfo struct { + Total_rto_time uint32 + } + ++type TCPVegasInfo struct { ++ Enabled uint32 ++ Rttcnt uint32 ++ Rtt uint32 ++ Minrtt uint32 ++} ++ ++type TCPDCTCPInfo struct { ++ Enabled uint16 ++ Ce_state uint16 ++ Alpha uint32 ++ Ab_ecn uint32 ++ Ab_tot uint32 ++} ++ ++type TCPBBRInfo struct { ++ Bw_lo uint32 ++ Bw_hi uint32 ++ Min_rtt uint32 ++ Pacing_gain uint32 ++ Cwnd_gain uint32 ++} ++ + type CanFilter struct { + Id uint32 + Mask uint32 +@@ -557,6 +584,7 @@ const ( + SizeofICMPv6Filter = 0x20 + SizeofUcred = 0xc + SizeofTCPInfo = 0xf8 ++ SizeofTCPCCInfo = 0x14 + SizeofCanFilter = 0x8 + SizeofTCPRepairOpt = 0x8 + ) +@@ -1724,12 +1752,6 @@ const ( + IFLA_IPVLAN_UNSPEC = 0x0 + IFLA_IPVLAN_MODE = 0x1 + IFLA_IPVLAN_FLAGS = 0x2 +- NETKIT_NEXT = -0x1 +- NETKIT_PASS = 0x0 +- NETKIT_DROP = 0x2 +- NETKIT_REDIRECT = 0x7 +- NETKIT_L2 = 0x0 +- NETKIT_L3 = 0x1 + IFLA_NETKIT_UNSPEC = 0x0 + IFLA_NETKIT_PEER_INFO = 0x1 + IFLA_NETKIT_PRIMARY = 0x2 +@@ -1768,6 +1790,7 @@ const ( + IFLA_VXLAN_DF = 0x1d + IFLA_VXLAN_VNIFILTER = 0x1e + IFLA_VXLAN_LOCALBYPASS = 0x1f ++ IFLA_VXLAN_LABEL_POLICY = 0x20 + IFLA_GENEVE_UNSPEC = 0x0 + IFLA_GENEVE_ID = 0x1 + IFLA_GENEVE_REMOTE = 0x2 +@@ -1797,6 +1820,8 @@ const ( + IFLA_GTP_ROLE = 0x4 + IFLA_GTP_CREATE_SOCKETS = 0x5 + IFLA_GTP_RESTART_COUNT = 0x6 ++ IFLA_GTP_LOCAL = 0x7 ++ IFLA_GTP_LOCAL6 = 0x8 + IFLA_BOND_UNSPEC = 0x0 + IFLA_BOND_MODE = 0x1 + IFLA_BOND_ACTIVE_SLAVE = 0x2 +@@ -1829,6 +1854,7 @@ const ( + IFLA_BOND_AD_LACP_ACTIVE = 0x1d + IFLA_BOND_MISSED_MAX = 0x1e + IFLA_BOND_NS_IP6_TARGET = 0x1f ++ IFLA_BOND_COUPLED_CONTROL = 0x20 + IFLA_BOND_AD_INFO_UNSPEC = 0x0 + IFLA_BOND_AD_INFO_AGGREGATOR = 0x1 + IFLA_BOND_AD_INFO_NUM_PORTS = 0x2 +@@ -1897,6 +1923,7 @@ const ( + IFLA_HSR_SEQ_NR = 0x5 + IFLA_HSR_VERSION = 0x6 + IFLA_HSR_PROTOCOL = 0x7 ++ IFLA_HSR_INTERLINK = 0x8 + IFLA_STATS_UNSPEC = 0x0 + IFLA_STATS_LINK_64 = 0x1 + IFLA_STATS_LINK_XSTATS = 0x2 +@@ -1949,6 +1976,15 @@ const ( + IFLA_DSA_MASTER = 0x1 + ) + ++const ( ++ NETKIT_NEXT = -0x1 ++ NETKIT_PASS = 0x0 ++ NETKIT_DROP = 0x2 ++ NETKIT_REDIRECT = 0x7 ++ NETKIT_L2 = 0x0 ++ NETKIT_L3 = 0x1 ++) ++ + const ( + NF_INET_PRE_ROUTING = 0x0 + NF_INET_LOCAL_IN = 0x1 +@@ -2486,7 +2522,7 @@ type XDPMmapOffsets struct { + type XDPUmemReg struct { + Addr uint64 + Len uint64 +- Chunk_size uint32 ++ Size uint32 + Headroom uint32 + Flags uint32 + Tx_metadata_len uint32 +@@ -2558,8 +2594,8 @@ const ( + SOF_TIMESTAMPING_BIND_PHC = 0x8000 + SOF_TIMESTAMPING_OPT_ID_TCP = 0x10000 + +- SOF_TIMESTAMPING_LAST = 0x10000 +- SOF_TIMESTAMPING_MASK = 0x1ffff ++ SOF_TIMESTAMPING_LAST = 0x20000 ++ SOF_TIMESTAMPING_MASK = 0x3ffff + + SCM_TSTAMP_SND = 0x0 + SCM_TSTAMP_SCHED = 0x1 +@@ -3505,7 +3541,7 @@ type Nhmsg struct { + type NexthopGrp struct { + Id uint32 + Weight uint8 +- Resvd1 uint8 ++ High uint8 + Resvd2 uint16 + } + +@@ -3766,7 +3802,7 @@ const ( + ETHTOOL_MSG_PSE_GET = 0x24 + ETHTOOL_MSG_PSE_SET = 0x25 + ETHTOOL_MSG_RSS_GET = 0x26 +- ETHTOOL_MSG_USER_MAX = 0x2b ++ ETHTOOL_MSG_USER_MAX = 0x2d + ETHTOOL_MSG_KERNEL_NONE = 0x0 + ETHTOOL_MSG_STRSET_GET_REPLY = 0x1 + ETHTOOL_MSG_LINKINFO_GET_REPLY = 0x2 +@@ -3806,12 +3842,15 @@ const ( + ETHTOOL_MSG_MODULE_NTF = 0x24 + ETHTOOL_MSG_PSE_GET_REPLY = 0x25 + ETHTOOL_MSG_RSS_GET_REPLY = 0x26 +- ETHTOOL_MSG_KERNEL_MAX = 0x2b ++ ETHTOOL_MSG_KERNEL_MAX = 0x2e ++ ETHTOOL_FLAG_COMPACT_BITSETS = 0x1 ++ ETHTOOL_FLAG_OMIT_REPLY = 0x2 ++ ETHTOOL_FLAG_STATS = 0x4 + ETHTOOL_A_HEADER_UNSPEC = 0x0 + ETHTOOL_A_HEADER_DEV_INDEX = 0x1 + ETHTOOL_A_HEADER_DEV_NAME = 0x2 + ETHTOOL_A_HEADER_FLAGS = 0x3 +- ETHTOOL_A_HEADER_MAX = 0x3 ++ ETHTOOL_A_HEADER_MAX = 0x4 + ETHTOOL_A_BITSET_BIT_UNSPEC = 0x0 + ETHTOOL_A_BITSET_BIT_INDEX = 0x1 + ETHTOOL_A_BITSET_BIT_NAME = 0x2 +@@ -3948,7 +3987,7 @@ const ( + ETHTOOL_A_COALESCE_RATE_SAMPLE_INTERVAL = 0x17 + ETHTOOL_A_COALESCE_USE_CQE_MODE_TX = 0x18 + ETHTOOL_A_COALESCE_USE_CQE_MODE_RX = 0x19 +- ETHTOOL_A_COALESCE_MAX = 0x1c ++ ETHTOOL_A_COALESCE_MAX = 0x1e + ETHTOOL_A_PAUSE_UNSPEC = 0x0 + ETHTOOL_A_PAUSE_HEADER = 0x1 + ETHTOOL_A_PAUSE_AUTONEG = 0x2 +@@ -3992,11 +4031,11 @@ const ( + ETHTOOL_A_CABLE_RESULT_UNSPEC = 0x0 + ETHTOOL_A_CABLE_RESULT_PAIR = 0x1 + ETHTOOL_A_CABLE_RESULT_CODE = 0x2 +- ETHTOOL_A_CABLE_RESULT_MAX = 0x2 ++ ETHTOOL_A_CABLE_RESULT_MAX = 0x3 + ETHTOOL_A_CABLE_FAULT_LENGTH_UNSPEC = 0x0 + ETHTOOL_A_CABLE_FAULT_LENGTH_PAIR = 0x1 + ETHTOOL_A_CABLE_FAULT_LENGTH_CM = 0x2 +- ETHTOOL_A_CABLE_FAULT_LENGTH_MAX = 0x2 ++ ETHTOOL_A_CABLE_FAULT_LENGTH_MAX = 0x3 + ETHTOOL_A_CABLE_TEST_NTF_STATUS_UNSPEC = 0x0 + ETHTOOL_A_CABLE_TEST_NTF_STATUS_STARTED = 0x1 + ETHTOOL_A_CABLE_TEST_NTF_STATUS_COMPLETED = 0x2 +@@ -4079,6 +4118,107 @@ type EthtoolDrvinfo struct { + Regdump_len uint32 + } + ++type EthtoolTsInfo struct { ++ Cmd uint32 ++ So_timestamping uint32 ++ Phc_index int32 ++ Tx_types uint32 ++ Tx_reserved [3]uint32 ++ Rx_filters uint32 ++ Rx_reserved [3]uint32 ++} ++ ++type HwTstampConfig struct { ++ Flags int32 ++ Tx_type int32 ++ Rx_filter int32 ++} ++ ++const ( ++ HWTSTAMP_FILTER_NONE = 0x0 ++ HWTSTAMP_FILTER_ALL = 0x1 ++ HWTSTAMP_FILTER_SOME = 0x2 ++ HWTSTAMP_FILTER_PTP_V1_L4_EVENT = 0x3 ++ HWTSTAMP_FILTER_PTP_V2_L4_EVENT = 0x6 ++ HWTSTAMP_FILTER_PTP_V2_L2_EVENT = 0x9 ++ HWTSTAMP_FILTER_PTP_V2_EVENT = 0xc ++) ++ ++const ( ++ HWTSTAMP_TX_OFF = 0x0 ++ HWTSTAMP_TX_ON = 0x1 ++ HWTSTAMP_TX_ONESTEP_SYNC = 0x2 ++) ++ ++type ( ++ PtpClockCaps struct { ++ Max_adj int32 ++ N_alarm int32 ++ N_ext_ts int32 ++ N_per_out int32 ++ Pps int32 ++ N_pins int32 ++ Cross_timestamping int32 ++ Adjust_phase int32 ++ Max_phase_adj int32 ++ Rsv [11]int32 ++ } ++ PtpClockTime struct { ++ Sec int64 ++ Nsec uint32 ++ Reserved uint32 ++ } ++ PtpExttsEvent struct { ++ T PtpClockTime ++ Index uint32 ++ Flags uint32 ++ Rsv [2]uint32 ++ } ++ PtpExttsRequest struct { ++ Index uint32 ++ Flags uint32 ++ Rsv [2]uint32 ++ } ++ PtpPeroutRequest struct { ++ StartOrPhase PtpClockTime ++ Period PtpClockTime ++ Index uint32 ++ Flags uint32 ++ On PtpClockTime ++ } ++ PtpPinDesc struct { ++ Name [64]byte ++ Index uint32 ++ Func uint32 ++ Chan uint32 ++ Rsv [5]uint32 ++ } ++ PtpSysOffset struct { ++ Samples uint32 ++ Rsv [3]uint32 ++ Ts [51]PtpClockTime ++ } ++ PtpSysOffsetExtended struct { ++ Samples uint32 ++ Clockid int32 ++ Rsv [2]uint32 ++ Ts [25][3]PtpClockTime ++ } ++ PtpSysOffsetPrecise struct { ++ Device PtpClockTime ++ Realtime PtpClockTime ++ Monoraw PtpClockTime ++ Rsv [4]uint32 ++ } ++) ++ ++const ( ++ PTP_PF_NONE = 0x0 ++ PTP_PF_EXTTS = 0x1 ++ PTP_PF_PEROUT = 0x2 ++ PTP_PF_PHYSYNC = 0x3 ++) ++ + type ( + HIDRawReportDescriptor struct { + Size uint32 +@@ -4260,6 +4400,7 @@ const ( + type LandlockRulesetAttr struct { + Access_fs uint64 + Access_net uint64 ++ Scoped uint64 + } + + type LandlockPathBeneathAttr struct { +@@ -4606,7 +4747,7 @@ const ( + NL80211_ATTR_MAC_HINT = 0xc8 + NL80211_ATTR_MAC_MASK = 0xd7 + NL80211_ATTR_MAX_AP_ASSOC_STA = 0xca +- NL80211_ATTR_MAX = 0x14a ++ NL80211_ATTR_MAX = 0x14c + NL80211_ATTR_MAX_CRIT_PROT_DURATION = 0xb4 + NL80211_ATTR_MAX_CSA_COUNTERS = 0xce + NL80211_ATTR_MAX_MATCH_SETS = 0x85 +@@ -5210,7 +5351,7 @@ const ( + NL80211_FREQUENCY_ATTR_GO_CONCURRENT = 0xf + NL80211_FREQUENCY_ATTR_INDOOR_ONLY = 0xe + NL80211_FREQUENCY_ATTR_IR_CONCURRENT = 0xf +- NL80211_FREQUENCY_ATTR_MAX = 0x20 ++ NL80211_FREQUENCY_ATTR_MAX = 0x21 + NL80211_FREQUENCY_ATTR_MAX_TX_POWER = 0x6 + NL80211_FREQUENCY_ATTR_NO_10MHZ = 0x11 + NL80211_FREQUENCY_ATTR_NO_160MHZ = 0xc +diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go b/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go +index 15adc04..ad05b51 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go +@@ -727,6 +727,37 @@ const ( + RISCV_HWPROBE_EXT_ZBA = 0x8 + RISCV_HWPROBE_EXT_ZBB = 0x10 + RISCV_HWPROBE_EXT_ZBS = 0x20 ++ RISCV_HWPROBE_EXT_ZICBOZ = 0x40 ++ RISCV_HWPROBE_EXT_ZBC = 0x80 ++ RISCV_HWPROBE_EXT_ZBKB = 0x100 ++ RISCV_HWPROBE_EXT_ZBKC = 0x200 ++ RISCV_HWPROBE_EXT_ZBKX = 0x400 ++ RISCV_HWPROBE_EXT_ZKND = 0x800 ++ RISCV_HWPROBE_EXT_ZKNE = 0x1000 ++ RISCV_HWPROBE_EXT_ZKNH = 0x2000 ++ RISCV_HWPROBE_EXT_ZKSED = 0x4000 ++ RISCV_HWPROBE_EXT_ZKSH = 0x8000 ++ RISCV_HWPROBE_EXT_ZKT = 0x10000 ++ RISCV_HWPROBE_EXT_ZVBB = 0x20000 ++ RISCV_HWPROBE_EXT_ZVBC = 0x40000 ++ RISCV_HWPROBE_EXT_ZVKB = 0x80000 ++ RISCV_HWPROBE_EXT_ZVKG = 0x100000 ++ RISCV_HWPROBE_EXT_ZVKNED = 0x200000 ++ RISCV_HWPROBE_EXT_ZVKNHA = 0x400000 ++ RISCV_HWPROBE_EXT_ZVKNHB = 0x800000 ++ RISCV_HWPROBE_EXT_ZVKSED = 0x1000000 ++ RISCV_HWPROBE_EXT_ZVKSH = 0x2000000 ++ RISCV_HWPROBE_EXT_ZVKT = 0x4000000 ++ RISCV_HWPROBE_EXT_ZFH = 0x8000000 ++ RISCV_HWPROBE_EXT_ZFHMIN = 0x10000000 ++ RISCV_HWPROBE_EXT_ZIHINTNTL = 0x20000000 ++ RISCV_HWPROBE_EXT_ZVFH = 0x40000000 ++ RISCV_HWPROBE_EXT_ZVFHMIN = 0x80000000 ++ RISCV_HWPROBE_EXT_ZFA = 0x100000000 ++ RISCV_HWPROBE_EXT_ZTSO = 0x200000000 ++ RISCV_HWPROBE_EXT_ZACAS = 0x400000000 ++ RISCV_HWPROBE_EXT_ZICOND = 0x800000000 ++ RISCV_HWPROBE_EXT_ZIHINTPAUSE = 0x1000000000 + RISCV_HWPROBE_KEY_CPUPERF_0 = 0x5 + RISCV_HWPROBE_MISALIGNED_UNKNOWN = 0x0 + RISCV_HWPROBE_MISALIGNED_EMULATED = 0x1 +@@ -734,4 +765,6 @@ const ( + RISCV_HWPROBE_MISALIGNED_FAST = 0x3 + RISCV_HWPROBE_MISALIGNED_UNSUPPORTED = 0x4 + RISCV_HWPROBE_MISALIGNED_MASK = 0x7 ++ RISCV_HWPROBE_KEY_ZICBOZ_BLOCK_SIZE = 0x6 ++ RISCV_HWPROBE_WHICH_CPUS = 0x1 + ) +diff --git a/vendor/golang.org/x/sys/unix/ztypes_zos_s390x.go b/vendor/golang.org/x/sys/unix/ztypes_zos_s390x.go +index d9a13af..2e5d5a4 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_zos_s390x.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_zos_s390x.go +@@ -377,6 +377,12 @@ type Flock_t struct { + Pid int32 + } + ++type F_cnvrt struct { ++ Cvtcmd int32 ++ Pccsid int16 ++ Fccsid int16 ++} ++ + type Termios struct { + Cflag uint32 + Iflag uint32 +diff --git a/vendor/golang.org/x/sys/windows/dll_windows.go b/vendor/golang.org/x/sys/windows/dll_windows.go +index 115341f..4e613cf 100644 +--- a/vendor/golang.org/x/sys/windows/dll_windows.go ++++ b/vendor/golang.org/x/sys/windows/dll_windows.go +@@ -65,7 +65,7 @@ func LoadDLL(name string) (dll *DLL, err error) { + return d, nil + } + +-// MustLoadDLL is like LoadDLL but panics if load operation failes. ++// MustLoadDLL is like LoadDLL but panics if load operation fails. + func MustLoadDLL(name string) *DLL { + d, e := LoadDLL(name) + if e != nil { +diff --git a/vendor/golang.org/x/sys/windows/syscall_windows.go b/vendor/golang.org/x/sys/windows/syscall_windows.go +index 1fa34fd..4a32543 100644 +--- a/vendor/golang.org/x/sys/windows/syscall_windows.go ++++ b/vendor/golang.org/x/sys/windows/syscall_windows.go +@@ -168,6 +168,8 @@ func NewCallbackCDecl(fn interface{}) uintptr { + //sys CreateNamedPipe(name *uint16, flags uint32, pipeMode uint32, maxInstances uint32, outSize uint32, inSize uint32, defaultTimeout uint32, sa *SecurityAttributes) (handle Handle, err error) [failretval==InvalidHandle] = CreateNamedPipeW + //sys ConnectNamedPipe(pipe Handle, overlapped *Overlapped) (err error) + //sys DisconnectNamedPipe(pipe Handle) (err error) ++//sys GetNamedPipeClientProcessId(pipe Handle, clientProcessID *uint32) (err error) ++//sys GetNamedPipeServerProcessId(pipe Handle, serverProcessID *uint32) (err error) + //sys GetNamedPipeInfo(pipe Handle, flags *uint32, outSize *uint32, inSize *uint32, maxInstances *uint32) (err error) + //sys GetNamedPipeHandleState(pipe Handle, state *uint32, curInstances *uint32, maxCollectionCount *uint32, collectDataTimeout *uint32, userName *uint16, maxUserNameSize uint32) (err error) = GetNamedPipeHandleStateW + //sys SetNamedPipeHandleState(pipe Handle, state *uint32, maxCollectionCount *uint32, collectDataTimeout *uint32) (err error) = SetNamedPipeHandleState +@@ -313,6 +315,10 @@ func NewCallbackCDecl(fn interface{}) uintptr { + //sys SetConsoleMode(console Handle, mode uint32) (err error) = kernel32.SetConsoleMode + //sys GetConsoleScreenBufferInfo(console Handle, info *ConsoleScreenBufferInfo) (err error) = kernel32.GetConsoleScreenBufferInfo + //sys setConsoleCursorPosition(console Handle, position uint32) (err error) = kernel32.SetConsoleCursorPosition ++//sys GetConsoleCP() (cp uint32, err error) = kernel32.GetConsoleCP ++//sys GetConsoleOutputCP() (cp uint32, err error) = kernel32.GetConsoleOutputCP ++//sys SetConsoleCP(cp uint32) (err error) = kernel32.SetConsoleCP ++//sys SetConsoleOutputCP(cp uint32) (err error) = kernel32.SetConsoleOutputCP + //sys WriteConsole(console Handle, buf *uint16, towrite uint32, written *uint32, reserved *byte) (err error) = kernel32.WriteConsoleW + //sys ReadConsole(console Handle, buf *uint16, toread uint32, read *uint32, inputControl *byte) (err error) = kernel32.ReadConsoleW + //sys resizePseudoConsole(pconsole Handle, size uint32) (hr error) = kernel32.ResizePseudoConsole +@@ -721,20 +727,12 @@ func DurationSinceBoot() time.Duration { + } + + func Ftruncate(fd Handle, length int64) (err error) { +- curoffset, e := Seek(fd, 0, 1) +- if e != nil { +- return e +- } +- defer Seek(fd, curoffset, 0) +- _, e = Seek(fd, length, 0) +- if e != nil { +- return e ++ type _FILE_END_OF_FILE_INFO struct { ++ EndOfFile int64 + } +- e = SetEndOfFile(fd) +- if e != nil { +- return e +- } +- return nil ++ var info _FILE_END_OF_FILE_INFO ++ info.EndOfFile = length ++ return SetFileInformationByHandle(fd, FileEndOfFileInfo, (*byte)(unsafe.Pointer(&info)), uint32(unsafe.Sizeof(info))) + } + + func Gettimeofday(tv *Timeval) (err error) { +@@ -890,6 +888,11 @@ const socket_error = uintptr(^uint32(0)) + //sys GetACP() (acp uint32) = kernel32.GetACP + //sys MultiByteToWideChar(codePage uint32, dwFlags uint32, str *byte, nstr int32, wchar *uint16, nwchar int32) (nwrite int32, err error) = kernel32.MultiByteToWideChar + //sys getBestInterfaceEx(sockaddr unsafe.Pointer, pdwBestIfIndex *uint32) (errcode error) = iphlpapi.GetBestInterfaceEx ++//sys GetIfEntry2Ex(level uint32, row *MibIfRow2) (errcode error) = iphlpapi.GetIfEntry2Ex ++//sys GetUnicastIpAddressEntry(row *MibUnicastIpAddressRow) (errcode error) = iphlpapi.GetUnicastIpAddressEntry ++//sys NotifyIpInterfaceChange(family uint16, callback uintptr, callerContext unsafe.Pointer, initialNotification bool, notificationHandle *Handle) (errcode error) = iphlpapi.NotifyIpInterfaceChange ++//sys NotifyUnicastIpAddressChange(family uint16, callback uintptr, callerContext unsafe.Pointer, initialNotification bool, notificationHandle *Handle) (errcode error) = iphlpapi.NotifyUnicastIpAddressChange ++//sys CancelMibChangeNotify2(notificationHandle Handle) (errcode error) = iphlpapi.CancelMibChangeNotify2 + + // For testing: clients can set this flag to force + // creation of IPv6 sockets to return EAFNOSUPPORT. +@@ -1681,13 +1684,16 @@ func (s NTStatus) Error() string { + // do not use NTUnicodeString, and instead UTF16PtrFromString should be used for + // the more common *uint16 string type. + func NewNTUnicodeString(s string) (*NTUnicodeString, error) { +- var u NTUnicodeString +- s16, err := UTF16PtrFromString(s) ++ s16, err := UTF16FromString(s) + if err != nil { + return nil, err + } +- RtlInitUnicodeString(&u, s16) +- return &u, nil ++ n := uint16(len(s16) * 2) ++ return &NTUnicodeString{ ++ Length: n - 2, // subtract 2 bytes for the NULL terminator ++ MaximumLength: n, ++ Buffer: &s16[0], ++ }, nil + } + + // Slice returns a uint16 slice that aliases the data in the NTUnicodeString. +diff --git a/vendor/golang.org/x/sys/windows/types_windows.go b/vendor/golang.org/x/sys/windows/types_windows.go +index 4d0c157..9d138de 100644 +--- a/vendor/golang.org/x/sys/windows/types_windows.go ++++ b/vendor/golang.org/x/sys/windows/types_windows.go +@@ -176,6 +176,7 @@ const ( + WAIT_FAILED = 0xFFFFFFFF + + // Access rights for process. ++ PROCESS_ALL_ACCESS = 0xFFFF + PROCESS_CREATE_PROCESS = 0x0080 + PROCESS_CREATE_THREAD = 0x0002 + PROCESS_DUP_HANDLE = 0x0040 +@@ -1060,6 +1061,7 @@ const ( + SIO_GET_EXTENSION_FUNCTION_POINTER = IOC_INOUT | IOC_WS2 | 6 + SIO_KEEPALIVE_VALS = IOC_IN | IOC_VENDOR | 4 + SIO_UDP_CONNRESET = IOC_IN | IOC_VENDOR | 12 ++ SIO_UDP_NETRESET = IOC_IN | IOC_VENDOR | 15 + + // cf. http://support.microsoft.com/default.aspx?scid=kb;en-us;257460 + +@@ -2031,6 +2033,50 @@ const ( + IF_TYPE_IEEE1394 = 144 + ) + ++// Enum NL_PREFIX_ORIGIN for [IpAdapterUnicastAddress], see ++// https://learn.microsoft.com/en-us/windows/win32/api/nldef/ne-nldef-nl_prefix_origin ++const ( ++ IpPrefixOriginOther = 0 ++ IpPrefixOriginManual = 1 ++ IpPrefixOriginWellKnown = 2 ++ IpPrefixOriginDhcp = 3 ++ IpPrefixOriginRouterAdvertisement = 4 ++ IpPrefixOriginUnchanged = 1 << 4 ++) ++ ++// Enum NL_SUFFIX_ORIGIN for [IpAdapterUnicastAddress], see ++// https://learn.microsoft.com/en-us/windows/win32/api/nldef/ne-nldef-nl_suffix_origin ++const ( ++ NlsoOther = 0 ++ NlsoManual = 1 ++ NlsoWellKnown = 2 ++ NlsoDhcp = 3 ++ NlsoLinkLayerAddress = 4 ++ NlsoRandom = 5 ++ IpSuffixOriginOther = 0 ++ IpSuffixOriginManual = 1 ++ IpSuffixOriginWellKnown = 2 ++ IpSuffixOriginDhcp = 3 ++ IpSuffixOriginLinkLayerAddress = 4 ++ IpSuffixOriginRandom = 5 ++ IpSuffixOriginUnchanged = 1 << 4 ++) ++ ++// Enum NL_DAD_STATE for [IpAdapterUnicastAddress], see ++// https://learn.microsoft.com/en-us/windows/win32/api/nldef/ne-nldef-nl_dad_state ++const ( ++ NldsInvalid = 0 ++ NldsTentative = 1 ++ NldsDuplicate = 2 ++ NldsDeprecated = 3 ++ NldsPreferred = 4 ++ IpDadStateInvalid = 0 ++ IpDadStateTentative = 1 ++ IpDadStateDuplicate = 2 ++ IpDadStateDeprecated = 3 ++ IpDadStatePreferred = 4 ++) ++ + type SocketAddress struct { + Sockaddr *syscall.RawSockaddrAny + SockaddrLength int32 +@@ -2158,6 +2204,132 @@ const ( + IfOperStatusLowerLayerDown = 7 + ) + ++const ( ++ IF_MAX_PHYS_ADDRESS_LENGTH = 32 ++ IF_MAX_STRING_SIZE = 256 ++) ++ ++// MIB_IF_ENTRY_LEVEL enumeration from netioapi.h or ++// https://learn.microsoft.com/en-us/windows/win32/api/netioapi/nf-netioapi-getifentry2ex. ++const ( ++ MibIfEntryNormal = 0 ++ MibIfEntryNormalWithoutStatistics = 2 ++) ++ ++// MIB_NOTIFICATION_TYPE enumeration from netioapi.h or ++// https://learn.microsoft.com/en-us/windows/win32/api/netioapi/ne-netioapi-mib_notification_type. ++const ( ++ MibParameterNotification = 0 ++ MibAddInstance = 1 ++ MibDeleteInstance = 2 ++ MibInitialNotification = 3 ++) ++ ++// MibIfRow2 stores information about a particular interface. See ++// https://learn.microsoft.com/en-us/windows/win32/api/netioapi/ns-netioapi-mib_if_row2. ++type MibIfRow2 struct { ++ InterfaceLuid uint64 ++ InterfaceIndex uint32 ++ InterfaceGuid GUID ++ Alias [IF_MAX_STRING_SIZE + 1]uint16 ++ Description [IF_MAX_STRING_SIZE + 1]uint16 ++ PhysicalAddressLength uint32 ++ PhysicalAddress [IF_MAX_PHYS_ADDRESS_LENGTH]uint8 ++ PermanentPhysicalAddress [IF_MAX_PHYS_ADDRESS_LENGTH]uint8 ++ Mtu uint32 ++ Type uint32 ++ TunnelType uint32 ++ MediaType uint32 ++ PhysicalMediumType uint32 ++ AccessType uint32 ++ DirectionType uint32 ++ InterfaceAndOperStatusFlags uint8 ++ OperStatus uint32 ++ AdminStatus uint32 ++ MediaConnectState uint32 ++ NetworkGuid GUID ++ ConnectionType uint32 ++ TransmitLinkSpeed uint64 ++ ReceiveLinkSpeed uint64 ++ InOctets uint64 ++ InUcastPkts uint64 ++ InNUcastPkts uint64 ++ InDiscards uint64 ++ InErrors uint64 ++ InUnknownProtos uint64 ++ InUcastOctets uint64 ++ InMulticastOctets uint64 ++ InBroadcastOctets uint64 ++ OutOctets uint64 ++ OutUcastPkts uint64 ++ OutNUcastPkts uint64 ++ OutDiscards uint64 ++ OutErrors uint64 ++ OutUcastOctets uint64 ++ OutMulticastOctets uint64 ++ OutBroadcastOctets uint64 ++ OutQLen uint64 ++} ++ ++// MIB_UNICASTIPADDRESS_ROW stores information about a unicast IP address. See ++// https://learn.microsoft.com/en-us/windows/win32/api/netioapi/ns-netioapi-mib_unicastipaddress_row. ++type MibUnicastIpAddressRow struct { ++ Address RawSockaddrInet6 // SOCKADDR_INET union ++ InterfaceLuid uint64 ++ InterfaceIndex uint32 ++ PrefixOrigin uint32 ++ SuffixOrigin uint32 ++ ValidLifetime uint32 ++ PreferredLifetime uint32 ++ OnLinkPrefixLength uint8 ++ SkipAsSource uint8 ++ DadState uint32 ++ ScopeId uint32 ++ CreationTimeStamp Filetime ++} ++ ++const ScopeLevelCount = 16 ++ ++// MIB_IPINTERFACE_ROW stores interface management information for a particular IP address family on a network interface. ++// See https://learn.microsoft.com/en-us/windows/win32/api/netioapi/ns-netioapi-mib_ipinterface_row. ++type MibIpInterfaceRow struct { ++ Family uint16 ++ InterfaceLuid uint64 ++ InterfaceIndex uint32 ++ MaxReassemblySize uint32 ++ InterfaceIdentifier uint64 ++ MinRouterAdvertisementInterval uint32 ++ MaxRouterAdvertisementInterval uint32 ++ AdvertisingEnabled uint8 ++ ForwardingEnabled uint8 ++ WeakHostSend uint8 ++ WeakHostReceive uint8 ++ UseAutomaticMetric uint8 ++ UseNeighborUnreachabilityDetection uint8 ++ ManagedAddressConfigurationSupported uint8 ++ OtherStatefulConfigurationSupported uint8 ++ AdvertiseDefaultRoute uint8 ++ RouterDiscoveryBehavior uint32 ++ DadTransmits uint32 ++ BaseReachableTime uint32 ++ RetransmitTime uint32 ++ PathMtuDiscoveryTimeout uint32 ++ LinkLocalAddressBehavior uint32 ++ LinkLocalAddressTimeout uint32 ++ ZoneIndices [ScopeLevelCount]uint32 ++ SitePrefixLength uint32 ++ Metric uint32 ++ NlMtu uint32 ++ Connected uint8 ++ SupportsWakeUpPatterns uint8 ++ SupportsNeighborDiscovery uint8 ++ SupportsRouterDiscovery uint8 ++ ReachableTime uint32 ++ TransmitOffload uint32 ++ ReceiveOffload uint32 ++ DisableDefaultRoutes uint8 ++} ++ + // Console related constants used for the mode parameter to SetConsoleMode. See + // https://docs.microsoft.com/en-us/windows/console/setconsolemode for details. + +diff --git a/vendor/golang.org/x/sys/windows/zsyscall_windows.go b/vendor/golang.org/x/sys/windows/zsyscall_windows.go +index 9bb979a..01c0716 100644 +--- a/vendor/golang.org/x/sys/windows/zsyscall_windows.go ++++ b/vendor/golang.org/x/sys/windows/zsyscall_windows.go +@@ -181,10 +181,15 @@ var ( + procDnsRecordListFree = moddnsapi.NewProc("DnsRecordListFree") + procDwmGetWindowAttribute = moddwmapi.NewProc("DwmGetWindowAttribute") + procDwmSetWindowAttribute = moddwmapi.NewProc("DwmSetWindowAttribute") ++ procCancelMibChangeNotify2 = modiphlpapi.NewProc("CancelMibChangeNotify2") + procGetAdaptersAddresses = modiphlpapi.NewProc("GetAdaptersAddresses") + procGetAdaptersInfo = modiphlpapi.NewProc("GetAdaptersInfo") + procGetBestInterfaceEx = modiphlpapi.NewProc("GetBestInterfaceEx") + procGetIfEntry = modiphlpapi.NewProc("GetIfEntry") ++ procGetIfEntry2Ex = modiphlpapi.NewProc("GetIfEntry2Ex") ++ procGetUnicastIpAddressEntry = modiphlpapi.NewProc("GetUnicastIpAddressEntry") ++ procNotifyIpInterfaceChange = modiphlpapi.NewProc("NotifyIpInterfaceChange") ++ procNotifyUnicastIpAddressChange = modiphlpapi.NewProc("NotifyUnicastIpAddressChange") + procAddDllDirectory = modkernel32.NewProc("AddDllDirectory") + procAssignProcessToJobObject = modkernel32.NewProc("AssignProcessToJobObject") + procCancelIo = modkernel32.NewProc("CancelIo") +@@ -247,7 +252,9 @@ var ( + procGetCommandLineW = modkernel32.NewProc("GetCommandLineW") + procGetComputerNameExW = modkernel32.NewProc("GetComputerNameExW") + procGetComputerNameW = modkernel32.NewProc("GetComputerNameW") ++ procGetConsoleCP = modkernel32.NewProc("GetConsoleCP") + procGetConsoleMode = modkernel32.NewProc("GetConsoleMode") ++ procGetConsoleOutputCP = modkernel32.NewProc("GetConsoleOutputCP") + procGetConsoleScreenBufferInfo = modkernel32.NewProc("GetConsoleScreenBufferInfo") + procGetCurrentDirectoryW = modkernel32.NewProc("GetCurrentDirectoryW") + procGetCurrentProcessId = modkernel32.NewProc("GetCurrentProcessId") +@@ -273,8 +280,10 @@ var ( + procGetMaximumProcessorCount = modkernel32.NewProc("GetMaximumProcessorCount") + procGetModuleFileNameW = modkernel32.NewProc("GetModuleFileNameW") + procGetModuleHandleExW = modkernel32.NewProc("GetModuleHandleExW") ++ procGetNamedPipeClientProcessId = modkernel32.NewProc("GetNamedPipeClientProcessId") + procGetNamedPipeHandleStateW = modkernel32.NewProc("GetNamedPipeHandleStateW") + procGetNamedPipeInfo = modkernel32.NewProc("GetNamedPipeInfo") ++ procGetNamedPipeServerProcessId = modkernel32.NewProc("GetNamedPipeServerProcessId") + procGetOverlappedResult = modkernel32.NewProc("GetOverlappedResult") + procGetPriorityClass = modkernel32.NewProc("GetPriorityClass") + procGetProcAddress = modkernel32.NewProc("GetProcAddress") +@@ -347,8 +356,10 @@ var ( + procSetCommMask = modkernel32.NewProc("SetCommMask") + procSetCommState = modkernel32.NewProc("SetCommState") + procSetCommTimeouts = modkernel32.NewProc("SetCommTimeouts") ++ procSetConsoleCP = modkernel32.NewProc("SetConsoleCP") + procSetConsoleCursorPosition = modkernel32.NewProc("SetConsoleCursorPosition") + procSetConsoleMode = modkernel32.NewProc("SetConsoleMode") ++ procSetConsoleOutputCP = modkernel32.NewProc("SetConsoleOutputCP") + procSetCurrentDirectoryW = modkernel32.NewProc("SetCurrentDirectoryW") + procSetDefaultDllDirectories = modkernel32.NewProc("SetDefaultDllDirectories") + procSetDllDirectoryW = modkernel32.NewProc("SetDllDirectoryW") +@@ -1602,6 +1613,14 @@ func DwmSetWindowAttribute(hwnd HWND, attribute uint32, value unsafe.Pointer, si + return + } + ++func CancelMibChangeNotify2(notificationHandle Handle) (errcode error) { ++ r0, _, _ := syscall.Syscall(procCancelMibChangeNotify2.Addr(), 1, uintptr(notificationHandle), 0, 0) ++ if r0 != 0 { ++ errcode = syscall.Errno(r0) ++ } ++ return ++} ++ + func GetAdaptersAddresses(family uint32, flags uint32, reserved uintptr, adapterAddresses *IpAdapterAddresses, sizePointer *uint32) (errcode error) { + r0, _, _ := syscall.Syscall6(procGetAdaptersAddresses.Addr(), 5, uintptr(family), uintptr(flags), uintptr(reserved), uintptr(unsafe.Pointer(adapterAddresses)), uintptr(unsafe.Pointer(sizePointer)), 0) + if r0 != 0 { +@@ -1634,6 +1653,46 @@ func GetIfEntry(pIfRow *MibIfRow) (errcode error) { + return + } + ++func GetIfEntry2Ex(level uint32, row *MibIfRow2) (errcode error) { ++ r0, _, _ := syscall.Syscall(procGetIfEntry2Ex.Addr(), 2, uintptr(level), uintptr(unsafe.Pointer(row)), 0) ++ if r0 != 0 { ++ errcode = syscall.Errno(r0) ++ } ++ return ++} ++ ++func GetUnicastIpAddressEntry(row *MibUnicastIpAddressRow) (errcode error) { ++ r0, _, _ := syscall.Syscall(procGetUnicastIpAddressEntry.Addr(), 1, uintptr(unsafe.Pointer(row)), 0, 0) ++ if r0 != 0 { ++ errcode = syscall.Errno(r0) ++ } ++ return ++} ++ ++func NotifyIpInterfaceChange(family uint16, callback uintptr, callerContext unsafe.Pointer, initialNotification bool, notificationHandle *Handle) (errcode error) { ++ var _p0 uint32 ++ if initialNotification { ++ _p0 = 1 ++ } ++ r0, _, _ := syscall.Syscall6(procNotifyIpInterfaceChange.Addr(), 5, uintptr(family), uintptr(callback), uintptr(callerContext), uintptr(_p0), uintptr(unsafe.Pointer(notificationHandle)), 0) ++ if r0 != 0 { ++ errcode = syscall.Errno(r0) ++ } ++ return ++} ++ ++func NotifyUnicastIpAddressChange(family uint16, callback uintptr, callerContext unsafe.Pointer, initialNotification bool, notificationHandle *Handle) (errcode error) { ++ var _p0 uint32 ++ if initialNotification { ++ _p0 = 1 ++ } ++ r0, _, _ := syscall.Syscall6(procNotifyUnicastIpAddressChange.Addr(), 5, uintptr(family), uintptr(callback), uintptr(callerContext), uintptr(_p0), uintptr(unsafe.Pointer(notificationHandle)), 0) ++ if r0 != 0 { ++ errcode = syscall.Errno(r0) ++ } ++ return ++} ++ + func AddDllDirectory(path *uint16) (cookie uintptr, err error) { + r0, _, e1 := syscall.Syscall(procAddDllDirectory.Addr(), 1, uintptr(unsafe.Pointer(path)), 0, 0) + cookie = uintptr(r0) +@@ -2162,6 +2221,15 @@ func GetComputerName(buf *uint16, n *uint32) (err error) { + return + } + ++func GetConsoleCP() (cp uint32, err error) { ++ r0, _, e1 := syscall.Syscall(procGetConsoleCP.Addr(), 0, 0, 0, 0) ++ cp = uint32(r0) ++ if cp == 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ + func GetConsoleMode(console Handle, mode *uint32) (err error) { + r1, _, e1 := syscall.Syscall(procGetConsoleMode.Addr(), 2, uintptr(console), uintptr(unsafe.Pointer(mode)), 0) + if r1 == 0 { +@@ -2170,6 +2238,15 @@ func GetConsoleMode(console Handle, mode *uint32) (err error) { + return + } + ++func GetConsoleOutputCP() (cp uint32, err error) { ++ r0, _, e1 := syscall.Syscall(procGetConsoleOutputCP.Addr(), 0, 0, 0, 0) ++ cp = uint32(r0) ++ if cp == 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ + func GetConsoleScreenBufferInfo(console Handle, info *ConsoleScreenBufferInfo) (err error) { + r1, _, e1 := syscall.Syscall(procGetConsoleScreenBufferInfo.Addr(), 2, uintptr(console), uintptr(unsafe.Pointer(info)), 0) + if r1 == 0 { +@@ -2371,6 +2448,14 @@ func GetModuleHandleEx(flags uint32, moduleName *uint16, module *Handle) (err er + return + } + ++func GetNamedPipeClientProcessId(pipe Handle, clientProcessID *uint32) (err error) { ++ r1, _, e1 := syscall.Syscall(procGetNamedPipeClientProcessId.Addr(), 2, uintptr(pipe), uintptr(unsafe.Pointer(clientProcessID)), 0) ++ if r1 == 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ + func GetNamedPipeHandleState(pipe Handle, state *uint32, curInstances *uint32, maxCollectionCount *uint32, collectDataTimeout *uint32, userName *uint16, maxUserNameSize uint32) (err error) { + r1, _, e1 := syscall.Syscall9(procGetNamedPipeHandleStateW.Addr(), 7, uintptr(pipe), uintptr(unsafe.Pointer(state)), uintptr(unsafe.Pointer(curInstances)), uintptr(unsafe.Pointer(maxCollectionCount)), uintptr(unsafe.Pointer(collectDataTimeout)), uintptr(unsafe.Pointer(userName)), uintptr(maxUserNameSize), 0, 0) + if r1 == 0 { +@@ -2387,6 +2472,14 @@ func GetNamedPipeInfo(pipe Handle, flags *uint32, outSize *uint32, inSize *uint3 + return + } + ++func GetNamedPipeServerProcessId(pipe Handle, serverProcessID *uint32) (err error) { ++ r1, _, e1 := syscall.Syscall(procGetNamedPipeServerProcessId.Addr(), 2, uintptr(pipe), uintptr(unsafe.Pointer(serverProcessID)), 0) ++ if r1 == 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ + func GetOverlappedResult(handle Handle, overlapped *Overlapped, done *uint32, wait bool) (err error) { + var _p0 uint32 + if wait { +@@ -3038,6 +3131,14 @@ func SetCommTimeouts(handle Handle, timeouts *CommTimeouts) (err error) { + return + } + ++func SetConsoleCP(cp uint32) (err error) { ++ r1, _, e1 := syscall.Syscall(procSetConsoleCP.Addr(), 1, uintptr(cp), 0, 0) ++ if r1 == 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ + func setConsoleCursorPosition(console Handle, position uint32) (err error) { + r1, _, e1 := syscall.Syscall(procSetConsoleCursorPosition.Addr(), 2, uintptr(console), uintptr(position), 0) + if r1 == 0 { +@@ -3054,6 +3155,14 @@ func SetConsoleMode(console Handle, mode uint32) (err error) { + return + } + ++func SetConsoleOutputCP(cp uint32) (err error) { ++ r1, _, e1 := syscall.Syscall(procSetConsoleOutputCP.Addr(), 1, uintptr(cp), 0, 0) ++ if r1 == 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ + func SetCurrentDirectory(path *uint16) (err error) { + r1, _, e1 := syscall.Syscall(procSetCurrentDirectoryW.Addr(), 1, uintptr(unsafe.Pointer(path)), 0, 0) + if r1 == 0 { +diff --git a/vendor/modules.txt b/vendor/modules.txt +index 6b39e77..be1b84e 100644 +--- a/vendor/modules.txt ++++ b/vendor/modules.txt +@@ -152,7 +152,7 @@ go.uber.org/zap/internal/exit + go.uber.org/zap/internal/pool + go.uber.org/zap/internal/stacktrace + go.uber.org/zap/zapcore +-# golang.org/x/net v0.28.0 ++# golang.org/x/net v0.33.0 + ## explicit; go 1.18 + golang.org/x/net/http/httpguts + golang.org/x/net/http2 +@@ -160,11 +160,11 @@ golang.org/x/net/http2/hpack + golang.org/x/net/idna + golang.org/x/net/internal/timeseries + golang.org/x/net/trace +-# golang.org/x/sys v0.23.0 ++# golang.org/x/sys v0.28.0 + ## explicit; go 1.18 + golang.org/x/sys/unix + golang.org/x/sys/windows +-# golang.org/x/text v0.17.0 ++# golang.org/x/text v0.21.0 + ## explicit; go 1.18 + golang.org/x/text/secure/bidirule + golang.org/x/text/transform +-- +2.40.1 + diff --git a/projects/kubernetes-csi/livenessprobe/1-31/patches/0001-Address-CVE-2024-45338.patch b/projects/kubernetes-csi/livenessprobe/1-31/patches/0001-Address-CVE-2024-45338.patch new file mode 100644 index 000000000..d284d9f1d --- /dev/null +++ b/projects/kubernetes-csi/livenessprobe/1-31/patches/0001-Address-CVE-2024-45338.patch @@ -0,0 +1,5325 @@ +From f846b95fea50c3bbb26a8702870a4c2979e671fe Mon Sep 17 00:00:00 2001 +From: torredil +Date: Mon, 23 Dec 2024 18:55:24 +0000 +Subject: [PATCH] Address CVE-2024-45338 + +Signed-off-by: torredil +--- + go.mod | 6 +- + go.sum | 12 +- + .../x/net/http2/client_conn_pool.go | 8 +- + vendor/golang.org/x/net/http2/config.go | 122 +++++ + vendor/golang.org/x/net/http2/config_go124.go | 61 +++ + .../x/net/http2/config_pre_go124.go | 16 + + vendor/golang.org/x/net/http2/frame.go | 4 +- + vendor/golang.org/x/net/http2/http2.go | 95 +++- + vendor/golang.org/x/net/http2/server.go | 244 ++++++--- + vendor/golang.org/x/net/http2/transport.go | 516 ++++++++++++------ + vendor/golang.org/x/net/http2/unencrypted.go | 32 ++ + vendor/golang.org/x/net/http2/write.go | 10 + + vendor/golang.org/x/sys/unix/README.md | 2 +- + vendor/golang.org/x/sys/unix/ioctl_linux.go | 96 ++++ + vendor/golang.org/x/sys/unix/mkerrors.sh | 17 +- + vendor/golang.org/x/sys/unix/syscall_aix.go | 2 +- + .../golang.org/x/sys/unix/syscall_darwin.go | 37 ++ + vendor/golang.org/x/sys/unix/syscall_hurd.go | 1 + + vendor/golang.org/x/sys/unix/syscall_linux.go | 64 ++- + .../x/sys/unix/syscall_linux_arm64.go | 2 + + .../x/sys/unix/syscall_linux_loong64.go | 2 + + .../x/sys/unix/syscall_linux_riscv64.go | 2 + + .../x/sys/unix/syscall_zos_s390x.go | 104 +++- + .../golang.org/x/sys/unix/vgetrandom_linux.go | 13 + + .../x/sys/unix/vgetrandom_unsupported.go | 11 + + .../x/sys/unix/zerrors_darwin_amd64.go | 7 + + .../x/sys/unix/zerrors_darwin_arm64.go | 7 + + vendor/golang.org/x/sys/unix/zerrors_linux.go | 44 +- + .../x/sys/unix/zerrors_linux_386.go | 25 + + .../x/sys/unix/zerrors_linux_amd64.go | 25 + + .../x/sys/unix/zerrors_linux_arm.go | 25 + + .../x/sys/unix/zerrors_linux_arm64.go | 26 + + .../x/sys/unix/zerrors_linux_loong64.go | 25 + + .../x/sys/unix/zerrors_linux_mips.go | 25 + + .../x/sys/unix/zerrors_linux_mips64.go | 25 + + .../x/sys/unix/zerrors_linux_mips64le.go | 25 + + .../x/sys/unix/zerrors_linux_mipsle.go | 25 + + .../x/sys/unix/zerrors_linux_ppc.go | 25 + + .../x/sys/unix/zerrors_linux_ppc64.go | 25 + + .../x/sys/unix/zerrors_linux_ppc64le.go | 25 + + .../x/sys/unix/zerrors_linux_riscv64.go | 25 + + .../x/sys/unix/zerrors_linux_s390x.go | 25 + + .../x/sys/unix/zerrors_linux_sparc64.go | 25 + + .../x/sys/unix/zerrors_zos_s390x.go | 2 + + .../x/sys/unix/zsyscall_darwin_amd64.go | 20 + + .../x/sys/unix/zsyscall_darwin_amd64.s | 5 + + .../x/sys/unix/zsyscall_darwin_arm64.go | 20 + + .../x/sys/unix/zsyscall_darwin_arm64.s | 5 + + .../golang.org/x/sys/unix/zsyscall_linux.go | 27 +- + .../x/sys/unix/zsysnum_linux_amd64.go | 1 + + .../x/sys/unix/zsysnum_linux_arm64.go | 2 +- + .../x/sys/unix/zsysnum_linux_loong64.go | 2 + + .../x/sys/unix/zsysnum_linux_riscv64.go | 2 +- + .../x/sys/unix/ztypes_darwin_amd64.go | 73 +++ + .../x/sys/unix/ztypes_darwin_arm64.go | 73 +++ + .../x/sys/unix/ztypes_freebsd_386.go | 1 + + .../x/sys/unix/ztypes_freebsd_amd64.go | 1 + + .../x/sys/unix/ztypes_freebsd_arm.go | 1 + + .../x/sys/unix/ztypes_freebsd_arm64.go | 1 + + .../x/sys/unix/ztypes_freebsd_riscv64.go | 1 + + vendor/golang.org/x/sys/unix/ztypes_linux.go | 227 ++++++-- + .../x/sys/unix/ztypes_linux_riscv64.go | 33 ++ + .../golang.org/x/sys/unix/ztypes_zos_s390x.go | 6 + + .../golang.org/x/sys/windows/dll_windows.go | 2 +- + .../x/sys/windows/syscall_windows.go | 40 +- + .../golang.org/x/sys/windows/types_windows.go | 172 ++++++ + .../x/sys/windows/zsyscall_windows.go | 109 ++++ + vendor/modules.txt | 6 +- + 68 files changed, 2370 insertions(+), 375 deletions(-) + create mode 100644 vendor/golang.org/x/net/http2/config.go + create mode 100644 vendor/golang.org/x/net/http2/config_go124.go + create mode 100644 vendor/golang.org/x/net/http2/config_pre_go124.go + create mode 100644 vendor/golang.org/x/net/http2/unencrypted.go + create mode 100644 vendor/golang.org/x/sys/unix/vgetrandom_linux.go + create mode 100644 vendor/golang.org/x/sys/unix/vgetrandom_unsupported.go + +diff --git a/go.mod b/go.mod +index 235ec1f..b8ded7e 100644 +--- a/go.mod ++++ b/go.mod +@@ -42,9 +42,9 @@ require ( + go.opentelemetry.io/otel/trace v1.28.0 // indirect + go.uber.org/multierr v1.11.0 // indirect + go.uber.org/zap v1.27.0 // indirect +- golang.org/x/net v0.28.0 // indirect +- golang.org/x/sys v0.23.0 // indirect +- golang.org/x/text v0.17.0 // indirect ++ golang.org/x/net v0.33.0 // indirect ++ golang.org/x/sys v0.28.0 // indirect ++ golang.org/x/text v0.21.0 // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20240701130421-f6361c86f094 // indirect + google.golang.org/grpc v1.65.0 // indirect + google.golang.org/protobuf v1.34.2 // indirect +diff --git a/go.sum b/go.sum +index 4a2470f..db27122 100644 +--- a/go.sum ++++ b/go.sum +@@ -109,8 +109,8 @@ golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLL + golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= + golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= + golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= +-golang.org/x/net v0.28.0 h1:a9JDOJc5GMUJ0+UDqmLT86WiEy7iWyIhz8gz8E4e5hE= +-golang.org/x/net v0.28.0/go.mod h1:yqtgsTWOOnlGLG9GFRrK3++bGOUEkNBoHZc8MEDWPNg= ++golang.org/x/net v0.33.0 h1:74SYHlV8BIgHIFC/LrYkOGIwL19eTYXQ5wc6TBuO36I= ++golang.org/x/net v0.33.0/go.mod h1:HXLR5J+9DxmrqMwG9qjGCxZ+zKXxBru04zlTvWlWuN4= + golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= + golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= + golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +@@ -121,13 +121,13 @@ golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7w + golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= + golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= + golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +-golang.org/x/sys v0.23.0 h1:YfKFowiIMvtgl1UERQoTPPToxltDeZfbj4H7dVUCwmM= +-golang.org/x/sys v0.23.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= ++golang.org/x/sys v0.28.0 h1:Fksou7UEQUWlKvIdsqzJmUmCX3cZuD2+P3XyyzwMhlA= ++golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= + golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= + golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= + golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +-golang.org/x/text v0.17.0 h1:XtiM5bkSOt+ewxlOE/aE/AKEHibwj/6gvWMl9Rsh0Qc= +-golang.org/x/text v0.17.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY= ++golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo= ++golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ= + golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= + golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= + golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +diff --git a/vendor/golang.org/x/net/http2/client_conn_pool.go b/vendor/golang.org/x/net/http2/client_conn_pool.go +index 780968d..e81b73e 100644 +--- a/vendor/golang.org/x/net/http2/client_conn_pool.go ++++ b/vendor/golang.org/x/net/http2/client_conn_pool.go +@@ -8,8 +8,8 @@ package http2 + + import ( + "context" +- "crypto/tls" + "errors" ++ "net" + "net/http" + "sync" + ) +@@ -158,7 +158,7 @@ func (c *dialCall) dial(ctx context.Context, addr string) { + // This code decides which ones live or die. + // The return value used is whether c was used. + // c is never closed. +-func (p *clientConnPool) addConnIfNeeded(key string, t *Transport, c *tls.Conn) (used bool, err error) { ++func (p *clientConnPool) addConnIfNeeded(key string, t *Transport, c net.Conn) (used bool, err error) { + p.mu.Lock() + for _, cc := range p.conns[key] { + if cc.CanTakeNewRequest() { +@@ -194,8 +194,8 @@ type addConnCall struct { + err error + } + +-func (c *addConnCall) run(t *Transport, key string, tc *tls.Conn) { +- cc, err := t.NewClientConn(tc) ++func (c *addConnCall) run(t *Transport, key string, nc net.Conn) { ++ cc, err := t.NewClientConn(nc) + + p := c.p + p.mu.Lock() +diff --git a/vendor/golang.org/x/net/http2/config.go b/vendor/golang.org/x/net/http2/config.go +new file mode 100644 +index 0000000..de58dfb +--- /dev/null ++++ b/vendor/golang.org/x/net/http2/config.go +@@ -0,0 +1,122 @@ ++// Copyright 2024 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 http2 ++ ++import ( ++ "math" ++ "net/http" ++ "time" ++) ++ ++// http2Config is a package-internal version of net/http.HTTP2Config. ++// ++// http.HTTP2Config was added in Go 1.24. ++// When running with a version of net/http that includes HTTP2Config, ++// we merge the configuration with the fields in Transport or Server ++// to produce an http2Config. ++// ++// Zero valued fields in http2Config are interpreted as in the ++// net/http.HTTPConfig documentation. ++// ++// Precedence order for reconciling configurations is: ++// ++// - Use the net/http.{Server,Transport}.HTTP2Config value, when non-zero. ++// - Otherwise use the http2.{Server.Transport} value. ++// - If the resulting value is zero or out of range, use a default. ++type http2Config struct { ++ MaxConcurrentStreams uint32 ++ MaxDecoderHeaderTableSize uint32 ++ MaxEncoderHeaderTableSize uint32 ++ MaxReadFrameSize uint32 ++ MaxUploadBufferPerConnection int32 ++ MaxUploadBufferPerStream int32 ++ SendPingTimeout time.Duration ++ PingTimeout time.Duration ++ WriteByteTimeout time.Duration ++ PermitProhibitedCipherSuites bool ++ CountError func(errType string) ++} ++ ++// configFromServer merges configuration settings from ++// net/http.Server.HTTP2Config and http2.Server. ++func configFromServer(h1 *http.Server, h2 *Server) http2Config { ++ conf := http2Config{ ++ MaxConcurrentStreams: h2.MaxConcurrentStreams, ++ MaxEncoderHeaderTableSize: h2.MaxEncoderHeaderTableSize, ++ MaxDecoderHeaderTableSize: h2.MaxDecoderHeaderTableSize, ++ MaxReadFrameSize: h2.MaxReadFrameSize, ++ MaxUploadBufferPerConnection: h2.MaxUploadBufferPerConnection, ++ MaxUploadBufferPerStream: h2.MaxUploadBufferPerStream, ++ SendPingTimeout: h2.ReadIdleTimeout, ++ PingTimeout: h2.PingTimeout, ++ WriteByteTimeout: h2.WriteByteTimeout, ++ PermitProhibitedCipherSuites: h2.PermitProhibitedCipherSuites, ++ CountError: h2.CountError, ++ } ++ fillNetHTTPServerConfig(&conf, h1) ++ setConfigDefaults(&conf, true) ++ return conf ++} ++ ++// configFromServer merges configuration settings from h2 and h2.t1.HTTP2 ++// (the net/http Transport). ++func configFromTransport(h2 *Transport) http2Config { ++ conf := http2Config{ ++ MaxEncoderHeaderTableSize: h2.MaxEncoderHeaderTableSize, ++ MaxDecoderHeaderTableSize: h2.MaxDecoderHeaderTableSize, ++ MaxReadFrameSize: h2.MaxReadFrameSize, ++ SendPingTimeout: h2.ReadIdleTimeout, ++ PingTimeout: h2.PingTimeout, ++ WriteByteTimeout: h2.WriteByteTimeout, ++ } ++ ++ // Unlike most config fields, where out-of-range values revert to the default, ++ // Transport.MaxReadFrameSize clips. ++ if conf.MaxReadFrameSize < minMaxFrameSize { ++ conf.MaxReadFrameSize = minMaxFrameSize ++ } else if conf.MaxReadFrameSize > maxFrameSize { ++ conf.MaxReadFrameSize = maxFrameSize ++ } ++ ++ if h2.t1 != nil { ++ fillNetHTTPTransportConfig(&conf, h2.t1) ++ } ++ setConfigDefaults(&conf, false) ++ return conf ++} ++ ++func setDefault[T ~int | ~int32 | ~uint32 | ~int64](v *T, minval, maxval, defval T) { ++ if *v < minval || *v > maxval { ++ *v = defval ++ } ++} ++ ++func setConfigDefaults(conf *http2Config, server bool) { ++ setDefault(&conf.MaxConcurrentStreams, 1, math.MaxUint32, defaultMaxStreams) ++ setDefault(&conf.MaxEncoderHeaderTableSize, 1, math.MaxUint32, initialHeaderTableSize) ++ setDefault(&conf.MaxDecoderHeaderTableSize, 1, math.MaxUint32, initialHeaderTableSize) ++ if server { ++ setDefault(&conf.MaxUploadBufferPerConnection, initialWindowSize, math.MaxInt32, 1<<20) ++ } else { ++ setDefault(&conf.MaxUploadBufferPerConnection, initialWindowSize, math.MaxInt32, transportDefaultConnFlow) ++ } ++ if server { ++ setDefault(&conf.MaxUploadBufferPerStream, 1, math.MaxInt32, 1<<20) ++ } else { ++ setDefault(&conf.MaxUploadBufferPerStream, 1, math.MaxInt32, transportDefaultStreamFlow) ++ } ++ setDefault(&conf.MaxReadFrameSize, minMaxFrameSize, maxFrameSize, defaultMaxReadFrameSize) ++ setDefault(&conf.PingTimeout, 1, math.MaxInt64, 15*time.Second) ++} ++ ++// adjustHTTP1MaxHeaderSize converts a limit in bytes on the size of an HTTP/1 header ++// to an HTTP/2 MAX_HEADER_LIST_SIZE value. ++func adjustHTTP1MaxHeaderSize(n int64) int64 { ++ // http2's count is in a slightly different unit and includes 32 bytes per pair. ++ // So, take the net/http.Server value and pad it up a bit, assuming 10 headers. ++ const perFieldOverhead = 32 // per http2 spec ++ const typicalHeaders = 10 // conservative ++ return n + typicalHeaders*perFieldOverhead ++} +diff --git a/vendor/golang.org/x/net/http2/config_go124.go b/vendor/golang.org/x/net/http2/config_go124.go +new file mode 100644 +index 0000000..e378412 +--- /dev/null ++++ b/vendor/golang.org/x/net/http2/config_go124.go +@@ -0,0 +1,61 @@ ++// Copyright 2024 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. ++ ++//go:build go1.24 ++ ++package http2 ++ ++import "net/http" ++ ++// fillNetHTTPServerConfig sets fields in conf from srv.HTTP2. ++func fillNetHTTPServerConfig(conf *http2Config, srv *http.Server) { ++ fillNetHTTPConfig(conf, srv.HTTP2) ++} ++ ++// fillNetHTTPServerConfig sets fields in conf from tr.HTTP2. ++func fillNetHTTPTransportConfig(conf *http2Config, tr *http.Transport) { ++ fillNetHTTPConfig(conf, tr.HTTP2) ++} ++ ++func fillNetHTTPConfig(conf *http2Config, h2 *http.HTTP2Config) { ++ if h2 == nil { ++ return ++ } ++ if h2.MaxConcurrentStreams != 0 { ++ conf.MaxConcurrentStreams = uint32(h2.MaxConcurrentStreams) ++ } ++ if h2.MaxEncoderHeaderTableSize != 0 { ++ conf.MaxEncoderHeaderTableSize = uint32(h2.MaxEncoderHeaderTableSize) ++ } ++ if h2.MaxDecoderHeaderTableSize != 0 { ++ conf.MaxDecoderHeaderTableSize = uint32(h2.MaxDecoderHeaderTableSize) ++ } ++ if h2.MaxConcurrentStreams != 0 { ++ conf.MaxConcurrentStreams = uint32(h2.MaxConcurrentStreams) ++ } ++ if h2.MaxReadFrameSize != 0 { ++ conf.MaxReadFrameSize = uint32(h2.MaxReadFrameSize) ++ } ++ if h2.MaxReceiveBufferPerConnection != 0 { ++ conf.MaxUploadBufferPerConnection = int32(h2.MaxReceiveBufferPerConnection) ++ } ++ if h2.MaxReceiveBufferPerStream != 0 { ++ conf.MaxUploadBufferPerStream = int32(h2.MaxReceiveBufferPerStream) ++ } ++ if h2.SendPingTimeout != 0 { ++ conf.SendPingTimeout = h2.SendPingTimeout ++ } ++ if h2.PingTimeout != 0 { ++ conf.PingTimeout = h2.PingTimeout ++ } ++ if h2.WriteByteTimeout != 0 { ++ conf.WriteByteTimeout = h2.WriteByteTimeout ++ } ++ if h2.PermitProhibitedCipherSuites { ++ conf.PermitProhibitedCipherSuites = true ++ } ++ if h2.CountError != nil { ++ conf.CountError = h2.CountError ++ } ++} +diff --git a/vendor/golang.org/x/net/http2/config_pre_go124.go b/vendor/golang.org/x/net/http2/config_pre_go124.go +new file mode 100644 +index 0000000..060fd6c +--- /dev/null ++++ b/vendor/golang.org/x/net/http2/config_pre_go124.go +@@ -0,0 +1,16 @@ ++// Copyright 2024 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. ++ ++//go:build !go1.24 ++ ++package http2 ++ ++import "net/http" ++ ++// Pre-Go 1.24 fallback. ++// The Server.HTTP2 and Transport.HTTP2 config fields were added in Go 1.24. ++ ++func fillNetHTTPServerConfig(conf *http2Config, srv *http.Server) {} ++ ++func fillNetHTTPTransportConfig(conf *http2Config, tr *http.Transport) {} +diff --git a/vendor/golang.org/x/net/http2/frame.go b/vendor/golang.org/x/net/http2/frame.go +index 105c3b2..81faec7 100644 +--- a/vendor/golang.org/x/net/http2/frame.go ++++ b/vendor/golang.org/x/net/http2/frame.go +@@ -1490,7 +1490,7 @@ func (mh *MetaHeadersFrame) checkPseudos() error { + pf := mh.PseudoFields() + for i, hf := range pf { + switch hf.Name { +- case ":method", ":path", ":scheme", ":authority": ++ case ":method", ":path", ":scheme", ":authority", ":protocol": + isRequest = true + case ":status": + isResponse = true +@@ -1498,7 +1498,7 @@ func (mh *MetaHeadersFrame) checkPseudos() error { + return pseudoHeaderError(hf.Name) + } + // Check for duplicates. +- // This would be a bad algorithm, but N is 4. ++ // This would be a bad algorithm, but N is 5. + // And this doesn't allocate. + for _, hf2 := range pf[:i] { + if hf.Name == hf2.Name { +diff --git a/vendor/golang.org/x/net/http2/http2.go b/vendor/golang.org/x/net/http2/http2.go +index 003e649..c7601c9 100644 +--- a/vendor/golang.org/x/net/http2/http2.go ++++ b/vendor/golang.org/x/net/http2/http2.go +@@ -19,8 +19,9 @@ import ( + "bufio" + "context" + "crypto/tls" ++ "errors" + "fmt" +- "io" ++ "net" + "net/http" + "os" + "sort" +@@ -33,10 +34,11 @@ import ( + ) + + var ( +- VerboseLogs bool +- logFrameWrites bool +- logFrameReads bool +- inTests bool ++ VerboseLogs bool ++ logFrameWrites bool ++ logFrameReads bool ++ inTests bool ++ disableExtendedConnectProtocol bool + ) + + func init() { +@@ -49,6 +51,9 @@ func init() { + logFrameWrites = true + logFrameReads = true + } ++ if strings.Contains(e, "http2xconnect=0") { ++ disableExtendedConnectProtocol = true ++ } + } + + const ( +@@ -140,6 +145,10 @@ func (s Setting) Valid() error { + if s.Val < 16384 || s.Val > 1<<24-1 { + return ConnectionError(ErrCodeProtocol) + } ++ case SettingEnableConnectProtocol: ++ if s.Val != 1 && s.Val != 0 { ++ return ConnectionError(ErrCodeProtocol) ++ } + } + return nil + } +@@ -149,21 +158,23 @@ func (s Setting) Valid() error { + type SettingID uint16 + + const ( +- SettingHeaderTableSize SettingID = 0x1 +- SettingEnablePush SettingID = 0x2 +- SettingMaxConcurrentStreams SettingID = 0x3 +- SettingInitialWindowSize SettingID = 0x4 +- SettingMaxFrameSize SettingID = 0x5 +- SettingMaxHeaderListSize SettingID = 0x6 ++ SettingHeaderTableSize SettingID = 0x1 ++ SettingEnablePush SettingID = 0x2 ++ SettingMaxConcurrentStreams SettingID = 0x3 ++ SettingInitialWindowSize SettingID = 0x4 ++ SettingMaxFrameSize SettingID = 0x5 ++ SettingMaxHeaderListSize SettingID = 0x6 ++ SettingEnableConnectProtocol SettingID = 0x8 + ) + + var settingName = map[SettingID]string{ +- SettingHeaderTableSize: "HEADER_TABLE_SIZE", +- SettingEnablePush: "ENABLE_PUSH", +- SettingMaxConcurrentStreams: "MAX_CONCURRENT_STREAMS", +- SettingInitialWindowSize: "INITIAL_WINDOW_SIZE", +- SettingMaxFrameSize: "MAX_FRAME_SIZE", +- SettingMaxHeaderListSize: "MAX_HEADER_LIST_SIZE", ++ SettingHeaderTableSize: "HEADER_TABLE_SIZE", ++ SettingEnablePush: "ENABLE_PUSH", ++ SettingMaxConcurrentStreams: "MAX_CONCURRENT_STREAMS", ++ SettingInitialWindowSize: "INITIAL_WINDOW_SIZE", ++ SettingMaxFrameSize: "MAX_FRAME_SIZE", ++ SettingMaxHeaderListSize: "MAX_HEADER_LIST_SIZE", ++ SettingEnableConnectProtocol: "ENABLE_CONNECT_PROTOCOL", + } + + func (s SettingID) String() string { +@@ -237,13 +248,19 @@ func (cw closeWaiter) Wait() { + // Its buffered writer is lazily allocated as needed, to minimize + // idle memory usage with many connections. + type bufferedWriter struct { +- _ incomparable +- w io.Writer // immutable +- bw *bufio.Writer // non-nil when data is buffered ++ _ incomparable ++ group synctestGroupInterface // immutable ++ conn net.Conn // immutable ++ bw *bufio.Writer // non-nil when data is buffered ++ byteTimeout time.Duration // immutable, WriteByteTimeout + } + +-func newBufferedWriter(w io.Writer) *bufferedWriter { +- return &bufferedWriter{w: w} ++func newBufferedWriter(group synctestGroupInterface, conn net.Conn, timeout time.Duration) *bufferedWriter { ++ return &bufferedWriter{ ++ group: group, ++ conn: conn, ++ byteTimeout: timeout, ++ } + } + + // bufWriterPoolBufferSize is the size of bufio.Writer's +@@ -270,7 +287,7 @@ func (w *bufferedWriter) Available() int { + func (w *bufferedWriter) Write(p []byte) (n int, err error) { + if w.bw == nil { + bw := bufWriterPool.Get().(*bufio.Writer) +- bw.Reset(w.w) ++ bw.Reset((*bufferedWriterTimeoutWriter)(w)) + w.bw = bw + } + return w.bw.Write(p) +@@ -288,6 +305,38 @@ func (w *bufferedWriter) Flush() error { + return err + } + ++type bufferedWriterTimeoutWriter bufferedWriter ++ ++func (w *bufferedWriterTimeoutWriter) Write(p []byte) (n int, err error) { ++ return writeWithByteTimeout(w.group, w.conn, w.byteTimeout, p) ++} ++ ++// writeWithByteTimeout writes to conn. ++// If more than timeout passes without any bytes being written to the connection, ++// the write fails. ++func writeWithByteTimeout(group synctestGroupInterface, conn net.Conn, timeout time.Duration, p []byte) (n int, err error) { ++ if timeout <= 0 { ++ return conn.Write(p) ++ } ++ for { ++ var now time.Time ++ if group == nil { ++ now = time.Now() ++ } else { ++ now = group.Now() ++ } ++ conn.SetWriteDeadline(now.Add(timeout)) ++ nn, err := conn.Write(p[n:]) ++ n += nn ++ if n == len(p) || nn == 0 || !errors.Is(err, os.ErrDeadlineExceeded) { ++ // Either we finished the write, made no progress, or hit the deadline. ++ // Whichever it is, we're done now. ++ conn.SetWriteDeadline(time.Time{}) ++ return n, err ++ } ++ } ++} ++ + func mustUint31(v int32) uint32 { + if v < 0 || v > 2147483647 { + panic("out of range") +diff --git a/vendor/golang.org/x/net/http2/server.go b/vendor/golang.org/x/net/http2/server.go +index 6c349f3..b55547a 100644 +--- a/vendor/golang.org/x/net/http2/server.go ++++ b/vendor/golang.org/x/net/http2/server.go +@@ -29,6 +29,7 @@ import ( + "bufio" + "bytes" + "context" ++ "crypto/rand" + "crypto/tls" + "errors" + "fmt" +@@ -52,10 +53,14 @@ import ( + ) + + const ( +- prefaceTimeout = 10 * time.Second +- firstSettingsTimeout = 2 * time.Second // should be in-flight with preface anyway +- handlerChunkWriteSize = 4 << 10 +- defaultMaxStreams = 250 // TODO: make this 100 as the GFE seems to? ++ prefaceTimeout = 10 * time.Second ++ firstSettingsTimeout = 2 * time.Second // should be in-flight with preface anyway ++ handlerChunkWriteSize = 4 << 10 ++ defaultMaxStreams = 250 // TODO: make this 100 as the GFE seems to? ++ ++ // maxQueuedControlFrames is the maximum number of control frames like ++ // SETTINGS, PING and RST_STREAM that will be queued for writing before ++ // the connection is closed to prevent memory exhaustion attacks. + maxQueuedControlFrames = 10000 + ) + +@@ -127,6 +132,22 @@ type Server struct { + // If zero or negative, there is no timeout. + IdleTimeout time.Duration + ++ // ReadIdleTimeout is the timeout after which a health check using a ping ++ // frame will be carried out if no frame is received on the connection. ++ // If zero, no health check is performed. ++ ReadIdleTimeout time.Duration ++ ++ // PingTimeout is the timeout after which the connection will be closed ++ // if a response to a ping is not received. ++ // If zero, a default of 15 seconds is used. ++ PingTimeout time.Duration ++ ++ // WriteByteTimeout is the timeout after which a connection will be ++ // closed if no data can be written to it. The timeout begins when data is ++ // available to write, and is extended whenever any bytes are written. ++ // If zero or negative, there is no timeout. ++ WriteByteTimeout time.Duration ++ + // MaxUploadBufferPerConnection is the size of the initial flow + // control window for each connections. The HTTP/2 spec does not + // allow this to be smaller than 65535 or larger than 2^32-1. +@@ -189,57 +210,6 @@ func (s *Server) afterFunc(d time.Duration, f func()) timer { + return timeTimer{time.AfterFunc(d, f)} + } + +-func (s *Server) initialConnRecvWindowSize() int32 { +- if s.MaxUploadBufferPerConnection >= initialWindowSize { +- return s.MaxUploadBufferPerConnection +- } +- return 1 << 20 +-} +- +-func (s *Server) initialStreamRecvWindowSize() int32 { +- if s.MaxUploadBufferPerStream > 0 { +- return s.MaxUploadBufferPerStream +- } +- return 1 << 20 +-} +- +-func (s *Server) maxReadFrameSize() uint32 { +- if v := s.MaxReadFrameSize; v >= minMaxFrameSize && v <= maxFrameSize { +- return v +- } +- return defaultMaxReadFrameSize +-} +- +-func (s *Server) maxConcurrentStreams() uint32 { +- if v := s.MaxConcurrentStreams; v > 0 { +- return v +- } +- return defaultMaxStreams +-} +- +-func (s *Server) maxDecoderHeaderTableSize() uint32 { +- if v := s.MaxDecoderHeaderTableSize; v > 0 { +- return v +- } +- return initialHeaderTableSize +-} +- +-func (s *Server) maxEncoderHeaderTableSize() uint32 { +- if v := s.MaxEncoderHeaderTableSize; v > 0 { +- return v +- } +- return initialHeaderTableSize +-} +- +-// maxQueuedControlFrames is the maximum number of control frames like +-// SETTINGS, PING and RST_STREAM that will be queued for writing before +-// the connection is closed to prevent memory exhaustion attacks. +-func (s *Server) maxQueuedControlFrames() int { +- // TODO: if anybody asks, add a Server field, and remember to define the +- // behavior of negative values. +- return maxQueuedControlFrames +-} +- + type serverInternalState struct { + mu sync.Mutex + activeConns map[*serverConn]struct{} +@@ -336,7 +306,7 @@ func ConfigureServer(s *http.Server, conf *Server) error { + if s.TLSNextProto == nil { + s.TLSNextProto = map[string]func(*http.Server, *tls.Conn, http.Handler){} + } +- protoHandler := func(hs *http.Server, c *tls.Conn, h http.Handler) { ++ protoHandler := func(hs *http.Server, c net.Conn, h http.Handler, sawClientPreface bool) { + if testHookOnConn != nil { + testHookOnConn() + } +@@ -353,12 +323,31 @@ func ConfigureServer(s *http.Server, conf *Server) error { + ctx = bc.BaseContext() + } + conf.ServeConn(c, &ServeConnOpts{ +- Context: ctx, +- Handler: h, +- BaseConfig: hs, ++ Context: ctx, ++ Handler: h, ++ BaseConfig: hs, ++ SawClientPreface: sawClientPreface, + }) + } +- s.TLSNextProto[NextProtoTLS] = protoHandler ++ s.TLSNextProto[NextProtoTLS] = func(hs *http.Server, c *tls.Conn, h http.Handler) { ++ protoHandler(hs, c, h, false) ++ } ++ // The "unencrypted_http2" TLSNextProto key is used to pass off non-TLS HTTP/2 conns. ++ // ++ // A connection passed in this method has already had the HTTP/2 preface read from it. ++ s.TLSNextProto[nextProtoUnencryptedHTTP2] = func(hs *http.Server, c *tls.Conn, h http.Handler) { ++ nc, err := unencryptedNetConnFromTLSConn(c) ++ if err != nil { ++ if lg := hs.ErrorLog; lg != nil { ++ lg.Print(err) ++ } else { ++ log.Print(err) ++ } ++ go c.Close() ++ return ++ } ++ protoHandler(hs, nc, h, true) ++ } + return nil + } + +@@ -440,13 +429,15 @@ func (s *Server) serveConn(c net.Conn, opts *ServeConnOpts, newf func(*serverCon + baseCtx, cancel := serverConnBaseContext(c, opts) + defer cancel() + ++ http1srv := opts.baseConfig() ++ conf := configFromServer(http1srv, s) + sc := &serverConn{ + srv: s, +- hs: opts.baseConfig(), ++ hs: http1srv, + conn: c, + baseCtx: baseCtx, + remoteAddrStr: c.RemoteAddr().String(), +- bw: newBufferedWriter(c), ++ bw: newBufferedWriter(s.group, c, conf.WriteByteTimeout), + handler: opts.handler(), + streams: make(map[uint32]*stream), + readFrameCh: make(chan readFrameResult), +@@ -456,9 +447,12 @@ func (s *Server) serveConn(c net.Conn, opts *ServeConnOpts, newf func(*serverCon + bodyReadCh: make(chan bodyReadMsg), // buffering doesn't matter either way + doneServing: make(chan struct{}), + clientMaxStreams: math.MaxUint32, // Section 6.5.2: "Initially, there is no limit to this value" +- advMaxStreams: s.maxConcurrentStreams(), ++ advMaxStreams: conf.MaxConcurrentStreams, + initialStreamSendWindowSize: initialWindowSize, ++ initialStreamRecvWindowSize: conf.MaxUploadBufferPerStream, + maxFrameSize: initialMaxFrameSize, ++ pingTimeout: conf.PingTimeout, ++ countErrorFunc: conf.CountError, + serveG: newGoroutineLock(), + pushEnabled: true, + sawClientPreface: opts.SawClientPreface, +@@ -491,15 +485,15 @@ func (s *Server) serveConn(c net.Conn, opts *ServeConnOpts, newf func(*serverCon + sc.flow.add(initialWindowSize) + sc.inflow.init(initialWindowSize) + sc.hpackEncoder = hpack.NewEncoder(&sc.headerWriteBuf) +- sc.hpackEncoder.SetMaxDynamicTableSizeLimit(s.maxEncoderHeaderTableSize()) ++ sc.hpackEncoder.SetMaxDynamicTableSizeLimit(conf.MaxEncoderHeaderTableSize) + + fr := NewFramer(sc.bw, c) +- if s.CountError != nil { +- fr.countError = s.CountError ++ if conf.CountError != nil { ++ fr.countError = conf.CountError + } +- fr.ReadMetaHeaders = hpack.NewDecoder(s.maxDecoderHeaderTableSize(), nil) ++ fr.ReadMetaHeaders = hpack.NewDecoder(conf.MaxDecoderHeaderTableSize, nil) + fr.MaxHeaderListSize = sc.maxHeaderListSize() +- fr.SetMaxReadFrameSize(s.maxReadFrameSize()) ++ fr.SetMaxReadFrameSize(conf.MaxReadFrameSize) + sc.framer = fr + + if tc, ok := c.(connectionStater); ok { +@@ -532,7 +526,7 @@ func (s *Server) serveConn(c net.Conn, opts *ServeConnOpts, newf func(*serverCon + // So for now, do nothing here again. + } + +- if !s.PermitProhibitedCipherSuites && isBadCipher(sc.tlsState.CipherSuite) { ++ if !conf.PermitProhibitedCipherSuites && isBadCipher(sc.tlsState.CipherSuite) { + // "Endpoints MAY choose to generate a connection error + // (Section 5.4.1) of type INADEQUATE_SECURITY if one of + // the prohibited cipher suites are negotiated." +@@ -569,7 +563,7 @@ func (s *Server) serveConn(c net.Conn, opts *ServeConnOpts, newf func(*serverCon + opts.UpgradeRequest = nil + } + +- sc.serve() ++ sc.serve(conf) + } + + func serverConnBaseContext(c net.Conn, opts *ServeConnOpts) (ctx context.Context, cancel func()) { +@@ -609,6 +603,7 @@ type serverConn struct { + tlsState *tls.ConnectionState // shared by all handlers, like net/http + remoteAddrStr string + writeSched WriteScheduler ++ countErrorFunc func(errType string) + + // Everything following is owned by the serve loop; use serveG.check(): + serveG goroutineLock // used to verify funcs are on serve() +@@ -628,6 +623,7 @@ type serverConn struct { + streams map[uint32]*stream + unstartedHandlers []unstartedHandler + initialStreamSendWindowSize int32 ++ initialStreamRecvWindowSize int32 + maxFrameSize int32 + peerMaxHeaderListSize uint32 // zero means unknown (default) + canonHeader map[string]string // http2-lower-case -> Go-Canonical-Case +@@ -638,9 +634,14 @@ type serverConn struct { + inGoAway bool // we've started to or sent GOAWAY + inFrameScheduleLoop bool // whether we're in the scheduleFrameWrite loop + needToSendGoAway bool // we need to schedule a GOAWAY frame write ++ pingSent bool ++ sentPingData [8]byte + goAwayCode ErrCode + shutdownTimer timer // nil until used + idleTimer timer // nil if unused ++ readIdleTimeout time.Duration ++ pingTimeout time.Duration ++ readIdleTimer timer // nil if unused + + // Owned by the writeFrameAsync goroutine: + headerWriteBuf bytes.Buffer +@@ -655,11 +656,7 @@ func (sc *serverConn) maxHeaderListSize() uint32 { + if n <= 0 { + n = http.DefaultMaxHeaderBytes + } +- // http2's count is in a slightly different unit and includes 32 bytes per pair. +- // So, take the net/http.Server value and pad it up a bit, assuming 10 headers. +- const perFieldOverhead = 32 // per http2 spec +- const typicalHeaders = 10 // conservative +- return uint32(n + typicalHeaders*perFieldOverhead) ++ return uint32(adjustHTTP1MaxHeaderSize(int64(n))) + } + + func (sc *serverConn) curOpenStreams() uint32 { +@@ -923,7 +920,7 @@ func (sc *serverConn) notePanic() { + } + } + +-func (sc *serverConn) serve() { ++func (sc *serverConn) serve(conf http2Config) { + sc.serveG.check() + defer sc.notePanic() + defer sc.conn.Close() +@@ -935,20 +932,24 @@ func (sc *serverConn) serve() { + sc.vlogf("http2: server connection from %v on %p", sc.conn.RemoteAddr(), sc.hs) + } + ++ settings := writeSettings{ ++ {SettingMaxFrameSize, conf.MaxReadFrameSize}, ++ {SettingMaxConcurrentStreams, sc.advMaxStreams}, ++ {SettingMaxHeaderListSize, sc.maxHeaderListSize()}, ++ {SettingHeaderTableSize, conf.MaxDecoderHeaderTableSize}, ++ {SettingInitialWindowSize, uint32(sc.initialStreamRecvWindowSize)}, ++ } ++ if !disableExtendedConnectProtocol { ++ settings = append(settings, Setting{SettingEnableConnectProtocol, 1}) ++ } + sc.writeFrame(FrameWriteRequest{ +- write: writeSettings{ +- {SettingMaxFrameSize, sc.srv.maxReadFrameSize()}, +- {SettingMaxConcurrentStreams, sc.advMaxStreams}, +- {SettingMaxHeaderListSize, sc.maxHeaderListSize()}, +- {SettingHeaderTableSize, sc.srv.maxDecoderHeaderTableSize()}, +- {SettingInitialWindowSize, uint32(sc.srv.initialStreamRecvWindowSize())}, +- }, ++ write: settings, + }) + sc.unackedSettings++ + + // Each connection starts with initialWindowSize inflow tokens. + // If a higher value is configured, we add more tokens. +- if diff := sc.srv.initialConnRecvWindowSize() - initialWindowSize; diff > 0 { ++ if diff := conf.MaxUploadBufferPerConnection - initialWindowSize; diff > 0 { + sc.sendWindowUpdate(nil, int(diff)) + } + +@@ -968,11 +969,18 @@ func (sc *serverConn) serve() { + defer sc.idleTimer.Stop() + } + ++ if conf.SendPingTimeout > 0 { ++ sc.readIdleTimeout = conf.SendPingTimeout ++ sc.readIdleTimer = sc.srv.afterFunc(conf.SendPingTimeout, sc.onReadIdleTimer) ++ defer sc.readIdleTimer.Stop() ++ } ++ + go sc.readFrames() // closed by defer sc.conn.Close above + + settingsTimer := sc.srv.afterFunc(firstSettingsTimeout, sc.onSettingsTimer) + defer settingsTimer.Stop() + ++ lastFrameTime := sc.srv.now() + loopNum := 0 + for { + loopNum++ +@@ -986,6 +994,7 @@ func (sc *serverConn) serve() { + case res := <-sc.wroteFrameCh: + sc.wroteFrame(res) + case res := <-sc.readFrameCh: ++ lastFrameTime = sc.srv.now() + // Process any written frames before reading new frames from the client since a + // written frame could have triggered a new stream to be started. + if sc.writingFrameAsync { +@@ -1017,6 +1026,8 @@ func (sc *serverConn) serve() { + case idleTimerMsg: + sc.vlogf("connection is idle") + sc.goAway(ErrCodeNo) ++ case readIdleTimerMsg: ++ sc.handlePingTimer(lastFrameTime) + case shutdownTimerMsg: + sc.vlogf("GOAWAY close timer fired; closing conn from %v", sc.conn.RemoteAddr()) + return +@@ -1039,7 +1050,7 @@ func (sc *serverConn) serve() { + // If the peer is causing us to generate a lot of control frames, + // but not reading them from us, assume they are trying to make us + // run out of memory. +- if sc.queuedControlFrames > sc.srv.maxQueuedControlFrames() { ++ if sc.queuedControlFrames > maxQueuedControlFrames { + sc.vlogf("http2: too many control frames in send queue, closing connection") + return + } +@@ -1055,12 +1066,39 @@ func (sc *serverConn) serve() { + } + } + ++func (sc *serverConn) handlePingTimer(lastFrameReadTime time.Time) { ++ if sc.pingSent { ++ sc.vlogf("timeout waiting for PING response") ++ sc.conn.Close() ++ return ++ } ++ ++ pingAt := lastFrameReadTime.Add(sc.readIdleTimeout) ++ now := sc.srv.now() ++ if pingAt.After(now) { ++ // We received frames since arming the ping timer. ++ // Reset it for the next possible timeout. ++ sc.readIdleTimer.Reset(pingAt.Sub(now)) ++ return ++ } ++ ++ sc.pingSent = true ++ // Ignore crypto/rand.Read errors: It generally can't fail, and worse case if it does ++ // is we send a PING frame containing 0s. ++ _, _ = rand.Read(sc.sentPingData[:]) ++ sc.writeFrame(FrameWriteRequest{ ++ write: &writePing{data: sc.sentPingData}, ++ }) ++ sc.readIdleTimer.Reset(sc.pingTimeout) ++} ++ + type serverMessage int + + // Message values sent to serveMsgCh. + var ( + settingsTimerMsg = new(serverMessage) + idleTimerMsg = new(serverMessage) ++ readIdleTimerMsg = new(serverMessage) + shutdownTimerMsg = new(serverMessage) + gracefulShutdownMsg = new(serverMessage) + handlerDoneMsg = new(serverMessage) +@@ -1068,6 +1106,7 @@ var ( + + func (sc *serverConn) onSettingsTimer() { sc.sendServeMsg(settingsTimerMsg) } + func (sc *serverConn) onIdleTimer() { sc.sendServeMsg(idleTimerMsg) } ++func (sc *serverConn) onReadIdleTimer() { sc.sendServeMsg(readIdleTimerMsg) } + func (sc *serverConn) onShutdownTimer() { sc.sendServeMsg(shutdownTimerMsg) } + + func (sc *serverConn) sendServeMsg(msg interface{}) { +@@ -1320,6 +1359,10 @@ func (sc *serverConn) wroteFrame(res frameWriteResult) { + sc.writingFrame = false + sc.writingFrameAsync = false + ++ if res.err != nil { ++ sc.conn.Close() ++ } ++ + wr := res.wr + + if writeEndsStream(wr.write) { +@@ -1594,6 +1637,11 @@ func (sc *serverConn) processFrame(f Frame) error { + func (sc *serverConn) processPing(f *PingFrame) error { + sc.serveG.check() + if f.IsAck() { ++ if sc.pingSent && sc.sentPingData == f.Data { ++ // This is a response to a PING we sent. ++ sc.pingSent = false ++ sc.readIdleTimer.Reset(sc.readIdleTimeout) ++ } + // 6.7 PING: " An endpoint MUST NOT respond to PING frames + // containing this flag." + return nil +@@ -1757,6 +1805,9 @@ func (sc *serverConn) processSetting(s Setting) error { + sc.maxFrameSize = int32(s.Val) // the maximum valid s.Val is < 2^31 + case SettingMaxHeaderListSize: + sc.peerMaxHeaderListSize = s.Val ++ case SettingEnableConnectProtocol: ++ // Receipt of this parameter by a server does not ++ // have any impact + default: + // Unknown setting: "An endpoint that receives a SETTINGS + // frame with any unknown or unsupported identifier MUST +@@ -2160,7 +2211,7 @@ func (sc *serverConn) newStream(id, pusherID uint32, state streamState) *stream + st.cw.Init() + st.flow.conn = &sc.flow // link to conn-level counter + st.flow.add(sc.initialStreamSendWindowSize) +- st.inflow.init(sc.srv.initialStreamRecvWindowSize()) ++ st.inflow.init(sc.initialStreamRecvWindowSize) + if sc.hs.WriteTimeout > 0 { + st.writeDeadline = sc.srv.afterFunc(sc.hs.WriteTimeout, st.onWriteTimeout) + } +@@ -2187,11 +2238,17 @@ func (sc *serverConn) newWriterAndRequest(st *stream, f *MetaHeadersFrame) (*res + scheme: f.PseudoValue("scheme"), + authority: f.PseudoValue("authority"), + path: f.PseudoValue("path"), ++ protocol: f.PseudoValue("protocol"), ++ } ++ ++ // extended connect is disabled, so we should not see :protocol ++ if disableExtendedConnectProtocol && rp.protocol != "" { ++ return nil, nil, sc.countError("bad_connect", streamError(f.StreamID, ErrCodeProtocol)) + } + + isConnect := rp.method == "CONNECT" + if isConnect { +- if rp.path != "" || rp.scheme != "" || rp.authority == "" { ++ if rp.protocol == "" && (rp.path != "" || rp.scheme != "" || rp.authority == "") { + return nil, nil, sc.countError("bad_connect", streamError(f.StreamID, ErrCodeProtocol)) + } + } else if rp.method == "" || rp.path == "" || (rp.scheme != "https" && rp.scheme != "http") { +@@ -2215,6 +2272,9 @@ func (sc *serverConn) newWriterAndRequest(st *stream, f *MetaHeadersFrame) (*res + if rp.authority == "" { + rp.authority = rp.header.Get("Host") + } ++ if rp.protocol != "" { ++ rp.header.Set(":protocol", rp.protocol) ++ } + + rw, req, err := sc.newWriterAndRequestNoBody(st, rp) + if err != nil { +@@ -2241,6 +2301,7 @@ func (sc *serverConn) newWriterAndRequest(st *stream, f *MetaHeadersFrame) (*res + type requestParam struct { + method string + scheme, authority, path string ++ protocol string + header http.Header + } + +@@ -2282,7 +2343,7 @@ func (sc *serverConn) newWriterAndRequestNoBody(st *stream, rp requestParam) (*r + + var url_ *url.URL + var requestURI string +- if rp.method == "CONNECT" { ++ if rp.method == "CONNECT" && rp.protocol == "" { + url_ = &url.URL{Host: rp.authority} + requestURI = rp.authority // mimic HTTP/1 server behavior + } else { +@@ -2855,6 +2916,11 @@ func (w *responseWriter) SetWriteDeadline(deadline time.Time) error { + return nil + } + ++func (w *responseWriter) EnableFullDuplex() error { ++ // We always support full duplex responses, so this is a no-op. ++ return nil ++} ++ + func (w *responseWriter) Flush() { + w.FlushError() + } +@@ -3301,7 +3367,7 @@ func (sc *serverConn) countError(name string, err error) error { + if sc == nil || sc.srv == nil { + return err + } +- f := sc.srv.CountError ++ f := sc.countErrorFunc + if f == nil { + return err + } +diff --git a/vendor/golang.org/x/net/http2/transport.go b/vendor/golang.org/x/net/http2/transport.go +index 61f511f..090d0e1 100644 +--- a/vendor/golang.org/x/net/http2/transport.go ++++ b/vendor/golang.org/x/net/http2/transport.go +@@ -25,7 +25,6 @@ import ( + "net/http" + "net/http/httptrace" + "net/textproto" +- "os" + "sort" + "strconv" + "strings" +@@ -203,6 +202,20 @@ func (t *Transport) markNewGoroutine() { + } + } + ++func (t *Transport) now() time.Time { ++ if t != nil && t.transportTestHooks != nil { ++ return t.transportTestHooks.group.Now() ++ } ++ return time.Now() ++} ++ ++func (t *Transport) timeSince(when time.Time) time.Duration { ++ if t != nil && t.transportTestHooks != nil { ++ return t.now().Sub(when) ++ } ++ return time.Since(when) ++} ++ + // newTimer creates a new time.Timer, or a synthetic timer in tests. + func (t *Transport) newTimer(d time.Duration) timer { + if t.transportTestHooks != nil { +@@ -227,40 +240,26 @@ func (t *Transport) contextWithTimeout(ctx context.Context, d time.Duration) (co + } + + func (t *Transport) maxHeaderListSize() uint32 { +- if t.MaxHeaderListSize == 0 { ++ n := int64(t.MaxHeaderListSize) ++ if t.t1 != nil && t.t1.MaxResponseHeaderBytes != 0 { ++ n = t.t1.MaxResponseHeaderBytes ++ if n > 0 { ++ n = adjustHTTP1MaxHeaderSize(n) ++ } ++ } ++ if n <= 0 { + return 10 << 20 + } +- if t.MaxHeaderListSize == 0xffffffff { ++ if n >= 0xffffffff { + return 0 + } +- return t.MaxHeaderListSize +-} +- +-func (t *Transport) maxFrameReadSize() uint32 { +- if t.MaxReadFrameSize == 0 { +- return 0 // use the default provided by the peer +- } +- if t.MaxReadFrameSize < minMaxFrameSize { +- return minMaxFrameSize +- } +- if t.MaxReadFrameSize > maxFrameSize { +- return maxFrameSize +- } +- return t.MaxReadFrameSize ++ return uint32(n) + } + + func (t *Transport) disableCompression() bool { + return t.DisableCompression || (t.t1 != nil && t.t1.DisableCompression) + } + +-func (t *Transport) pingTimeout() time.Duration { +- if t.PingTimeout == 0 { +- return 15 * time.Second +- } +- return t.PingTimeout +- +-} +- + // ConfigureTransport configures a net/http HTTP/1 Transport to use HTTP/2. + // It returns an error if t1 has already been HTTP/2-enabled. + // +@@ -296,8 +295,8 @@ func configureTransports(t1 *http.Transport) (*Transport, error) { + if !strSliceContains(t1.TLSClientConfig.NextProtos, "http/1.1") { + t1.TLSClientConfig.NextProtos = append(t1.TLSClientConfig.NextProtos, "http/1.1") + } +- upgradeFn := func(authority string, c *tls.Conn) http.RoundTripper { +- addr := authorityAddr("https", authority) ++ upgradeFn := func(scheme, authority string, c net.Conn) http.RoundTripper { ++ addr := authorityAddr(scheme, authority) + if used, err := connPool.addConnIfNeeded(addr, t2, c); err != nil { + go c.Close() + return erringRoundTripper{err} +@@ -308,18 +307,37 @@ func configureTransports(t1 *http.Transport) (*Transport, error) { + // was unknown) + go c.Close() + } ++ if scheme == "http" { ++ return (*unencryptedTransport)(t2) ++ } + return t2 + } +- if m := t1.TLSNextProto; len(m) == 0 { +- t1.TLSNextProto = map[string]func(string, *tls.Conn) http.RoundTripper{ +- "h2": upgradeFn, ++ if t1.TLSNextProto == nil { ++ t1.TLSNextProto = make(map[string]func(string, *tls.Conn) http.RoundTripper) ++ } ++ t1.TLSNextProto[NextProtoTLS] = func(authority string, c *tls.Conn) http.RoundTripper { ++ return upgradeFn("https", authority, c) ++ } ++ // The "unencrypted_http2" TLSNextProto key is used to pass off non-TLS HTTP/2 conns. ++ t1.TLSNextProto[nextProtoUnencryptedHTTP2] = func(authority string, c *tls.Conn) http.RoundTripper { ++ nc, err := unencryptedNetConnFromTLSConn(c) ++ if err != nil { ++ go c.Close() ++ return erringRoundTripper{err} + } +- } else { +- m["h2"] = upgradeFn ++ return upgradeFn("http", authority, nc) + } + return t2, nil + } + ++// unencryptedTransport is a Transport with a RoundTrip method that ++// always permits http:// URLs. ++type unencryptedTransport Transport ++ ++func (t *unencryptedTransport) RoundTrip(req *http.Request) (*http.Response, error) { ++ return (*Transport)(t).RoundTripOpt(req, RoundTripOpt{allowHTTP: true}) ++} ++ + func (t *Transport) connPool() ClientConnPool { + t.connPoolOnce.Do(t.initConnPool) + return t.connPoolOrDef +@@ -339,7 +357,7 @@ type ClientConn struct { + t *Transport + tconn net.Conn // usually *tls.Conn, except specialized impls + tlsState *tls.ConnectionState // nil only for specialized impls +- reused uint32 // whether conn is being reused; atomic ++ atomicReused uint32 // whether conn is being reused; atomic + singleUse bool // whether being used for a single http.Request + getConnCalled bool // used by clientConnPool + +@@ -350,31 +368,54 @@ type ClientConn struct { + idleTimeout time.Duration // or 0 for never + idleTimer timer + +- mu sync.Mutex // guards following +- cond *sync.Cond // hold mu; broadcast on flow/closed changes +- flow outflow // our conn-level flow control quota (cs.outflow is per stream) +- inflow inflow // peer's conn-level flow control +- doNotReuse bool // whether conn is marked to not be reused for any future requests +- closing bool +- closed bool +- seenSettings bool // true if we've seen a settings frame, false otherwise +- wantSettingsAck bool // we sent a SETTINGS frame and haven't heard back +- goAway *GoAwayFrame // if non-nil, the GoAwayFrame we received +- goAwayDebug string // goAway frame's debug data, retained as a string +- streams map[uint32]*clientStream // client-initiated +- streamsReserved int // incr by ReserveNewRequest; decr on RoundTrip +- nextStreamID uint32 +- pendingRequests int // requests blocked and waiting to be sent because len(streams) == maxConcurrentStreams +- pings map[[8]byte]chan struct{} // in flight ping data to notification channel +- br *bufio.Reader +- lastActive time.Time +- lastIdle time.Time // time last idle ++ mu sync.Mutex // guards following ++ cond *sync.Cond // hold mu; broadcast on flow/closed changes ++ flow outflow // our conn-level flow control quota (cs.outflow is per stream) ++ inflow inflow // peer's conn-level flow control ++ doNotReuse bool // whether conn is marked to not be reused for any future requests ++ closing bool ++ closed bool ++ seenSettings bool // true if we've seen a settings frame, false otherwise ++ seenSettingsChan chan struct{} // closed when seenSettings is true or frame reading fails ++ wantSettingsAck bool // we sent a SETTINGS frame and haven't heard back ++ goAway *GoAwayFrame // if non-nil, the GoAwayFrame we received ++ goAwayDebug string // goAway frame's debug data, retained as a string ++ streams map[uint32]*clientStream // client-initiated ++ streamsReserved int // incr by ReserveNewRequest; decr on RoundTrip ++ nextStreamID uint32 ++ pendingRequests int // requests blocked and waiting to be sent because len(streams) == maxConcurrentStreams ++ pings map[[8]byte]chan struct{} // in flight ping data to notification channel ++ br *bufio.Reader ++ lastActive time.Time ++ lastIdle time.Time // time last idle + // Settings from peer: (also guarded by wmu) +- maxFrameSize uint32 +- maxConcurrentStreams uint32 +- peerMaxHeaderListSize uint64 +- peerMaxHeaderTableSize uint32 +- initialWindowSize uint32 ++ maxFrameSize uint32 ++ maxConcurrentStreams uint32 ++ peerMaxHeaderListSize uint64 ++ peerMaxHeaderTableSize uint32 ++ initialWindowSize uint32 ++ initialStreamRecvWindowSize int32 ++ readIdleTimeout time.Duration ++ pingTimeout time.Duration ++ extendedConnectAllowed bool ++ ++ // rstStreamPingsBlocked works around an unfortunate gRPC behavior. ++ // gRPC strictly limits the number of PING frames that it will receive. ++ // The default is two pings per two hours, but the limit resets every time ++ // the gRPC endpoint sends a HEADERS or DATA frame. See golang/go#70575. ++ // ++ // rstStreamPingsBlocked is set after receiving a response to a PING frame ++ // bundled with an RST_STREAM (see pendingResets below), and cleared after ++ // receiving a HEADERS or DATA frame. ++ rstStreamPingsBlocked bool ++ ++ // pendingResets is the number of RST_STREAM frames we have sent to the peer, ++ // without confirming that the peer has received them. When we send a RST_STREAM, ++ // we bundle it with a PING frame, unless a PING is already in flight. We count ++ // the reset stream against the connection's concurrency limit until we get ++ // a PING response. This limits the number of requests we'll try to send to a ++ // completely unresponsive connection. ++ pendingResets int + + // reqHeaderMu is a 1-element semaphore channel controlling access to sending new requests. + // Write to reqHeaderMu to lock it, read from it to unlock. +@@ -432,12 +473,12 @@ type clientStream struct { + sentHeaders bool + + // owned by clientConnReadLoop: +- firstByte bool // got the first response byte +- pastHeaders bool // got first MetaHeadersFrame (actual headers) +- pastTrailers bool // got optional second MetaHeadersFrame (trailers) +- num1xx uint8 // number of 1xx responses seen +- readClosed bool // peer sent an END_STREAM flag +- readAborted bool // read loop reset the stream ++ firstByte bool // got the first response byte ++ pastHeaders bool // got first MetaHeadersFrame (actual headers) ++ pastTrailers bool // got optional second MetaHeadersFrame (trailers) ++ readClosed bool // peer sent an END_STREAM flag ++ readAborted bool // read loop reset the stream ++ totalHeaderSize int64 // total size of 1xx headers seen + + trailer http.Header // accumulated trailers + resTrailer *http.Header // client's Response.Trailer +@@ -499,6 +540,7 @@ func (cs *clientStream) closeReqBodyLocked() { + } + + type stickyErrWriter struct { ++ group synctestGroupInterface + conn net.Conn + timeout time.Duration + err *error +@@ -508,22 +550,9 @@ func (sew stickyErrWriter) Write(p []byte) (n int, err error) { + if *sew.err != nil { + return 0, *sew.err + } +- for { +- if sew.timeout != 0 { +- sew.conn.SetWriteDeadline(time.Now().Add(sew.timeout)) +- } +- nn, err := sew.conn.Write(p[n:]) +- n += nn +- if n < len(p) && nn > 0 && errors.Is(err, os.ErrDeadlineExceeded) { +- // Keep extending the deadline so long as we're making progress. +- continue +- } +- if sew.timeout != 0 { +- sew.conn.SetWriteDeadline(time.Time{}) +- } +- *sew.err = err +- return n, err +- } ++ n, err = writeWithByteTimeout(sew.group, sew.conn, sew.timeout, p) ++ *sew.err = err ++ return n, err + } + + // noCachedConnError is the concrete type of ErrNoCachedConn, which +@@ -554,6 +583,8 @@ type RoundTripOpt struct { + // no cached connection is available, RoundTripOpt + // will return ErrNoCachedConn. + OnlyCachedConn bool ++ ++ allowHTTP bool // allow http:// URLs + } + + func (t *Transport) RoundTrip(req *http.Request) (*http.Response, error) { +@@ -586,7 +617,14 @@ func authorityAddr(scheme string, authority string) (addr string) { + + // RoundTripOpt is like RoundTrip, but takes options. + func (t *Transport) RoundTripOpt(req *http.Request, opt RoundTripOpt) (*http.Response, error) { +- if !(req.URL.Scheme == "https" || (req.URL.Scheme == "http" && t.AllowHTTP)) { ++ switch req.URL.Scheme { ++ case "https": ++ // Always okay. ++ case "http": ++ if !t.AllowHTTP && !opt.allowHTTP { ++ return nil, errors.New("http2: unencrypted HTTP/2 not enabled") ++ } ++ default: + return nil, errors.New("http2: unsupported scheme") + } + +@@ -597,7 +635,7 @@ func (t *Transport) RoundTripOpt(req *http.Request, opt RoundTripOpt) (*http.Res + t.vlogf("http2: Transport failed to get client conn for %s: %v", addr, err) + return nil, err + } +- reused := !atomic.CompareAndSwapUint32(&cc.reused, 0, 1) ++ reused := !atomic.CompareAndSwapUint32(&cc.atomicReused, 0, 1) + traceGotConn(req, cc, reused) + res, err := cc.RoundTrip(req) + if err != nil && retry <= 6 { +@@ -622,6 +660,22 @@ func (t *Transport) RoundTripOpt(req *http.Request, opt RoundTripOpt) (*http.Res + } + } + } ++ if err == errClientConnNotEstablished { ++ // This ClientConn was created recently, ++ // this is the first request to use it, ++ // and the connection is closed and not usable. ++ // ++ // In this state, cc.idleTimer will remove the conn from the pool ++ // when it fires. Stop the timer and remove it here so future requests ++ // won't try to use this connection. ++ // ++ // If the timer has already fired and we're racing it, the redundant ++ // call to MarkDead is harmless. ++ if cc.idleTimer != nil { ++ cc.idleTimer.Stop() ++ } ++ t.connPool().MarkDead(cc) ++ } + if err != nil { + t.vlogf("RoundTrip failure: %v", err) + return nil, err +@@ -640,9 +694,10 @@ func (t *Transport) CloseIdleConnections() { + } + + var ( +- errClientConnClosed = errors.New("http2: client conn is closed") +- errClientConnUnusable = errors.New("http2: client conn not usable") +- errClientConnGotGoAway = errors.New("http2: Transport received Server's graceful shutdown GOAWAY") ++ errClientConnClosed = errors.New("http2: client conn is closed") ++ errClientConnUnusable = errors.New("http2: client conn not usable") ++ errClientConnNotEstablished = errors.New("http2: client conn could not be established") ++ errClientConnGotGoAway = errors.New("http2: Transport received Server's graceful shutdown GOAWAY") + ) + + // shouldRetryRequest is called by RoundTrip when a request fails to get +@@ -758,44 +813,38 @@ func (t *Transport) expectContinueTimeout() time.Duration { + return t.t1.ExpectContinueTimeout + } + +-func (t *Transport) maxDecoderHeaderTableSize() uint32 { +- if v := t.MaxDecoderHeaderTableSize; v > 0 { +- return v +- } +- return initialHeaderTableSize +-} +- +-func (t *Transport) maxEncoderHeaderTableSize() uint32 { +- if v := t.MaxEncoderHeaderTableSize; v > 0 { +- return v +- } +- return initialHeaderTableSize +-} +- + func (t *Transport) NewClientConn(c net.Conn) (*ClientConn, error) { + return t.newClientConn(c, t.disableKeepAlives()) + } + + func (t *Transport) newClientConn(c net.Conn, singleUse bool) (*ClientConn, error) { ++ conf := configFromTransport(t) + cc := &ClientConn{ +- t: t, +- tconn: c, +- readerDone: make(chan struct{}), +- nextStreamID: 1, +- maxFrameSize: 16 << 10, // spec default +- initialWindowSize: 65535, // spec default +- maxConcurrentStreams: initialMaxConcurrentStreams, // "infinite", per spec. Use a smaller value until we have received server settings. +- peerMaxHeaderListSize: 0xffffffffffffffff, // "infinite", per spec. Use 2^64-1 instead. +- streams: make(map[uint32]*clientStream), +- singleUse: singleUse, +- wantSettingsAck: true, +- pings: make(map[[8]byte]chan struct{}), +- reqHeaderMu: make(chan struct{}, 1), +- } ++ t: t, ++ tconn: c, ++ readerDone: make(chan struct{}), ++ nextStreamID: 1, ++ maxFrameSize: 16 << 10, // spec default ++ initialWindowSize: 65535, // spec default ++ initialStreamRecvWindowSize: conf.MaxUploadBufferPerStream, ++ maxConcurrentStreams: initialMaxConcurrentStreams, // "infinite", per spec. Use a smaller value until we have received server settings. ++ peerMaxHeaderListSize: 0xffffffffffffffff, // "infinite", per spec. Use 2^64-1 instead. ++ streams: make(map[uint32]*clientStream), ++ singleUse: singleUse, ++ seenSettingsChan: make(chan struct{}), ++ wantSettingsAck: true, ++ readIdleTimeout: conf.SendPingTimeout, ++ pingTimeout: conf.PingTimeout, ++ pings: make(map[[8]byte]chan struct{}), ++ reqHeaderMu: make(chan struct{}, 1), ++ lastActive: t.now(), ++ } ++ var group synctestGroupInterface + if t.transportTestHooks != nil { + t.markNewGoroutine() + t.transportTestHooks.newclientconn(cc) + c = cc.tconn ++ group = t.group + } + if VerboseLogs { + t.vlogf("http2: Transport creating client conn %p to %v", cc, c.RemoteAddr()) +@@ -807,24 +856,23 @@ func (t *Transport) newClientConn(c net.Conn, singleUse bool) (*ClientConn, erro + // TODO: adjust this writer size to account for frame size + + // MTU + crypto/tls record padding. + cc.bw = bufio.NewWriter(stickyErrWriter{ ++ group: group, + conn: c, +- timeout: t.WriteByteTimeout, ++ timeout: conf.WriteByteTimeout, + err: &cc.werr, + }) + cc.br = bufio.NewReader(c) + cc.fr = NewFramer(cc.bw, cc.br) +- if t.maxFrameReadSize() != 0 { +- cc.fr.SetMaxReadFrameSize(t.maxFrameReadSize()) +- } ++ cc.fr.SetMaxReadFrameSize(conf.MaxReadFrameSize) + if t.CountError != nil { + cc.fr.countError = t.CountError + } +- maxHeaderTableSize := t.maxDecoderHeaderTableSize() ++ maxHeaderTableSize := conf.MaxDecoderHeaderTableSize + cc.fr.ReadMetaHeaders = hpack.NewDecoder(maxHeaderTableSize, nil) + cc.fr.MaxHeaderListSize = t.maxHeaderListSize() + + cc.henc = hpack.NewEncoder(&cc.hbuf) +- cc.henc.SetMaxDynamicTableSizeLimit(t.maxEncoderHeaderTableSize()) ++ cc.henc.SetMaxDynamicTableSizeLimit(conf.MaxEncoderHeaderTableSize) + cc.peerMaxHeaderTableSize = initialHeaderTableSize + + if cs, ok := c.(connectionStater); ok { +@@ -834,11 +882,9 @@ func (t *Transport) newClientConn(c net.Conn, singleUse bool) (*ClientConn, erro + + initialSettings := []Setting{ + {ID: SettingEnablePush, Val: 0}, +- {ID: SettingInitialWindowSize, Val: transportDefaultStreamFlow}, +- } +- if max := t.maxFrameReadSize(); max != 0 { +- initialSettings = append(initialSettings, Setting{ID: SettingMaxFrameSize, Val: max}) ++ {ID: SettingInitialWindowSize, Val: uint32(cc.initialStreamRecvWindowSize)}, + } ++ initialSettings = append(initialSettings, Setting{ID: SettingMaxFrameSize, Val: conf.MaxReadFrameSize}) + if max := t.maxHeaderListSize(); max != 0 { + initialSettings = append(initialSettings, Setting{ID: SettingMaxHeaderListSize, Val: max}) + } +@@ -848,8 +894,8 @@ func (t *Transport) newClientConn(c net.Conn, singleUse bool) (*ClientConn, erro + + cc.bw.Write(clientPreface) + cc.fr.WriteSettings(initialSettings...) +- cc.fr.WriteWindowUpdate(0, transportDefaultConnFlow) +- cc.inflow.init(transportDefaultConnFlow + initialWindowSize) ++ cc.fr.WriteWindowUpdate(0, uint32(conf.MaxUploadBufferPerConnection)) ++ cc.inflow.init(conf.MaxUploadBufferPerConnection + initialWindowSize) + cc.bw.Flush() + if cc.werr != nil { + cc.Close() +@@ -867,7 +913,7 @@ func (t *Transport) newClientConn(c net.Conn, singleUse bool) (*ClientConn, erro + } + + func (cc *ClientConn) healthCheck() { +- pingTimeout := cc.t.pingTimeout() ++ pingTimeout := cc.pingTimeout + // We don't need to periodically ping in the health check, because the readLoop of ClientConn will + // trigger the healthCheck again if there is no frame received. + ctx, cancel := cc.t.contextWithTimeout(context.Background(), pingTimeout) +@@ -995,7 +1041,7 @@ func (cc *ClientConn) State() ClientConnState { + return ClientConnState{ + Closed: cc.closed, + Closing: cc.closing || cc.singleUse || cc.doNotReuse || cc.goAway != nil, +- StreamsActive: len(cc.streams), ++ StreamsActive: len(cc.streams) + cc.pendingResets, + StreamsReserved: cc.streamsReserved, + StreamsPending: cc.pendingRequests, + LastIdle: cc.lastIdle, +@@ -1027,16 +1073,38 @@ func (cc *ClientConn) idleStateLocked() (st clientConnIdleState) { + // writing it. + maxConcurrentOkay = true + } else { +- maxConcurrentOkay = int64(len(cc.streams)+cc.streamsReserved+1) <= int64(cc.maxConcurrentStreams) ++ // We can take a new request if the total of ++ // - active streams; ++ // - reservation slots for new streams; and ++ // - streams for which we have sent a RST_STREAM and a PING, ++ // but received no subsequent frame ++ // is less than the concurrency limit. ++ maxConcurrentOkay = cc.currentRequestCountLocked() < int(cc.maxConcurrentStreams) + } + + st.canTakeNewRequest = cc.goAway == nil && !cc.closed && !cc.closing && maxConcurrentOkay && + !cc.doNotReuse && + int64(cc.nextStreamID)+2*int64(cc.pendingRequests) < math.MaxInt32 && + !cc.tooIdleLocked() ++ ++ // If this connection has never been used for a request and is closed, ++ // then let it take a request (which will fail). ++ // ++ // This avoids a situation where an error early in a connection's lifetime ++ // goes unreported. ++ if cc.nextStreamID == 1 && cc.streamsReserved == 0 && cc.closed { ++ st.canTakeNewRequest = true ++ } ++ + return + } + ++// currentRequestCountLocked reports the number of concurrency slots currently in use, ++// including active streams, reserved slots, and reset streams waiting for acknowledgement. ++func (cc *ClientConn) currentRequestCountLocked() int { ++ return len(cc.streams) + cc.streamsReserved + cc.pendingResets ++} ++ + func (cc *ClientConn) canTakeNewRequestLocked() bool { + st := cc.idleStateLocked() + return st.canTakeNewRequest +@@ -1049,7 +1117,7 @@ func (cc *ClientConn) tooIdleLocked() bool { + // times are compared based on their wall time. We don't want + // to reuse a connection that's been sitting idle during + // VM/laptop suspend if monotonic time was also frozen. +- return cc.idleTimeout != 0 && !cc.lastIdle.IsZero() && time.Since(cc.lastIdle.Round(0)) > cc.idleTimeout ++ return cc.idleTimeout != 0 && !cc.lastIdle.IsZero() && cc.t.timeSince(cc.lastIdle.Round(0)) > cc.idleTimeout + } + + // onIdleTimeout is called from a time.AfterFunc goroutine. It will +@@ -1411,6 +1479,8 @@ func (cs *clientStream) doRequest(req *http.Request, streamf func(*clientStream) + cs.cleanupWriteRequest(err) + } + ++var errExtendedConnectNotSupported = errors.New("net/http: extended connect not supported by peer") ++ + // writeRequest sends a request. + // + // It returns nil after the request is written, the response read, +@@ -1426,12 +1496,31 @@ func (cs *clientStream) writeRequest(req *http.Request, streamf func(*clientStre + return err + } + ++ // wait for setting frames to be received, a server can change this value later, ++ // but we just wait for the first settings frame ++ var isExtendedConnect bool ++ if req.Method == "CONNECT" && req.Header.Get(":protocol") != "" { ++ isExtendedConnect = true ++ } ++ + // Acquire the new-request lock by writing to reqHeaderMu. + // This lock guards the critical section covering allocating a new stream ID + // (requires mu) and creating the stream (requires wmu). + if cc.reqHeaderMu == nil { + panic("RoundTrip on uninitialized ClientConn") // for tests + } ++ if isExtendedConnect { ++ select { ++ case <-cs.reqCancel: ++ return errRequestCanceled ++ case <-ctx.Done(): ++ return ctx.Err() ++ case <-cc.seenSettingsChan: ++ if !cc.extendedConnectAllowed { ++ return errExtendedConnectNotSupported ++ } ++ } ++ } + select { + case cc.reqHeaderMu <- struct{}{}: + case <-cs.reqCancel: +@@ -1613,6 +1702,7 @@ func (cs *clientStream) cleanupWriteRequest(err error) { + cs.reqBodyClosed = make(chan struct{}) + } + bodyClosed := cs.reqBodyClosed ++ closeOnIdle := cc.singleUse || cc.doNotReuse || cc.t.disableKeepAlives() || cc.goAway != nil + cc.mu.Unlock() + if mustCloseBody { + cs.reqBody.Close() +@@ -1637,16 +1727,44 @@ func (cs *clientStream) cleanupWriteRequest(err error) { + if cs.sentHeaders { + if se, ok := err.(StreamError); ok { + if se.Cause != errFromPeer { +- cc.writeStreamReset(cs.ID, se.Code, err) ++ cc.writeStreamReset(cs.ID, se.Code, false, err) + } + } else { +- cc.writeStreamReset(cs.ID, ErrCodeCancel, err) ++ // We're cancelling an in-flight request. ++ // ++ // This could be due to the server becoming unresponsive. ++ // To avoid sending too many requests on a dead connection, ++ // we let the request continue to consume a concurrency slot ++ // until we can confirm the server is still responding. ++ // We do this by sending a PING frame along with the RST_STREAM ++ // (unless a ping is already in flight). ++ // ++ // For simplicity, we don't bother tracking the PING payload: ++ // We reset cc.pendingResets any time we receive a PING ACK. ++ // ++ // We skip this if the conn is going to be closed on idle, ++ // because it's short lived and will probably be closed before ++ // we get the ping response. ++ ping := false ++ if !closeOnIdle { ++ cc.mu.Lock() ++ // rstStreamPingsBlocked works around a gRPC behavior: ++ // see comment on the field for details. ++ if !cc.rstStreamPingsBlocked { ++ if cc.pendingResets == 0 { ++ ping = true ++ } ++ cc.pendingResets++ ++ } ++ cc.mu.Unlock() ++ } ++ cc.writeStreamReset(cs.ID, ErrCodeCancel, ping, err) + } + } + cs.bufPipe.CloseWithError(err) // no-op if already closed + } else { + if cs.sentHeaders && !cs.sentEndStream { +- cc.writeStreamReset(cs.ID, ErrCodeNo, nil) ++ cc.writeStreamReset(cs.ID, ErrCodeNo, false, nil) + } + cs.bufPipe.CloseWithError(errRequestCanceled) + } +@@ -1668,12 +1786,17 @@ func (cs *clientStream) cleanupWriteRequest(err error) { + // Must hold cc.mu. + func (cc *ClientConn) awaitOpenSlotForStreamLocked(cs *clientStream) error { + for { +- cc.lastActive = time.Now() ++ if cc.closed && cc.nextStreamID == 1 && cc.streamsReserved == 0 { ++ // This is the very first request sent to this connection. ++ // Return a fatal error which aborts the retry loop. ++ return errClientConnNotEstablished ++ } ++ cc.lastActive = cc.t.now() + if cc.closed || !cc.canTakeNewRequestLocked() { + return errClientConnUnusable + } + cc.lastIdle = time.Time{} +- if int64(len(cc.streams)) < int64(cc.maxConcurrentStreams) { ++ if cc.currentRequestCountLocked() < int(cc.maxConcurrentStreams) { + return nil + } + cc.pendingRequests++ +@@ -1945,7 +2068,7 @@ func (cs *clientStream) awaitFlowControl(maxBytes int) (taken int32, err error) + + func validateHeaders(hdrs http.Header) string { + for k, vv := range hdrs { +- if !httpguts.ValidHeaderFieldName(k) { ++ if !httpguts.ValidHeaderFieldName(k) && k != ":protocol" { + return fmt.Sprintf("name %q", k) + } + for _, v := range vv { +@@ -1961,6 +2084,10 @@ func validateHeaders(hdrs http.Header) string { + + var errNilRequestURL = errors.New("http2: Request.URI is nil") + ++func isNormalConnect(req *http.Request) bool { ++ return req.Method == "CONNECT" && req.Header.Get(":protocol") == "" ++} ++ + // requires cc.wmu be held. + func (cc *ClientConn) encodeHeaders(req *http.Request, addGzipHeader bool, trailers string, contentLength int64) ([]byte, error) { + cc.hbuf.Reset() +@@ -1981,7 +2108,7 @@ func (cc *ClientConn) encodeHeaders(req *http.Request, addGzipHeader bool, trail + } + + var path string +- if req.Method != "CONNECT" { ++ if !isNormalConnect(req) { + path = req.URL.RequestURI() + if !validPseudoPath(path) { + orig := path +@@ -2018,7 +2145,7 @@ func (cc *ClientConn) encodeHeaders(req *http.Request, addGzipHeader bool, trail + m = http.MethodGet + } + f(":method", m) +- if req.Method != "CONNECT" { ++ if !isNormalConnect(req) { + f(":path", path) + f(":scheme", req.URL.Scheme) + } +@@ -2199,7 +2326,7 @@ type resAndError struct { + func (cc *ClientConn) addStreamLocked(cs *clientStream) { + cs.flow.add(int32(cc.initialWindowSize)) + cs.flow.setConnFlow(&cc.flow) +- cs.inflow.init(transportDefaultStreamFlow) ++ cs.inflow.init(cc.initialStreamRecvWindowSize) + cs.ID = cc.nextStreamID + cc.nextStreamID += 2 + cc.streams[cs.ID] = cs +@@ -2215,10 +2342,10 @@ func (cc *ClientConn) forgetStreamID(id uint32) { + if len(cc.streams) != slen-1 { + panic("forgetting unknown stream id") + } +- cc.lastActive = time.Now() ++ cc.lastActive = cc.t.now() + if len(cc.streams) == 0 && cc.idleTimer != nil { + cc.idleTimer.Reset(cc.idleTimeout) +- cc.lastIdle = time.Now() ++ cc.lastIdle = cc.t.now() + } + // Wake up writeRequestBody via clientStream.awaitFlowControl and + // wake up RoundTrip if there is a pending request. +@@ -2278,7 +2405,6 @@ func isEOFOrNetReadError(err error) bool { + + func (rl *clientConnReadLoop) cleanup() { + cc := rl.cc +- cc.t.connPool().MarkDead(cc) + defer cc.closeConn() + defer close(cc.readerDone) + +@@ -2302,6 +2428,24 @@ func (rl *clientConnReadLoop) cleanup() { + } + cc.closed = true + ++ // If the connection has never been used, and has been open for only a short time, ++ // leave it in the connection pool for a little while. ++ // ++ // This avoids a situation where new connections are constantly created, ++ // added to the pool, fail, and are removed from the pool, without any error ++ // being surfaced to the user. ++ const unusedWaitTime = 5 * time.Second ++ idleTime := cc.t.now().Sub(cc.lastActive) ++ if atomic.LoadUint32(&cc.atomicReused) == 0 && idleTime < unusedWaitTime { ++ cc.idleTimer = cc.t.afterFunc(unusedWaitTime-idleTime, func() { ++ cc.t.connPool().MarkDead(cc) ++ }) ++ } else { ++ cc.mu.Unlock() // avoid any deadlocks in MarkDead ++ cc.t.connPool().MarkDead(cc) ++ cc.mu.Lock() ++ } ++ + for _, cs := range cc.streams { + select { + case <-cs.peerClosed: +@@ -2345,7 +2489,7 @@ func (cc *ClientConn) countReadFrameError(err error) { + func (rl *clientConnReadLoop) run() error { + cc := rl.cc + gotSettings := false +- readIdleTimeout := cc.t.ReadIdleTimeout ++ readIdleTimeout := cc.readIdleTimeout + var t timer + if readIdleTimeout != 0 { + t = cc.t.afterFunc(readIdleTimeout, cc.healthCheck) +@@ -2359,7 +2503,7 @@ func (rl *clientConnReadLoop) run() error { + cc.vlogf("http2: Transport readFrame error on conn %p: (%T) %v", cc, err, err) + } + if se, ok := err.(StreamError); ok { +- if cs := rl.streamByID(se.StreamID); cs != nil { ++ if cs := rl.streamByID(se.StreamID, notHeaderOrDataFrame); cs != nil { + if se.Cause == nil { + se.Cause = cc.fr.errDetail + } +@@ -2405,13 +2549,16 @@ func (rl *clientConnReadLoop) run() error { + if VerboseLogs { + cc.vlogf("http2: Transport conn %p received error from processing frame %v: %v", cc, summarizeFrame(f), err) + } ++ if !cc.seenSettings { ++ close(cc.seenSettingsChan) ++ } + return err + } + } + } + + func (rl *clientConnReadLoop) processHeaders(f *MetaHeadersFrame) error { +- cs := rl.streamByID(f.StreamID) ++ cs := rl.streamByID(f.StreamID, headerOrDataFrame) + if cs == nil { + // We'd get here if we canceled a request while the + // server had its response still in flight. So if this +@@ -2529,15 +2676,34 @@ func (rl *clientConnReadLoop) handleResponse(cs *clientStream, f *MetaHeadersFra + if f.StreamEnded() { + return nil, errors.New("1xx informational response with END_STREAM flag") + } +- cs.num1xx++ +- const max1xxResponses = 5 // arbitrary bound on number of informational responses, same as net/http +- if cs.num1xx > max1xxResponses { +- return nil, errors.New("http2: too many 1xx informational responses") +- } + if fn := cs.get1xxTraceFunc(); fn != nil { ++ // If the 1xx response is being delivered to the user, ++ // then they're responsible for limiting the number ++ // of responses. + if err := fn(statusCode, textproto.MIMEHeader(header)); err != nil { + return nil, err + } ++ } else { ++ // If the user didn't examine the 1xx response, then we ++ // limit the size of all 1xx headers. ++ // ++ // This differs a bit from the HTTP/1 implementation, which ++ // limits the size of all 1xx headers plus the final response. ++ // Use the larger limit of MaxHeaderListSize and ++ // net/http.Transport.MaxResponseHeaderBytes. ++ limit := int64(cs.cc.t.maxHeaderListSize()) ++ if t1 := cs.cc.t.t1; t1 != nil && t1.MaxResponseHeaderBytes > limit { ++ limit = t1.MaxResponseHeaderBytes ++ } ++ for _, h := range f.Fields { ++ cs.totalHeaderSize += int64(h.Size()) ++ } ++ if cs.totalHeaderSize > limit { ++ if VerboseLogs { ++ log.Printf("http2: 1xx informational responses too large") ++ } ++ return nil, errors.New("header list too large") ++ } + } + if statusCode == 100 { + traceGot100Continue(cs.trace) +@@ -2721,7 +2887,7 @@ func (b transportResponseBody) Close() error { + + func (rl *clientConnReadLoop) processData(f *DataFrame) error { + cc := rl.cc +- cs := rl.streamByID(f.StreamID) ++ cs := rl.streamByID(f.StreamID, headerOrDataFrame) + data := f.Data() + if cs == nil { + cc.mu.Lock() +@@ -2856,9 +3022,22 @@ func (rl *clientConnReadLoop) endStreamError(cs *clientStream, err error) { + cs.abortStream(err) + } + +-func (rl *clientConnReadLoop) streamByID(id uint32) *clientStream { ++// Constants passed to streamByID for documentation purposes. ++const ( ++ headerOrDataFrame = true ++ notHeaderOrDataFrame = false ++) ++ ++// streamByID returns the stream with the given id, or nil if no stream has that id. ++// If headerOrData is true, it clears rst.StreamPingsBlocked. ++func (rl *clientConnReadLoop) streamByID(id uint32, headerOrData bool) *clientStream { + rl.cc.mu.Lock() + defer rl.cc.mu.Unlock() ++ if headerOrData { ++ // Work around an unfortunate gRPC behavior. ++ // See comment on ClientConn.rstStreamPingsBlocked for details. ++ rl.cc.rstStreamPingsBlocked = false ++ } + cs := rl.cc.streams[id] + if cs != nil && !cs.readAborted { + return cs +@@ -2952,6 +3131,21 @@ func (rl *clientConnReadLoop) processSettingsNoWrite(f *SettingsFrame) error { + case SettingHeaderTableSize: + cc.henc.SetMaxDynamicTableSize(s.Val) + cc.peerMaxHeaderTableSize = s.Val ++ case SettingEnableConnectProtocol: ++ if err := s.Valid(); err != nil { ++ return err ++ } ++ // If the peer wants to send us SETTINGS_ENABLE_CONNECT_PROTOCOL, ++ // we require that it do so in the first SETTINGS frame. ++ // ++ // When we attempt to use extended CONNECT, we wait for the first ++ // SETTINGS frame to see if the server supports it. If we let the ++ // server enable the feature with a later SETTINGS frame, then ++ // users will see inconsistent results depending on whether we've ++ // seen that frame or not. ++ if !cc.seenSettings { ++ cc.extendedConnectAllowed = s.Val == 1 ++ } + default: + cc.vlogf("Unhandled Setting: %v", s) + } +@@ -2969,6 +3163,7 @@ func (rl *clientConnReadLoop) processSettingsNoWrite(f *SettingsFrame) error { + // connection can establish to our default. + cc.maxConcurrentStreams = defaultMaxConcurrentStreams + } ++ close(cc.seenSettingsChan) + cc.seenSettings = true + } + +@@ -2977,7 +3172,7 @@ func (rl *clientConnReadLoop) processSettingsNoWrite(f *SettingsFrame) error { + + func (rl *clientConnReadLoop) processWindowUpdate(f *WindowUpdateFrame) error { + cc := rl.cc +- cs := rl.streamByID(f.StreamID) ++ cs := rl.streamByID(f.StreamID, notHeaderOrDataFrame) + if f.StreamID != 0 && cs == nil { + return nil + } +@@ -3006,7 +3201,7 @@ func (rl *clientConnReadLoop) processWindowUpdate(f *WindowUpdateFrame) error { + } + + func (rl *clientConnReadLoop) processResetStream(f *RSTStreamFrame) error { +- cs := rl.streamByID(f.StreamID) ++ cs := rl.streamByID(f.StreamID, notHeaderOrDataFrame) + if cs == nil { + // TODO: return error if server tries to RST_STREAM an idle stream + return nil +@@ -3081,6 +3276,12 @@ func (rl *clientConnReadLoop) processPing(f *PingFrame) error { + close(c) + delete(cc.pings, f.Data) + } ++ if cc.pendingResets > 0 { ++ // See clientStream.cleanupWriteRequest. ++ cc.pendingResets = 0 ++ cc.rstStreamPingsBlocked = true ++ cc.cond.Broadcast() ++ } + return nil + } + cc := rl.cc +@@ -3103,13 +3304,20 @@ func (rl *clientConnReadLoop) processPushPromise(f *PushPromiseFrame) error { + return ConnectionError(ErrCodeProtocol) + } + +-func (cc *ClientConn) writeStreamReset(streamID uint32, code ErrCode, err error) { ++// writeStreamReset sends a RST_STREAM frame. ++// When ping is true, it also sends a PING frame with a random payload. ++func (cc *ClientConn) writeStreamReset(streamID uint32, code ErrCode, ping bool, err error) { + // TODO: map err to more interesting error codes, once the + // HTTP community comes up with some. But currently for + // RST_STREAM there's no equivalent to GOAWAY frame's debug + // data, and the error codes are all pretty vague ("cancel"). + cc.wmu.Lock() + cc.fr.WriteRSTStream(streamID, code) ++ if ping { ++ var payload [8]byte ++ rand.Read(payload[:]) ++ cc.fr.WritePing(false, payload) ++ } + cc.bw.Flush() + cc.wmu.Unlock() + } +@@ -3263,7 +3471,7 @@ func traceGotConn(req *http.Request, cc *ClientConn, reused bool) { + cc.mu.Lock() + ci.WasIdle = len(cc.streams) == 0 && reused + if ci.WasIdle && !cc.lastActive.IsZero() { +- ci.IdleTime = time.Since(cc.lastActive) ++ ci.IdleTime = cc.t.timeSince(cc.lastActive) + } + cc.mu.Unlock() + +diff --git a/vendor/golang.org/x/net/http2/unencrypted.go b/vendor/golang.org/x/net/http2/unencrypted.go +new file mode 100644 +index 0000000..b2de211 +--- /dev/null ++++ b/vendor/golang.org/x/net/http2/unencrypted.go +@@ -0,0 +1,32 @@ ++// Copyright 2024 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 http2 ++ ++import ( ++ "crypto/tls" ++ "errors" ++ "net" ++) ++ ++const nextProtoUnencryptedHTTP2 = "unencrypted_http2" ++ ++// unencryptedNetConnFromTLSConn retrieves a net.Conn wrapped in a *tls.Conn. ++// ++// TLSNextProto functions accept a *tls.Conn. ++// ++// When passing an unencrypted HTTP/2 connection to a TLSNextProto function, ++// we pass a *tls.Conn with an underlying net.Conn containing the unencrypted connection. ++// To be extra careful about mistakes (accidentally dropping TLS encryption in a place ++// where we want it), the tls.Conn contains a net.Conn with an UnencryptedNetConn method ++// that returns the actual connection we want to use. ++func unencryptedNetConnFromTLSConn(tc *tls.Conn) (net.Conn, error) { ++ conner, ok := tc.NetConn().(interface { ++ UnencryptedNetConn() net.Conn ++ }) ++ if !ok { ++ return nil, errors.New("http2: TLS conn unexpectedly found in unencrypted handoff") ++ } ++ return conner.UnencryptedNetConn(), nil ++} +diff --git a/vendor/golang.org/x/net/http2/write.go b/vendor/golang.org/x/net/http2/write.go +index 33f6139..6ff6bee 100644 +--- a/vendor/golang.org/x/net/http2/write.go ++++ b/vendor/golang.org/x/net/http2/write.go +@@ -131,6 +131,16 @@ func (se StreamError) writeFrame(ctx writeContext) error { + + func (se StreamError) staysWithinBuffer(max int) bool { return frameHeaderLen+4 <= max } + ++type writePing struct { ++ data [8]byte ++} ++ ++func (w writePing) writeFrame(ctx writeContext) error { ++ return ctx.Framer().WritePing(false, w.data) ++} ++ ++func (w writePing) staysWithinBuffer(max int) bool { return frameHeaderLen+len(w.data) <= max } ++ + type writePingAck struct{ pf *PingFrame } + + func (w writePingAck) writeFrame(ctx writeContext) error { +diff --git a/vendor/golang.org/x/sys/unix/README.md b/vendor/golang.org/x/sys/unix/README.md +index 7d3c060..6e08a76 100644 +--- a/vendor/golang.org/x/sys/unix/README.md ++++ b/vendor/golang.org/x/sys/unix/README.md +@@ -156,7 +156,7 @@ from the generated architecture-specific files listed below, and merge these + into a common file for each OS. + + The merge is performed in the following steps: +-1. Construct the set of common code that is idential in all architecture-specific files. ++1. Construct the set of common code that is identical in all architecture-specific files. + 2. Write this common code to the merged file. + 3. Remove the common code from all architecture-specific files. + +diff --git a/vendor/golang.org/x/sys/unix/ioctl_linux.go b/vendor/golang.org/x/sys/unix/ioctl_linux.go +index dbe680e..7ca4fa1 100644 +--- a/vendor/golang.org/x/sys/unix/ioctl_linux.go ++++ b/vendor/golang.org/x/sys/unix/ioctl_linux.go +@@ -58,6 +58,102 @@ func IoctlGetEthtoolDrvinfo(fd int, ifname string) (*EthtoolDrvinfo, error) { + return &value, err + } + ++// IoctlGetEthtoolTsInfo fetches ethtool timestamping and PHC ++// association for the network device specified by ifname. ++func IoctlGetEthtoolTsInfo(fd int, ifname string) (*EthtoolTsInfo, error) { ++ ifr, err := NewIfreq(ifname) ++ if err != nil { ++ return nil, err ++ } ++ ++ value := EthtoolTsInfo{Cmd: ETHTOOL_GET_TS_INFO} ++ ifrd := ifr.withData(unsafe.Pointer(&value)) ++ ++ err = ioctlIfreqData(fd, SIOCETHTOOL, &ifrd) ++ return &value, err ++} ++ ++// IoctlGetHwTstamp retrieves the hardware timestamping configuration ++// for the network device specified by ifname. ++func IoctlGetHwTstamp(fd int, ifname string) (*HwTstampConfig, error) { ++ ifr, err := NewIfreq(ifname) ++ if err != nil { ++ return nil, err ++ } ++ ++ value := HwTstampConfig{} ++ ifrd := ifr.withData(unsafe.Pointer(&value)) ++ ++ err = ioctlIfreqData(fd, SIOCGHWTSTAMP, &ifrd) ++ return &value, err ++} ++ ++// IoctlSetHwTstamp updates the hardware timestamping configuration for ++// the network device specified by ifname. ++func IoctlSetHwTstamp(fd int, ifname string, cfg *HwTstampConfig) error { ++ ifr, err := NewIfreq(ifname) ++ if err != nil { ++ return err ++ } ++ ifrd := ifr.withData(unsafe.Pointer(cfg)) ++ return ioctlIfreqData(fd, SIOCSHWTSTAMP, &ifrd) ++} ++ ++// FdToClockID derives the clock ID from the file descriptor number ++// - see clock_gettime(3), FD_TO_CLOCKID macros. The resulting ID is ++// suitable for system calls like ClockGettime. ++func FdToClockID(fd int) int32 { return int32((int(^fd) << 3) | 3) } ++ ++// IoctlPtpClockGetcaps returns the description of a given PTP device. ++func IoctlPtpClockGetcaps(fd int) (*PtpClockCaps, error) { ++ var value PtpClockCaps ++ err := ioctlPtr(fd, PTP_CLOCK_GETCAPS2, unsafe.Pointer(&value)) ++ return &value, err ++} ++ ++// IoctlPtpSysOffsetPrecise returns a description of the clock ++// offset compared to the system clock. ++func IoctlPtpSysOffsetPrecise(fd int) (*PtpSysOffsetPrecise, error) { ++ var value PtpSysOffsetPrecise ++ err := ioctlPtr(fd, PTP_SYS_OFFSET_PRECISE2, unsafe.Pointer(&value)) ++ return &value, err ++} ++ ++// IoctlPtpSysOffsetExtended returns an extended description of the ++// clock offset compared to the system clock. The samples parameter ++// specifies the desired number of measurements. ++func IoctlPtpSysOffsetExtended(fd int, samples uint) (*PtpSysOffsetExtended, error) { ++ value := PtpSysOffsetExtended{Samples: uint32(samples)} ++ err := ioctlPtr(fd, PTP_SYS_OFFSET_EXTENDED2, unsafe.Pointer(&value)) ++ return &value, err ++} ++ ++// IoctlPtpPinGetfunc returns the configuration of the specified ++// I/O pin on given PTP device. ++func IoctlPtpPinGetfunc(fd int, index uint) (*PtpPinDesc, error) { ++ value := PtpPinDesc{Index: uint32(index)} ++ err := ioctlPtr(fd, PTP_PIN_GETFUNC2, unsafe.Pointer(&value)) ++ return &value, err ++} ++ ++// IoctlPtpPinSetfunc updates configuration of the specified PTP ++// I/O pin. ++func IoctlPtpPinSetfunc(fd int, pd *PtpPinDesc) error { ++ return ioctlPtr(fd, PTP_PIN_SETFUNC2, unsafe.Pointer(pd)) ++} ++ ++// IoctlPtpPeroutRequest configures the periodic output mode of the ++// PTP I/O pins. ++func IoctlPtpPeroutRequest(fd int, r *PtpPeroutRequest) error { ++ return ioctlPtr(fd, PTP_PEROUT_REQUEST2, unsafe.Pointer(r)) ++} ++ ++// IoctlPtpExttsRequest configures the external timestamping mode ++// of the PTP I/O pins. ++func IoctlPtpExttsRequest(fd int, r *PtpExttsRequest) error { ++ return ioctlPtr(fd, PTP_EXTTS_REQUEST2, unsafe.Pointer(r)) ++} ++ + // IoctlGetWatchdogInfo fetches information about a watchdog device from the + // Linux watchdog API. For more information, see: + // https://www.kernel.org/doc/html/latest/watchdog/watchdog-api.html. +diff --git a/vendor/golang.org/x/sys/unix/mkerrors.sh b/vendor/golang.org/x/sys/unix/mkerrors.sh +index d07dd09..6ab02b6 100644 +--- a/vendor/golang.org/x/sys/unix/mkerrors.sh ++++ b/vendor/golang.org/x/sys/unix/mkerrors.sh +@@ -158,6 +158,16 @@ includes_Linux=' + #endif + #define _GNU_SOURCE + ++// See the description in unix/linux/types.go ++#if defined(__ARM_EABI__) || \ ++ (defined(__mips__) && (_MIPS_SIM == _ABIO32)) || \ ++ (defined(__powerpc__) && (!defined(__powerpc64__))) ++# ifdef _TIME_BITS ++# undef _TIME_BITS ++# endif ++# define _TIME_BITS 32 ++#endif ++ + // is broken on powerpc64, as it fails to include definitions of + // these structures. We just include them copied from . + #if defined(__powerpc__) +@@ -256,6 +266,7 @@ struct ltchars { + #include + #include + #include ++#include + #include + #include + #include +@@ -527,6 +538,7 @@ ccflags="$@" + $2 ~ /^(AF|SOCK|SO|SOL|IPPROTO|IP|IPV6|TCP|MCAST|EVFILT|NOTE|SHUT|PROT|MAP|MREMAP|MFD|T?PACKET|MSG|SCM|MCL|DT|MADV|PR|LOCAL|TCPOPT|UDP)_/ || + $2 ~ /^NFC_(GENL|PROTO|COMM|RF|SE|DIRECTION|LLCP|SOCKPROTO)_/ || + $2 ~ /^NFC_.*_(MAX)?SIZE$/ || ++ $2 ~ /^PTP_/ || + $2 ~ /^RAW_PAYLOAD_/ || + $2 ~ /^[US]F_/ || + $2 ~ /^TP_STATUS_/ || +@@ -552,6 +564,7 @@ ccflags="$@" + $2 !~ /^RTC_VL_(ACCURACY|BACKUP|DATA)/ && + $2 ~ /^(NETLINK|NLM|NLMSG|NLA|IFA|IFAN|RT|RTC|RTCF|RTN|RTPROT|RTNH|ARPHRD|ETH_P|NETNSA)_/ || + $2 ~ /^SOCK_|SK_DIAG_|SKNLGRP_$/ || ++ $2 ~ /^(CONNECT|SAE)_/ || + $2 ~ /^FIORDCHK$/ || + $2 ~ /^SIOC/ || + $2 ~ /^TIOC/ || +@@ -655,7 +668,7 @@ errors=$( + signals=$( + echo '#include ' | $CC -x c - -E -dM $ccflags | + awk '$1=="#define" && $2 ~ /^SIG[A-Z0-9]+$/ { print $2 }' | +- grep -v 'SIGSTKSIZE\|SIGSTKSZ\|SIGRT\|SIGMAX64' | ++ grep -E -v '(SIGSTKSIZE|SIGSTKSZ|SIGRT|SIGMAX64)' | + sort + ) + +@@ -665,7 +678,7 @@ echo '#include ' | $CC -x c - -E -dM $ccflags | + sort >_error.grep + echo '#include ' | $CC -x c - -E -dM $ccflags | + awk '$1=="#define" && $2 ~ /^SIG[A-Z0-9]+$/ { print "^\t" $2 "[ \t]*=" }' | +- grep -v 'SIGSTKSIZE\|SIGSTKSZ\|SIGRT\|SIGMAX64' | ++ grep -E -v '(SIGSTKSIZE|SIGSTKSZ|SIGRT|SIGMAX64)' | + sort >_signal.grep + + echo '// mkerrors.sh' "$@" +diff --git a/vendor/golang.org/x/sys/unix/syscall_aix.go b/vendor/golang.org/x/sys/unix/syscall_aix.go +index 67ce6ce..6f15ba1 100644 +--- a/vendor/golang.org/x/sys/unix/syscall_aix.go ++++ b/vendor/golang.org/x/sys/unix/syscall_aix.go +@@ -360,7 +360,7 @@ func Wait4(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (wpid int, + var status _C_int + var r Pid_t + err = ERESTART +- // AIX wait4 may return with ERESTART errno, while the processus is still ++ // AIX wait4 may return with ERESTART errno, while the process is still + // active. + for err == ERESTART { + r, err = wait4(Pid_t(pid), &status, options, rusage) +diff --git a/vendor/golang.org/x/sys/unix/syscall_darwin.go b/vendor/golang.org/x/sys/unix/syscall_darwin.go +index 2d15200..099867d 100644 +--- a/vendor/golang.org/x/sys/unix/syscall_darwin.go ++++ b/vendor/golang.org/x/sys/unix/syscall_darwin.go +@@ -566,6 +566,43 @@ func PthreadFchdir(fd int) (err error) { + return pthread_fchdir_np(fd) + } + ++// Connectx calls connectx(2) to initiate a connection on a socket. ++// ++// srcIf, srcAddr, and dstAddr are filled into a [SaEndpoints] struct and passed as the endpoints argument. ++// ++// - srcIf is the optional source interface index. 0 means unspecified. ++// - srcAddr is the optional source address. nil means unspecified. ++// - dstAddr is the destination address. ++// ++// On success, Connectx returns the number of bytes enqueued for transmission. ++func Connectx(fd int, srcIf uint32, srcAddr, dstAddr Sockaddr, associd SaeAssocID, flags uint32, iov []Iovec, connid *SaeConnID) (n uintptr, err error) { ++ endpoints := SaEndpoints{ ++ Srcif: srcIf, ++ } ++ ++ if srcAddr != nil { ++ addrp, addrlen, err := srcAddr.sockaddr() ++ if err != nil { ++ return 0, err ++ } ++ endpoints.Srcaddr = (*RawSockaddr)(addrp) ++ endpoints.Srcaddrlen = uint32(addrlen) ++ } ++ ++ if dstAddr != nil { ++ addrp, addrlen, err := dstAddr.sockaddr() ++ if err != nil { ++ return 0, err ++ } ++ endpoints.Dstaddr = (*RawSockaddr)(addrp) ++ endpoints.Dstaddrlen = uint32(addrlen) ++ } ++ ++ err = connectx(fd, &endpoints, associd, flags, iov, &n, connid) ++ return ++} ++ ++//sys connectx(fd int, endpoints *SaEndpoints, associd SaeAssocID, flags uint32, iov []Iovec, n *uintptr, connid *SaeConnID) (err error) + //sys sendfile(infd int, outfd int, offset int64, len *int64, hdtr unsafe.Pointer, flags int) (err error) + + //sys shmat(id int, addr uintptr, flag int) (ret uintptr, err error) +diff --git a/vendor/golang.org/x/sys/unix/syscall_hurd.go b/vendor/golang.org/x/sys/unix/syscall_hurd.go +index ba46651..a6a2d2f 100644 +--- a/vendor/golang.org/x/sys/unix/syscall_hurd.go ++++ b/vendor/golang.org/x/sys/unix/syscall_hurd.go +@@ -11,6 +11,7 @@ package unix + int ioctl(int, unsigned long int, uintptr_t); + */ + import "C" ++import "unsafe" + + func ioctl(fd int, req uint, arg uintptr) (err error) { + r0, er := C.ioctl(C.int(fd), C.ulong(req), C.uintptr_t(arg)) +diff --git a/vendor/golang.org/x/sys/unix/syscall_linux.go b/vendor/golang.org/x/sys/unix/syscall_linux.go +index 3f1d3d4..230a945 100644 +--- a/vendor/golang.org/x/sys/unix/syscall_linux.go ++++ b/vendor/golang.org/x/sys/unix/syscall_linux.go +@@ -1295,6 +1295,48 @@ func GetsockoptTCPInfo(fd, level, opt int) (*TCPInfo, error) { + return &value, err + } + ++// GetsockoptTCPCCVegasInfo returns algorithm specific congestion control information for a socket using the "vegas" ++// algorithm. ++// ++// The socket's congestion control algorighm can be retrieved via [GetsockoptString] with the [TCP_CONGESTION] option: ++// ++// algo, err := unix.GetsockoptString(fd, unix.IPPROTO_TCP, unix.TCP_CONGESTION) ++func GetsockoptTCPCCVegasInfo(fd, level, opt int) (*TCPVegasInfo, error) { ++ var value [SizeofTCPCCInfo / 4]uint32 // ensure proper alignment ++ vallen := _Socklen(SizeofTCPCCInfo) ++ err := getsockopt(fd, level, opt, unsafe.Pointer(&value[0]), &vallen) ++ out := (*TCPVegasInfo)(unsafe.Pointer(&value[0])) ++ return out, err ++} ++ ++// GetsockoptTCPCCDCTCPInfo returns algorithm specific congestion control information for a socket using the "dctp" ++// algorithm. ++// ++// The socket's congestion control algorighm can be retrieved via [GetsockoptString] with the [TCP_CONGESTION] option: ++// ++// algo, err := unix.GetsockoptString(fd, unix.IPPROTO_TCP, unix.TCP_CONGESTION) ++func GetsockoptTCPCCDCTCPInfo(fd, level, opt int) (*TCPDCTCPInfo, error) { ++ var value [SizeofTCPCCInfo / 4]uint32 // ensure proper alignment ++ vallen := _Socklen(SizeofTCPCCInfo) ++ err := getsockopt(fd, level, opt, unsafe.Pointer(&value[0]), &vallen) ++ out := (*TCPDCTCPInfo)(unsafe.Pointer(&value[0])) ++ return out, err ++} ++ ++// GetsockoptTCPCCBBRInfo returns algorithm specific congestion control information for a socket using the "bbr" ++// algorithm. ++// ++// The socket's congestion control algorighm can be retrieved via [GetsockoptString] with the [TCP_CONGESTION] option: ++// ++// algo, err := unix.GetsockoptString(fd, unix.IPPROTO_TCP, unix.TCP_CONGESTION) ++func GetsockoptTCPCCBBRInfo(fd, level, opt int) (*TCPBBRInfo, error) { ++ var value [SizeofTCPCCInfo / 4]uint32 // ensure proper alignment ++ vallen := _Socklen(SizeofTCPCCInfo) ++ err := getsockopt(fd, level, opt, unsafe.Pointer(&value[0]), &vallen) ++ out := (*TCPBBRInfo)(unsafe.Pointer(&value[0])) ++ return out, err ++} ++ + // GetsockoptString returns the string value of the socket option opt for the + // socket associated with fd at the given socket level. + func GetsockoptString(fd, level, opt int) (string, error) { +@@ -1818,6 +1860,7 @@ func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err e + //sys ClockAdjtime(clockid int32, buf *Timex) (state int, err error) + //sys ClockGetres(clockid int32, res *Timespec) (err error) + //sys ClockGettime(clockid int32, time *Timespec) (err error) ++//sys ClockSettime(clockid int32, time *Timespec) (err error) + //sys ClockNanosleep(clockid int32, flags int, request *Timespec, remain *Timespec) (err error) + //sys Close(fd int) (err error) + //sys CloseRange(first uint, last uint, flags uint) (err error) +@@ -1959,7 +2002,26 @@ func Getpgrp() (pid int) { + //sysnb Getpid() (pid int) + //sysnb Getppid() (ppid int) + //sys Getpriority(which int, who int) (prio int, err error) +-//sys Getrandom(buf []byte, flags int) (n int, err error) ++ ++func Getrandom(buf []byte, flags int) (n int, err error) { ++ vdsoRet, supported := vgetrandom(buf, uint32(flags)) ++ if supported { ++ if vdsoRet < 0 { ++ return 0, errnoErr(syscall.Errno(-vdsoRet)) ++ } ++ return vdsoRet, nil ++ } ++ var p *byte ++ if len(buf) > 0 { ++ p = &buf[0] ++ } ++ r, _, e := Syscall(SYS_GETRANDOM, uintptr(unsafe.Pointer(p)), uintptr(len(buf)), uintptr(flags)) ++ if e != 0 { ++ return 0, errnoErr(e) ++ } ++ return int(r), nil ++} ++ + //sysnb Getrusage(who int, rusage *Rusage) (err error) + //sysnb Getsid(pid int) (sid int, err error) + //sysnb Gettid() (tid int) +diff --git a/vendor/golang.org/x/sys/unix/syscall_linux_arm64.go b/vendor/golang.org/x/sys/unix/syscall_linux_arm64.go +index cf2ee6c..745e5c7 100644 +--- a/vendor/golang.org/x/sys/unix/syscall_linux_arm64.go ++++ b/vendor/golang.org/x/sys/unix/syscall_linux_arm64.go +@@ -182,3 +182,5 @@ func KexecFileLoad(kernelFd int, initrdFd int, cmdline string, flags int) error + } + return kexecFileLoad(kernelFd, initrdFd, cmdlineLen, cmdline, flags) + } ++ ++const SYS_FSTATAT = SYS_NEWFSTATAT +diff --git a/vendor/golang.org/x/sys/unix/syscall_linux_loong64.go b/vendor/golang.org/x/sys/unix/syscall_linux_loong64.go +index 3d0e984..dd2262a 100644 +--- a/vendor/golang.org/x/sys/unix/syscall_linux_loong64.go ++++ b/vendor/golang.org/x/sys/unix/syscall_linux_loong64.go +@@ -214,3 +214,5 @@ func KexecFileLoad(kernelFd int, initrdFd int, cmdline string, flags int) error + } + return kexecFileLoad(kernelFd, initrdFd, cmdlineLen, cmdline, flags) + } ++ ++const SYS_FSTATAT = SYS_NEWFSTATAT +diff --git a/vendor/golang.org/x/sys/unix/syscall_linux_riscv64.go b/vendor/golang.org/x/sys/unix/syscall_linux_riscv64.go +index 6f5a288..8cf3670 100644 +--- a/vendor/golang.org/x/sys/unix/syscall_linux_riscv64.go ++++ b/vendor/golang.org/x/sys/unix/syscall_linux_riscv64.go +@@ -187,3 +187,5 @@ func RISCVHWProbe(pairs []RISCVHWProbePairs, set *CPUSet, flags uint) (err error + } + return riscvHWProbe(pairs, setSize, set, flags) + } ++ ++const SYS_FSTATAT = SYS_NEWFSTATAT +diff --git a/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go b/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go +index 312ae6a..7bf5c04 100644 +--- a/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go ++++ b/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go +@@ -768,6 +768,15 @@ func Munmap(b []byte) (err error) { + return mapper.Munmap(b) + } + ++func MmapPtr(fd int, offset int64, addr unsafe.Pointer, length uintptr, prot int, flags int) (ret unsafe.Pointer, err error) { ++ xaddr, err := mapper.mmap(uintptr(addr), length, prot, flags, fd, offset) ++ return unsafe.Pointer(xaddr), err ++} ++ ++func MunmapPtr(addr unsafe.Pointer, length uintptr) (err error) { ++ return mapper.munmap(uintptr(addr), length) ++} ++ + //sys Gethostname(buf []byte) (err error) = SYS___GETHOSTNAME_A + //sysnb Getgid() (gid int) + //sysnb Getpid() (pid int) +@@ -816,10 +825,10 @@ func Lstat(path string, stat *Stat_t) (err error) { + // for checking symlinks begins with $VERSION/ $SYSNAME/ $SYSSYMR/ $SYSSYMA/ + func isSpecialPath(path []byte) (v bool) { + var special = [4][8]byte{ +- [8]byte{'V', 'E', 'R', 'S', 'I', 'O', 'N', '/'}, +- [8]byte{'S', 'Y', 'S', 'N', 'A', 'M', 'E', '/'}, +- [8]byte{'S', 'Y', 'S', 'S', 'Y', 'M', 'R', '/'}, +- [8]byte{'S', 'Y', 'S', 'S', 'Y', 'M', 'A', '/'}} ++ {'V', 'E', 'R', 'S', 'I', 'O', 'N', '/'}, ++ {'S', 'Y', 'S', 'N', 'A', 'M', 'E', '/'}, ++ {'S', 'Y', 'S', 'S', 'Y', 'M', 'R', '/'}, ++ {'S', 'Y', 'S', 'S', 'Y', 'M', 'A', '/'}} + + var i, j int + for i = 0; i < len(special); i++ { +@@ -3115,3 +3124,90 @@ func legacy_Mkfifoat(dirfd int, path string, mode uint32) (err error) { + //sys Posix_openpt(oflag int) (fd int, err error) = SYS_POSIX_OPENPT + //sys Grantpt(fildes int) (rc int, err error) = SYS_GRANTPT + //sys Unlockpt(fildes int) (rc int, err error) = SYS_UNLOCKPT ++ ++func fcntlAsIs(fd uintptr, cmd int, arg uintptr) (val int, err error) { ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_FCNTL<<4, uintptr(fd), uintptr(cmd), arg) ++ runtime.ExitSyscall() ++ val = int(r0) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++func Fcntl(fd uintptr, cmd int, op interface{}) (ret int, err error) { ++ switch op.(type) { ++ case *Flock_t: ++ err = FcntlFlock(fd, cmd, op.(*Flock_t)) ++ if err != nil { ++ ret = -1 ++ } ++ return ++ case int: ++ return FcntlInt(fd, cmd, op.(int)) ++ case *F_cnvrt: ++ return fcntlAsIs(fd, cmd, uintptr(unsafe.Pointer(op.(*F_cnvrt)))) ++ case unsafe.Pointer: ++ return fcntlAsIs(fd, cmd, uintptr(op.(unsafe.Pointer))) ++ default: ++ return -1, EINVAL ++ } ++ return ++} ++ ++func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) { ++ if raceenabled { ++ raceReleaseMerge(unsafe.Pointer(&ioSync)) ++ } ++ return sendfile(outfd, infd, offset, count) ++} ++ ++func sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) { ++ // TODO: use LE call instead if the call is implemented ++ originalOffset, err := Seek(infd, 0, SEEK_CUR) ++ if err != nil { ++ return -1, err ++ } ++ //start reading data from in_fd ++ if offset != nil { ++ _, err := Seek(infd, *offset, SEEK_SET) ++ if err != nil { ++ return -1, err ++ } ++ } ++ ++ buf := make([]byte, count) ++ readBuf := make([]byte, 0) ++ var n int = 0 ++ for i := 0; i < count; i += n { ++ n, err := Read(infd, buf) ++ if n == 0 { ++ if err != nil { ++ return -1, err ++ } else { // EOF ++ break ++ } ++ } ++ readBuf = append(readBuf, buf...) ++ buf = buf[0:0] ++ } ++ ++ n2, err := Write(outfd, readBuf) ++ if err != nil { ++ return -1, err ++ } ++ ++ //When sendfile() returns, this variable will be set to the ++ // offset of the byte following the last byte that was read. ++ if offset != nil { ++ *offset = *offset + int64(n) ++ // If offset is not NULL, then sendfile() does not modify the file ++ // offset of in_fd ++ _, err := Seek(infd, originalOffset, SEEK_SET) ++ if err != nil { ++ return -1, err ++ } ++ } ++ return n2, nil ++} +diff --git a/vendor/golang.org/x/sys/unix/vgetrandom_linux.go b/vendor/golang.org/x/sys/unix/vgetrandom_linux.go +new file mode 100644 +index 0000000..07ac8e0 +--- /dev/null ++++ b/vendor/golang.org/x/sys/unix/vgetrandom_linux.go +@@ -0,0 +1,13 @@ ++// Copyright 2024 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. ++ ++//go:build linux && go1.24 ++ ++package unix ++ ++import _ "unsafe" ++ ++//go:linkname vgetrandom runtime.vgetrandom ++//go:noescape ++func vgetrandom(p []byte, flags uint32) (ret int, supported bool) +diff --git a/vendor/golang.org/x/sys/unix/vgetrandom_unsupported.go b/vendor/golang.org/x/sys/unix/vgetrandom_unsupported.go +new file mode 100644 +index 0000000..297e97b +--- /dev/null ++++ b/vendor/golang.org/x/sys/unix/vgetrandom_unsupported.go +@@ -0,0 +1,11 @@ ++// Copyright 2024 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. ++ ++//go:build !linux || !go1.24 ++ ++package unix ++ ++func vgetrandom(p []byte, flags uint32) (ret int, supported bool) { ++ return -1, false ++} +diff --git a/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go b/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go +index 4308ac1..d73c465 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go +@@ -237,6 +237,9 @@ const ( + CLOCK_UPTIME_RAW_APPROX = 0x9 + CLONE_NOFOLLOW = 0x1 + CLONE_NOOWNERCOPY = 0x2 ++ CONNECT_DATA_AUTHENTICATED = 0x4 ++ CONNECT_DATA_IDEMPOTENT = 0x2 ++ CONNECT_RESUME_ON_READ_WRITE = 0x1 + CR0 = 0x0 + CR1 = 0x1000 + CR2 = 0x2000 +@@ -1265,6 +1268,10 @@ const ( + RTV_SSTHRESH = 0x20 + RUSAGE_CHILDREN = -0x1 + RUSAGE_SELF = 0x0 ++ SAE_ASSOCID_ALL = 0xffffffff ++ SAE_ASSOCID_ANY = 0x0 ++ SAE_CONNID_ALL = 0xffffffff ++ SAE_CONNID_ANY = 0x0 + SCM_CREDS = 0x3 + SCM_RIGHTS = 0x1 + SCM_TIMESTAMP = 0x2 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go b/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go +index c8068a7..4a55a40 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go +@@ -237,6 +237,9 @@ const ( + CLOCK_UPTIME_RAW_APPROX = 0x9 + CLONE_NOFOLLOW = 0x1 + CLONE_NOOWNERCOPY = 0x2 ++ CONNECT_DATA_AUTHENTICATED = 0x4 ++ CONNECT_DATA_IDEMPOTENT = 0x2 ++ CONNECT_RESUME_ON_READ_WRITE = 0x1 + CR0 = 0x0 + CR1 = 0x1000 + CR2 = 0x2000 +@@ -1265,6 +1268,10 @@ const ( + RTV_SSTHRESH = 0x20 + RUSAGE_CHILDREN = -0x1 + RUSAGE_SELF = 0x0 ++ SAE_ASSOCID_ALL = 0xffffffff ++ SAE_ASSOCID_ANY = 0x0 ++ SAE_CONNID_ALL = 0xffffffff ++ SAE_CONNID_ANY = 0x0 + SCM_CREDS = 0x3 + SCM_RIGHTS = 0x1 + SCM_TIMESTAMP = 0x2 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux.go b/vendor/golang.org/x/sys/unix/zerrors_linux.go +index 01a70b2..6ebc48b 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux.go +@@ -321,6 +321,9 @@ const ( + AUDIT_INTEGRITY_STATUS = 0x70a + AUDIT_IPC = 0x517 + AUDIT_IPC_SET_PERM = 0x51f ++ AUDIT_IPE_ACCESS = 0x58c ++ AUDIT_IPE_CONFIG_CHANGE = 0x58d ++ AUDIT_IPE_POLICY_LOAD = 0x58e + AUDIT_KERNEL = 0x7d0 + AUDIT_KERNEL_OTHER = 0x524 + AUDIT_KERN_MODULE = 0x532 +@@ -489,12 +492,14 @@ const ( + BPF_F_ID = 0x20 + BPF_F_NETFILTER_IP_DEFRAG = 0x1 + BPF_F_QUERY_EFFECTIVE = 0x1 ++ BPF_F_REDIRECT_FLAGS = 0x19 + BPF_F_REPLACE = 0x4 + BPF_F_SLEEPABLE = 0x10 + BPF_F_STRICT_ALIGNMENT = 0x1 + BPF_F_TEST_REG_INVARIANTS = 0x80 + BPF_F_TEST_RND_HI32 = 0x4 + BPF_F_TEST_RUN_ON_CPU = 0x1 ++ BPF_F_TEST_SKB_CHECKSUM_COMPLETE = 0x4 + BPF_F_TEST_STATE_FREQ = 0x8 + BPF_F_TEST_XDP_LIVE_FRAMES = 0x2 + BPF_F_XDP_DEV_BOUND_ONLY = 0x40 +@@ -1165,6 +1170,7 @@ const ( + EXTA = 0xe + EXTB = 0xf + F2FS_SUPER_MAGIC = 0xf2f52010 ++ FALLOC_FL_ALLOCATE_RANGE = 0x0 + FALLOC_FL_COLLAPSE_RANGE = 0x8 + FALLOC_FL_INSERT_RANGE = 0x20 + FALLOC_FL_KEEP_SIZE = 0x1 +@@ -1798,6 +1804,8 @@ const ( + LANDLOCK_ACCESS_NET_BIND_TCP = 0x1 + LANDLOCK_ACCESS_NET_CONNECT_TCP = 0x2 + LANDLOCK_CREATE_RULESET_VERSION = 0x1 ++ LANDLOCK_SCOPE_ABSTRACT_UNIX_SOCKET = 0x1 ++ LANDLOCK_SCOPE_SIGNAL = 0x2 + LINUX_REBOOT_CMD_CAD_OFF = 0x0 + LINUX_REBOOT_CMD_CAD_ON = 0x89abcdef + LINUX_REBOOT_CMD_HALT = 0xcdef0123 +@@ -1922,6 +1930,8 @@ const ( + MNT_EXPIRE = 0x4 + MNT_FORCE = 0x1 + MNT_ID_REQ_SIZE_VER0 = 0x18 ++ MNT_ID_REQ_SIZE_VER1 = 0x20 ++ MNT_NS_INFO_SIZE_VER0 = 0x10 + MODULE_INIT_COMPRESSED_FILE = 0x4 + MODULE_INIT_IGNORE_MODVERSIONS = 0x1 + MODULE_INIT_IGNORE_VERMAGIC = 0x2 +@@ -2187,7 +2197,7 @@ const ( + NFT_REG_SIZE = 0x10 + NFT_REJECT_ICMPX_MAX = 0x3 + NFT_RT_MAX = 0x4 +- NFT_SECMARK_CTX_MAXLEN = 0x100 ++ NFT_SECMARK_CTX_MAXLEN = 0x1000 + NFT_SET_MAXNAMELEN = 0x100 + NFT_SOCKET_MAX = 0x3 + NFT_TABLE_F_MASK = 0x7 +@@ -2356,9 +2366,11 @@ const ( + PERF_MEM_LVLNUM_IO = 0xa + PERF_MEM_LVLNUM_L1 = 0x1 + PERF_MEM_LVLNUM_L2 = 0x2 ++ PERF_MEM_LVLNUM_L2_MHB = 0x5 + PERF_MEM_LVLNUM_L3 = 0x3 + PERF_MEM_LVLNUM_L4 = 0x4 + PERF_MEM_LVLNUM_LFB = 0xc ++ PERF_MEM_LVLNUM_MSC = 0x6 + PERF_MEM_LVLNUM_NA = 0xf + PERF_MEM_LVLNUM_PMEM = 0xe + PERF_MEM_LVLNUM_RAM = 0xd +@@ -2431,6 +2443,7 @@ const ( + PRIO_PGRP = 0x1 + PRIO_PROCESS = 0x0 + PRIO_USER = 0x2 ++ PROCFS_IOCTL_MAGIC = 'f' + PROC_SUPER_MAGIC = 0x9fa0 + PROT_EXEC = 0x4 + PROT_GROWSDOWN = 0x1000000 +@@ -2620,6 +2633,28 @@ const ( + PR_UNALIGN_NOPRINT = 0x1 + PR_UNALIGN_SIGBUS = 0x2 + PSTOREFS_MAGIC = 0x6165676c ++ PTP_CLK_MAGIC = '=' ++ PTP_ENABLE_FEATURE = 0x1 ++ PTP_EXTTS_EDGES = 0x6 ++ PTP_EXTTS_EVENT_VALID = 0x1 ++ PTP_EXTTS_V1_VALID_FLAGS = 0x7 ++ PTP_EXTTS_VALID_FLAGS = 0x1f ++ PTP_EXT_OFFSET = 0x10 ++ PTP_FALLING_EDGE = 0x4 ++ PTP_MAX_SAMPLES = 0x19 ++ PTP_PEROUT_DUTY_CYCLE = 0x2 ++ PTP_PEROUT_ONE_SHOT = 0x1 ++ PTP_PEROUT_PHASE = 0x4 ++ PTP_PEROUT_V1_VALID_FLAGS = 0x0 ++ PTP_PEROUT_VALID_FLAGS = 0x7 ++ PTP_PIN_GETFUNC = 0xc0603d06 ++ PTP_PIN_GETFUNC2 = 0xc0603d0f ++ PTP_RISING_EDGE = 0x2 ++ PTP_STRICT_FLAGS = 0x8 ++ PTP_SYS_OFFSET_EXTENDED = 0xc4c03d09 ++ PTP_SYS_OFFSET_EXTENDED2 = 0xc4c03d12 ++ PTP_SYS_OFFSET_PRECISE = 0xc0403d08 ++ PTP_SYS_OFFSET_PRECISE2 = 0xc0403d11 + PTRACE_ATTACH = 0x10 + PTRACE_CONT = 0x7 + PTRACE_DETACH = 0x11 +@@ -2933,15 +2968,17 @@ const ( + RUSAGE_SELF = 0x0 + RUSAGE_THREAD = 0x1 + RWF_APPEND = 0x10 ++ RWF_ATOMIC = 0x40 + RWF_DSYNC = 0x2 + RWF_HIPRI = 0x1 + RWF_NOAPPEND = 0x20 + RWF_NOWAIT = 0x8 +- RWF_SUPPORTED = 0x3f ++ RWF_SUPPORTED = 0x7f + RWF_SYNC = 0x4 + RWF_WRITE_LIFE_NOT_SET = 0x0 + SCHED_BATCH = 0x3 + SCHED_DEADLINE = 0x6 ++ SCHED_EXT = 0x7 + SCHED_FIFO = 0x1 + SCHED_FLAG_ALL = 0x7f + SCHED_FLAG_DL_OVERRUN = 0x4 +@@ -3210,6 +3247,7 @@ const ( + STATX_ATTR_MOUNT_ROOT = 0x2000 + STATX_ATTR_NODUMP = 0x40 + STATX_ATTR_VERITY = 0x100000 ++ STATX_ATTR_WRITE_ATOMIC = 0x400000 + STATX_BASIC_STATS = 0x7ff + STATX_BLOCKS = 0x400 + STATX_BTIME = 0x800 +@@ -3226,6 +3264,7 @@ const ( + STATX_SUBVOL = 0x8000 + STATX_TYPE = 0x1 + STATX_UID = 0x8 ++ STATX_WRITE_ATOMIC = 0x10000 + STATX__RESERVED = 0x80000000 + SYNC_FILE_RANGE_WAIT_AFTER = 0x4 + SYNC_FILE_RANGE_WAIT_BEFORE = 0x1 +@@ -3624,6 +3663,7 @@ const ( + XDP_UMEM_PGOFF_COMPLETION_RING = 0x180000000 + XDP_UMEM_PGOFF_FILL_RING = 0x100000000 + XDP_UMEM_REG = 0x4 ++ XDP_UMEM_TX_METADATA_LEN = 0x4 + XDP_UMEM_TX_SW_CSUM = 0x2 + XDP_UMEM_UNALIGNED_CHUNK_FLAG = 0x1 + XDP_USE_NEED_WAKEUP = 0x8 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_386.go b/vendor/golang.org/x/sys/unix/zerrors_linux_386.go +index 684a516..c0d45e3 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_386.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_386.go +@@ -109,6 +109,7 @@ const ( + HIDIOCGRAWINFO = 0x80084803 + HIDIOCGRDESC = 0x90044802 + HIDIOCGRDESCSIZE = 0x80044801 ++ HIDIOCREVOKE = 0x4004480d + HUPCL = 0x400 + ICANON = 0x2 + IEXTEN = 0x8000 +@@ -153,9 +154,14 @@ const ( + NFDBITS = 0x20 + NLDLY = 0x100 + NOFLSH = 0x80 ++ NS_GET_MNTNS_ID = 0x8008b705 + NS_GET_NSTYPE = 0xb703 + NS_GET_OWNER_UID = 0xb704 + NS_GET_PARENT = 0xb702 ++ NS_GET_PID_FROM_PIDNS = 0x8004b706 ++ NS_GET_PID_IN_PIDNS = 0x8004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x8004b707 ++ NS_GET_TGID_IN_PIDNS = 0x8004b709 + NS_GET_USERNS = 0xb701 + OLCUC = 0x2 + ONLCR = 0x4 +@@ -232,6 +238,20 @@ const ( + PPPIOCUNBRIDGECHAN = 0x7434 + PPPIOCXFERUNIT = 0x744e + PR_SET_PTRACER_ANY = 0xffffffff ++ PTP_CLOCK_GETCAPS = 0x80503d01 ++ PTP_CLOCK_GETCAPS2 = 0x80503d0a ++ PTP_ENABLE_PPS = 0x40043d04 ++ PTP_ENABLE_PPS2 = 0x40043d0d ++ PTP_EXTTS_REQUEST = 0x40103d02 ++ PTP_EXTTS_REQUEST2 = 0x40103d0b ++ PTP_MASK_CLEAR_ALL = 0x3d13 ++ PTP_MASK_EN_SINGLE = 0x40043d14 ++ PTP_PEROUT_REQUEST = 0x40383d03 ++ PTP_PEROUT_REQUEST2 = 0x40383d0c ++ PTP_PIN_SETFUNC = 0x40603d07 ++ PTP_PIN_SETFUNC2 = 0x40603d10 ++ PTP_SYS_OFFSET = 0x43403d05 ++ PTP_SYS_OFFSET2 = 0x43403d0e + PTRACE_GETFPREGS = 0xe + PTRACE_GETFPXREGS = 0x12 + PTRACE_GET_THREAD_AREA = 0x19 +@@ -278,6 +298,8 @@ const ( + RTC_WIE_ON = 0x700f + RTC_WKALM_RD = 0x80287010 + RTC_WKALM_SET = 0x4028700f ++ SCM_DEVMEM_DMABUF = 0x4f ++ SCM_DEVMEM_LINEAR = 0x4e + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a +@@ -316,6 +338,9 @@ const ( + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DEVMEM_DMABUF = 0x4f ++ SO_DEVMEM_DONTNEED = 0x50 ++ SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x27 + SO_DONTROUTE = 0x5 + SO_ERROR = 0x4 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go +index 61d74b5..c731d24 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go +@@ -109,6 +109,7 @@ const ( + HIDIOCGRAWINFO = 0x80084803 + HIDIOCGRDESC = 0x90044802 + HIDIOCGRDESCSIZE = 0x80044801 ++ HIDIOCREVOKE = 0x4004480d + HUPCL = 0x400 + ICANON = 0x2 + IEXTEN = 0x8000 +@@ -153,9 +154,14 @@ const ( + NFDBITS = 0x40 + NLDLY = 0x100 + NOFLSH = 0x80 ++ NS_GET_MNTNS_ID = 0x8008b705 + NS_GET_NSTYPE = 0xb703 + NS_GET_OWNER_UID = 0xb704 + NS_GET_PARENT = 0xb702 ++ NS_GET_PID_FROM_PIDNS = 0x8004b706 ++ NS_GET_PID_IN_PIDNS = 0x8004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x8004b707 ++ NS_GET_TGID_IN_PIDNS = 0x8004b709 + NS_GET_USERNS = 0xb701 + OLCUC = 0x2 + ONLCR = 0x4 +@@ -232,6 +238,20 @@ const ( + PPPIOCUNBRIDGECHAN = 0x7434 + PPPIOCXFERUNIT = 0x744e + PR_SET_PTRACER_ANY = 0xffffffffffffffff ++ PTP_CLOCK_GETCAPS = 0x80503d01 ++ PTP_CLOCK_GETCAPS2 = 0x80503d0a ++ PTP_ENABLE_PPS = 0x40043d04 ++ PTP_ENABLE_PPS2 = 0x40043d0d ++ PTP_EXTTS_REQUEST = 0x40103d02 ++ PTP_EXTTS_REQUEST2 = 0x40103d0b ++ PTP_MASK_CLEAR_ALL = 0x3d13 ++ PTP_MASK_EN_SINGLE = 0x40043d14 ++ PTP_PEROUT_REQUEST = 0x40383d03 ++ PTP_PEROUT_REQUEST2 = 0x40383d0c ++ PTP_PIN_SETFUNC = 0x40603d07 ++ PTP_PIN_SETFUNC2 = 0x40603d10 ++ PTP_SYS_OFFSET = 0x43403d05 ++ PTP_SYS_OFFSET2 = 0x43403d0e + PTRACE_ARCH_PRCTL = 0x1e + PTRACE_GETFPREGS = 0xe + PTRACE_GETFPXREGS = 0x12 +@@ -279,6 +299,8 @@ const ( + RTC_WIE_ON = 0x700f + RTC_WKALM_RD = 0x80287010 + RTC_WKALM_SET = 0x4028700f ++ SCM_DEVMEM_DMABUF = 0x4f ++ SCM_DEVMEM_LINEAR = 0x4e + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a +@@ -317,6 +339,9 @@ const ( + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DEVMEM_DMABUF = 0x4f ++ SO_DEVMEM_DONTNEED = 0x50 ++ SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x27 + SO_DONTROUTE = 0x5 + SO_ERROR = 0x4 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go b/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go +index a28c9e3..680018a 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go +@@ -108,6 +108,7 @@ const ( + HIDIOCGRAWINFO = 0x80084803 + HIDIOCGRDESC = 0x90044802 + HIDIOCGRDESCSIZE = 0x80044801 ++ HIDIOCREVOKE = 0x4004480d + HUPCL = 0x400 + ICANON = 0x2 + IEXTEN = 0x8000 +@@ -150,9 +151,14 @@ const ( + NFDBITS = 0x20 + NLDLY = 0x100 + NOFLSH = 0x80 ++ NS_GET_MNTNS_ID = 0x8008b705 + NS_GET_NSTYPE = 0xb703 + NS_GET_OWNER_UID = 0xb704 + NS_GET_PARENT = 0xb702 ++ NS_GET_PID_FROM_PIDNS = 0x8004b706 ++ NS_GET_PID_IN_PIDNS = 0x8004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x8004b707 ++ NS_GET_TGID_IN_PIDNS = 0x8004b709 + NS_GET_USERNS = 0xb701 + OLCUC = 0x2 + ONLCR = 0x4 +@@ -229,6 +235,20 @@ const ( + PPPIOCUNBRIDGECHAN = 0x7434 + PPPIOCXFERUNIT = 0x744e + PR_SET_PTRACER_ANY = 0xffffffff ++ PTP_CLOCK_GETCAPS = 0x80503d01 ++ PTP_CLOCK_GETCAPS2 = 0x80503d0a ++ PTP_ENABLE_PPS = 0x40043d04 ++ PTP_ENABLE_PPS2 = 0x40043d0d ++ PTP_EXTTS_REQUEST = 0x40103d02 ++ PTP_EXTTS_REQUEST2 = 0x40103d0b ++ PTP_MASK_CLEAR_ALL = 0x3d13 ++ PTP_MASK_EN_SINGLE = 0x40043d14 ++ PTP_PEROUT_REQUEST = 0x40383d03 ++ PTP_PEROUT_REQUEST2 = 0x40383d0c ++ PTP_PIN_SETFUNC = 0x40603d07 ++ PTP_PIN_SETFUNC2 = 0x40603d10 ++ PTP_SYS_OFFSET = 0x43403d05 ++ PTP_SYS_OFFSET2 = 0x43403d0e + PTRACE_GETCRUNCHREGS = 0x19 + PTRACE_GETFDPIC = 0x1f + PTRACE_GETFDPIC_EXEC = 0x0 +@@ -284,6 +304,8 @@ const ( + RTC_WIE_ON = 0x700f + RTC_WKALM_RD = 0x80287010 + RTC_WKALM_SET = 0x4028700f ++ SCM_DEVMEM_DMABUF = 0x4f ++ SCM_DEVMEM_LINEAR = 0x4e + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a +@@ -322,6 +344,9 @@ const ( + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DEVMEM_DMABUF = 0x4f ++ SO_DEVMEM_DONTNEED = 0x50 ++ SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x27 + SO_DONTROUTE = 0x5 + SO_ERROR = 0x4 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go +index ab5d1fe..a63909f 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go +@@ -112,6 +112,7 @@ const ( + HIDIOCGRAWINFO = 0x80084803 + HIDIOCGRDESC = 0x90044802 + HIDIOCGRDESCSIZE = 0x80044801 ++ HIDIOCREVOKE = 0x4004480d + HUPCL = 0x400 + ICANON = 0x2 + IEXTEN = 0x8000 +@@ -154,9 +155,14 @@ const ( + NFDBITS = 0x40 + NLDLY = 0x100 + NOFLSH = 0x80 ++ NS_GET_MNTNS_ID = 0x8008b705 + NS_GET_NSTYPE = 0xb703 + NS_GET_OWNER_UID = 0xb704 + NS_GET_PARENT = 0xb702 ++ NS_GET_PID_FROM_PIDNS = 0x8004b706 ++ NS_GET_PID_IN_PIDNS = 0x8004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x8004b707 ++ NS_GET_TGID_IN_PIDNS = 0x8004b709 + NS_GET_USERNS = 0xb701 + OLCUC = 0x2 + ONLCR = 0x4 +@@ -200,6 +206,7 @@ const ( + PERF_EVENT_IOC_SET_BPF = 0x40042408 + PERF_EVENT_IOC_SET_FILTER = 0x40082406 + PERF_EVENT_IOC_SET_OUTPUT = 0x2405 ++ POE_MAGIC = 0x504f4530 + PPPIOCATTACH = 0x4004743d + PPPIOCATTCHAN = 0x40047438 + PPPIOCBRIDGECHAN = 0x40047435 +@@ -235,6 +242,20 @@ const ( + PROT_BTI = 0x10 + PROT_MTE = 0x20 + PR_SET_PTRACER_ANY = 0xffffffffffffffff ++ PTP_CLOCK_GETCAPS = 0x80503d01 ++ PTP_CLOCK_GETCAPS2 = 0x80503d0a ++ PTP_ENABLE_PPS = 0x40043d04 ++ PTP_ENABLE_PPS2 = 0x40043d0d ++ PTP_EXTTS_REQUEST = 0x40103d02 ++ PTP_EXTTS_REQUEST2 = 0x40103d0b ++ PTP_MASK_CLEAR_ALL = 0x3d13 ++ PTP_MASK_EN_SINGLE = 0x40043d14 ++ PTP_PEROUT_REQUEST = 0x40383d03 ++ PTP_PEROUT_REQUEST2 = 0x40383d0c ++ PTP_PIN_SETFUNC = 0x40603d07 ++ PTP_PIN_SETFUNC2 = 0x40603d10 ++ PTP_SYS_OFFSET = 0x43403d05 ++ PTP_SYS_OFFSET2 = 0x43403d0e + PTRACE_PEEKMTETAGS = 0x21 + PTRACE_POKEMTETAGS = 0x22 + PTRACE_SYSEMU = 0x1f +@@ -275,6 +296,8 @@ const ( + RTC_WIE_ON = 0x700f + RTC_WKALM_RD = 0x80287010 + RTC_WKALM_SET = 0x4028700f ++ SCM_DEVMEM_DMABUF = 0x4f ++ SCM_DEVMEM_LINEAR = 0x4e + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a +@@ -313,6 +336,9 @@ const ( + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DEVMEM_DMABUF = 0x4f ++ SO_DEVMEM_DONTNEED = 0x50 ++ SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x27 + SO_DONTROUTE = 0x5 + SO_ERROR = 0x4 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go +index c523090..9b0a257 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go +@@ -109,6 +109,7 @@ const ( + HIDIOCGRAWINFO = 0x80084803 + HIDIOCGRDESC = 0x90044802 + HIDIOCGRDESCSIZE = 0x80044801 ++ HIDIOCREVOKE = 0x4004480d + HUPCL = 0x400 + ICANON = 0x2 + IEXTEN = 0x8000 +@@ -154,9 +155,14 @@ const ( + NFDBITS = 0x40 + NLDLY = 0x100 + NOFLSH = 0x80 ++ NS_GET_MNTNS_ID = 0x8008b705 + NS_GET_NSTYPE = 0xb703 + NS_GET_OWNER_UID = 0xb704 + NS_GET_PARENT = 0xb702 ++ NS_GET_PID_FROM_PIDNS = 0x8004b706 ++ NS_GET_PID_IN_PIDNS = 0x8004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x8004b707 ++ NS_GET_TGID_IN_PIDNS = 0x8004b709 + NS_GET_USERNS = 0xb701 + OLCUC = 0x2 + ONLCR = 0x4 +@@ -233,6 +239,20 @@ const ( + PPPIOCUNBRIDGECHAN = 0x7434 + PPPIOCXFERUNIT = 0x744e + PR_SET_PTRACER_ANY = 0xffffffffffffffff ++ PTP_CLOCK_GETCAPS = 0x80503d01 ++ PTP_CLOCK_GETCAPS2 = 0x80503d0a ++ PTP_ENABLE_PPS = 0x40043d04 ++ PTP_ENABLE_PPS2 = 0x40043d0d ++ PTP_EXTTS_REQUEST = 0x40103d02 ++ PTP_EXTTS_REQUEST2 = 0x40103d0b ++ PTP_MASK_CLEAR_ALL = 0x3d13 ++ PTP_MASK_EN_SINGLE = 0x40043d14 ++ PTP_PEROUT_REQUEST = 0x40383d03 ++ PTP_PEROUT_REQUEST2 = 0x40383d0c ++ PTP_PIN_SETFUNC = 0x40603d07 ++ PTP_PIN_SETFUNC2 = 0x40603d10 ++ PTP_SYS_OFFSET = 0x43403d05 ++ PTP_SYS_OFFSET2 = 0x43403d0e + PTRACE_SYSEMU = 0x1f + PTRACE_SYSEMU_SINGLESTEP = 0x20 + RLIMIT_AS = 0x9 +@@ -271,6 +291,8 @@ const ( + RTC_WIE_ON = 0x700f + RTC_WKALM_RD = 0x80287010 + RTC_WKALM_SET = 0x4028700f ++ SCM_DEVMEM_DMABUF = 0x4f ++ SCM_DEVMEM_LINEAR = 0x4e + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a +@@ -309,6 +331,9 @@ const ( + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DEVMEM_DMABUF = 0x4f ++ SO_DEVMEM_DONTNEED = 0x50 ++ SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x27 + SO_DONTROUTE = 0x5 + SO_ERROR = 0x4 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go b/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go +index 01e6ea7..958e6e0 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go +@@ -108,6 +108,7 @@ const ( + HIDIOCGRAWINFO = 0x40084803 + HIDIOCGRDESC = 0x50044802 + HIDIOCGRDESCSIZE = 0x40044801 ++ HIDIOCREVOKE = 0x8004480d + HUPCL = 0x400 + ICANON = 0x2 + IEXTEN = 0x100 +@@ -150,9 +151,14 @@ const ( + NFDBITS = 0x20 + NLDLY = 0x100 + NOFLSH = 0x80 ++ NS_GET_MNTNS_ID = 0x4008b705 + NS_GET_NSTYPE = 0x2000b703 + NS_GET_OWNER_UID = 0x2000b704 + NS_GET_PARENT = 0x2000b702 ++ NS_GET_PID_FROM_PIDNS = 0x4004b706 ++ NS_GET_PID_IN_PIDNS = 0x4004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x4004b707 ++ NS_GET_TGID_IN_PIDNS = 0x4004b709 + NS_GET_USERNS = 0x2000b701 + OLCUC = 0x2 + ONLCR = 0x4 +@@ -229,6 +235,20 @@ const ( + PPPIOCUNBRIDGECHAN = 0x20007434 + PPPIOCXFERUNIT = 0x2000744e + PR_SET_PTRACER_ANY = 0xffffffff ++ PTP_CLOCK_GETCAPS = 0x40503d01 ++ PTP_CLOCK_GETCAPS2 = 0x40503d0a ++ PTP_ENABLE_PPS = 0x80043d04 ++ PTP_ENABLE_PPS2 = 0x80043d0d ++ PTP_EXTTS_REQUEST = 0x80103d02 ++ PTP_EXTTS_REQUEST2 = 0x80103d0b ++ PTP_MASK_CLEAR_ALL = 0x20003d13 ++ PTP_MASK_EN_SINGLE = 0x80043d14 ++ PTP_PEROUT_REQUEST = 0x80383d03 ++ PTP_PEROUT_REQUEST2 = 0x80383d0c ++ PTP_PIN_SETFUNC = 0x80603d07 ++ PTP_PIN_SETFUNC2 = 0x80603d10 ++ PTP_SYS_OFFSET = 0x83403d05 ++ PTP_SYS_OFFSET2 = 0x83403d0e + PTRACE_GETFPREGS = 0xe + PTRACE_GET_THREAD_AREA = 0x19 + PTRACE_GET_THREAD_AREA_3264 = 0xc4 +@@ -277,6 +297,8 @@ const ( + RTC_WIE_ON = 0x2000700f + RTC_WKALM_RD = 0x40287010 + RTC_WKALM_SET = 0x8028700f ++ SCM_DEVMEM_DMABUF = 0x4f ++ SCM_DEVMEM_LINEAR = 0x4e + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a +@@ -315,6 +337,9 @@ const ( + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DEVMEM_DMABUF = 0x4f ++ SO_DEVMEM_DONTNEED = 0x50 ++ SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x1029 + SO_DONTROUTE = 0x10 + SO_ERROR = 0x1007 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go +index 7aa610b..50c7f25 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go +@@ -108,6 +108,7 @@ const ( + HIDIOCGRAWINFO = 0x40084803 + HIDIOCGRDESC = 0x50044802 + HIDIOCGRDESCSIZE = 0x40044801 ++ HIDIOCREVOKE = 0x8004480d + HUPCL = 0x400 + ICANON = 0x2 + IEXTEN = 0x100 +@@ -150,9 +151,14 @@ const ( + NFDBITS = 0x40 + NLDLY = 0x100 + NOFLSH = 0x80 ++ NS_GET_MNTNS_ID = 0x4008b705 + NS_GET_NSTYPE = 0x2000b703 + NS_GET_OWNER_UID = 0x2000b704 + NS_GET_PARENT = 0x2000b702 ++ NS_GET_PID_FROM_PIDNS = 0x4004b706 ++ NS_GET_PID_IN_PIDNS = 0x4004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x4004b707 ++ NS_GET_TGID_IN_PIDNS = 0x4004b709 + NS_GET_USERNS = 0x2000b701 + OLCUC = 0x2 + ONLCR = 0x4 +@@ -229,6 +235,20 @@ const ( + PPPIOCUNBRIDGECHAN = 0x20007434 + PPPIOCXFERUNIT = 0x2000744e + PR_SET_PTRACER_ANY = 0xffffffffffffffff ++ PTP_CLOCK_GETCAPS = 0x40503d01 ++ PTP_CLOCK_GETCAPS2 = 0x40503d0a ++ PTP_ENABLE_PPS = 0x80043d04 ++ PTP_ENABLE_PPS2 = 0x80043d0d ++ PTP_EXTTS_REQUEST = 0x80103d02 ++ PTP_EXTTS_REQUEST2 = 0x80103d0b ++ PTP_MASK_CLEAR_ALL = 0x20003d13 ++ PTP_MASK_EN_SINGLE = 0x80043d14 ++ PTP_PEROUT_REQUEST = 0x80383d03 ++ PTP_PEROUT_REQUEST2 = 0x80383d0c ++ PTP_PIN_SETFUNC = 0x80603d07 ++ PTP_PIN_SETFUNC2 = 0x80603d10 ++ PTP_SYS_OFFSET = 0x83403d05 ++ PTP_SYS_OFFSET2 = 0x83403d0e + PTRACE_GETFPREGS = 0xe + PTRACE_GET_THREAD_AREA = 0x19 + PTRACE_GET_THREAD_AREA_3264 = 0xc4 +@@ -277,6 +297,8 @@ const ( + RTC_WIE_ON = 0x2000700f + RTC_WKALM_RD = 0x40287010 + RTC_WKALM_SET = 0x8028700f ++ SCM_DEVMEM_DMABUF = 0x4f ++ SCM_DEVMEM_LINEAR = 0x4e + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a +@@ -315,6 +337,9 @@ const ( + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DEVMEM_DMABUF = 0x4f ++ SO_DEVMEM_DONTNEED = 0x50 ++ SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x1029 + SO_DONTROUTE = 0x10 + SO_ERROR = 0x1007 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go b/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go +index 92af771..ced21d6 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go +@@ -108,6 +108,7 @@ const ( + HIDIOCGRAWINFO = 0x40084803 + HIDIOCGRDESC = 0x50044802 + HIDIOCGRDESCSIZE = 0x40044801 ++ HIDIOCREVOKE = 0x8004480d + HUPCL = 0x400 + ICANON = 0x2 + IEXTEN = 0x100 +@@ -150,9 +151,14 @@ const ( + NFDBITS = 0x40 + NLDLY = 0x100 + NOFLSH = 0x80 ++ NS_GET_MNTNS_ID = 0x4008b705 + NS_GET_NSTYPE = 0x2000b703 + NS_GET_OWNER_UID = 0x2000b704 + NS_GET_PARENT = 0x2000b702 ++ NS_GET_PID_FROM_PIDNS = 0x4004b706 ++ NS_GET_PID_IN_PIDNS = 0x4004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x4004b707 ++ NS_GET_TGID_IN_PIDNS = 0x4004b709 + NS_GET_USERNS = 0x2000b701 + OLCUC = 0x2 + ONLCR = 0x4 +@@ -229,6 +235,20 @@ const ( + PPPIOCUNBRIDGECHAN = 0x20007434 + PPPIOCXFERUNIT = 0x2000744e + PR_SET_PTRACER_ANY = 0xffffffffffffffff ++ PTP_CLOCK_GETCAPS = 0x40503d01 ++ PTP_CLOCK_GETCAPS2 = 0x40503d0a ++ PTP_ENABLE_PPS = 0x80043d04 ++ PTP_ENABLE_PPS2 = 0x80043d0d ++ PTP_EXTTS_REQUEST = 0x80103d02 ++ PTP_EXTTS_REQUEST2 = 0x80103d0b ++ PTP_MASK_CLEAR_ALL = 0x20003d13 ++ PTP_MASK_EN_SINGLE = 0x80043d14 ++ PTP_PEROUT_REQUEST = 0x80383d03 ++ PTP_PEROUT_REQUEST2 = 0x80383d0c ++ PTP_PIN_SETFUNC = 0x80603d07 ++ PTP_PIN_SETFUNC2 = 0x80603d10 ++ PTP_SYS_OFFSET = 0x83403d05 ++ PTP_SYS_OFFSET2 = 0x83403d0e + PTRACE_GETFPREGS = 0xe + PTRACE_GET_THREAD_AREA = 0x19 + PTRACE_GET_THREAD_AREA_3264 = 0xc4 +@@ -277,6 +297,8 @@ const ( + RTC_WIE_ON = 0x2000700f + RTC_WKALM_RD = 0x40287010 + RTC_WKALM_SET = 0x8028700f ++ SCM_DEVMEM_DMABUF = 0x4f ++ SCM_DEVMEM_LINEAR = 0x4e + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a +@@ -315,6 +337,9 @@ const ( + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DEVMEM_DMABUF = 0x4f ++ SO_DEVMEM_DONTNEED = 0x50 ++ SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x1029 + SO_DONTROUTE = 0x10 + SO_ERROR = 0x1007 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go b/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go +index b27ef5e..226c044 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go +@@ -108,6 +108,7 @@ const ( + HIDIOCGRAWINFO = 0x40084803 + HIDIOCGRDESC = 0x50044802 + HIDIOCGRDESCSIZE = 0x40044801 ++ HIDIOCREVOKE = 0x8004480d + HUPCL = 0x400 + ICANON = 0x2 + IEXTEN = 0x100 +@@ -150,9 +151,14 @@ const ( + NFDBITS = 0x20 + NLDLY = 0x100 + NOFLSH = 0x80 ++ NS_GET_MNTNS_ID = 0x4008b705 + NS_GET_NSTYPE = 0x2000b703 + NS_GET_OWNER_UID = 0x2000b704 + NS_GET_PARENT = 0x2000b702 ++ NS_GET_PID_FROM_PIDNS = 0x4004b706 ++ NS_GET_PID_IN_PIDNS = 0x4004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x4004b707 ++ NS_GET_TGID_IN_PIDNS = 0x4004b709 + NS_GET_USERNS = 0x2000b701 + OLCUC = 0x2 + ONLCR = 0x4 +@@ -229,6 +235,20 @@ const ( + PPPIOCUNBRIDGECHAN = 0x20007434 + PPPIOCXFERUNIT = 0x2000744e + PR_SET_PTRACER_ANY = 0xffffffff ++ PTP_CLOCK_GETCAPS = 0x40503d01 ++ PTP_CLOCK_GETCAPS2 = 0x40503d0a ++ PTP_ENABLE_PPS = 0x80043d04 ++ PTP_ENABLE_PPS2 = 0x80043d0d ++ PTP_EXTTS_REQUEST = 0x80103d02 ++ PTP_EXTTS_REQUEST2 = 0x80103d0b ++ PTP_MASK_CLEAR_ALL = 0x20003d13 ++ PTP_MASK_EN_SINGLE = 0x80043d14 ++ PTP_PEROUT_REQUEST = 0x80383d03 ++ PTP_PEROUT_REQUEST2 = 0x80383d0c ++ PTP_PIN_SETFUNC = 0x80603d07 ++ PTP_PIN_SETFUNC2 = 0x80603d10 ++ PTP_SYS_OFFSET = 0x83403d05 ++ PTP_SYS_OFFSET2 = 0x83403d0e + PTRACE_GETFPREGS = 0xe + PTRACE_GET_THREAD_AREA = 0x19 + PTRACE_GET_THREAD_AREA_3264 = 0xc4 +@@ -277,6 +297,8 @@ const ( + RTC_WIE_ON = 0x2000700f + RTC_WKALM_RD = 0x40287010 + RTC_WKALM_SET = 0x8028700f ++ SCM_DEVMEM_DMABUF = 0x4f ++ SCM_DEVMEM_LINEAR = 0x4e + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a +@@ -315,6 +337,9 @@ const ( + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DEVMEM_DMABUF = 0x4f ++ SO_DEVMEM_DONTNEED = 0x50 ++ SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x1029 + SO_DONTROUTE = 0x10 + SO_ERROR = 0x1007 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go +index 237a2ce..3122737 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go +@@ -108,6 +108,7 @@ const ( + HIDIOCGRAWINFO = 0x40084803 + HIDIOCGRDESC = 0x50044802 + HIDIOCGRDESCSIZE = 0x40044801 ++ HIDIOCREVOKE = 0x8004480d + HUPCL = 0x4000 + ICANON = 0x100 + IEXTEN = 0x400 +@@ -152,9 +153,14 @@ const ( + NL3 = 0x300 + NLDLY = 0x300 + NOFLSH = 0x80000000 ++ NS_GET_MNTNS_ID = 0x4008b705 + NS_GET_NSTYPE = 0x2000b703 + NS_GET_OWNER_UID = 0x2000b704 + NS_GET_PARENT = 0x2000b702 ++ NS_GET_PID_FROM_PIDNS = 0x4004b706 ++ NS_GET_PID_IN_PIDNS = 0x4004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x4004b707 ++ NS_GET_TGID_IN_PIDNS = 0x4004b709 + NS_GET_USERNS = 0x2000b701 + OLCUC = 0x4 + ONLCR = 0x2 +@@ -232,6 +238,20 @@ const ( + PPPIOCXFERUNIT = 0x2000744e + PROT_SAO = 0x10 + PR_SET_PTRACER_ANY = 0xffffffff ++ PTP_CLOCK_GETCAPS = 0x40503d01 ++ PTP_CLOCK_GETCAPS2 = 0x40503d0a ++ PTP_ENABLE_PPS = 0x80043d04 ++ PTP_ENABLE_PPS2 = 0x80043d0d ++ PTP_EXTTS_REQUEST = 0x80103d02 ++ PTP_EXTTS_REQUEST2 = 0x80103d0b ++ PTP_MASK_CLEAR_ALL = 0x20003d13 ++ PTP_MASK_EN_SINGLE = 0x80043d14 ++ PTP_PEROUT_REQUEST = 0x80383d03 ++ PTP_PEROUT_REQUEST2 = 0x80383d0c ++ PTP_PIN_SETFUNC = 0x80603d07 ++ PTP_PIN_SETFUNC2 = 0x80603d10 ++ PTP_SYS_OFFSET = 0x83403d05 ++ PTP_SYS_OFFSET2 = 0x83403d0e + PTRACE_GETEVRREGS = 0x14 + PTRACE_GETFPREGS = 0xe + PTRACE_GETREGS64 = 0x16 +@@ -332,6 +352,8 @@ const ( + RTC_WIE_ON = 0x2000700f + RTC_WKALM_RD = 0x40287010 + RTC_WKALM_SET = 0x8028700f ++ SCM_DEVMEM_DMABUF = 0x4f ++ SCM_DEVMEM_LINEAR = 0x4e + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a +@@ -370,6 +392,9 @@ const ( + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DEVMEM_DMABUF = 0x4f ++ SO_DEVMEM_DONTNEED = 0x50 ++ SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x27 + SO_DONTROUTE = 0x5 + SO_ERROR = 0x4 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go +index 4a5c555..eb5d346 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go +@@ -108,6 +108,7 @@ const ( + HIDIOCGRAWINFO = 0x40084803 + HIDIOCGRDESC = 0x50044802 + HIDIOCGRDESCSIZE = 0x40044801 ++ HIDIOCREVOKE = 0x8004480d + HUPCL = 0x4000 + ICANON = 0x100 + IEXTEN = 0x400 +@@ -152,9 +153,14 @@ const ( + NL3 = 0x300 + NLDLY = 0x300 + NOFLSH = 0x80000000 ++ NS_GET_MNTNS_ID = 0x4008b705 + NS_GET_NSTYPE = 0x2000b703 + NS_GET_OWNER_UID = 0x2000b704 + NS_GET_PARENT = 0x2000b702 ++ NS_GET_PID_FROM_PIDNS = 0x4004b706 ++ NS_GET_PID_IN_PIDNS = 0x4004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x4004b707 ++ NS_GET_TGID_IN_PIDNS = 0x4004b709 + NS_GET_USERNS = 0x2000b701 + OLCUC = 0x4 + ONLCR = 0x2 +@@ -232,6 +238,20 @@ const ( + PPPIOCXFERUNIT = 0x2000744e + PROT_SAO = 0x10 + PR_SET_PTRACER_ANY = 0xffffffffffffffff ++ PTP_CLOCK_GETCAPS = 0x40503d01 ++ PTP_CLOCK_GETCAPS2 = 0x40503d0a ++ PTP_ENABLE_PPS = 0x80043d04 ++ PTP_ENABLE_PPS2 = 0x80043d0d ++ PTP_EXTTS_REQUEST = 0x80103d02 ++ PTP_EXTTS_REQUEST2 = 0x80103d0b ++ PTP_MASK_CLEAR_ALL = 0x20003d13 ++ PTP_MASK_EN_SINGLE = 0x80043d14 ++ PTP_PEROUT_REQUEST = 0x80383d03 ++ PTP_PEROUT_REQUEST2 = 0x80383d0c ++ PTP_PIN_SETFUNC = 0x80603d07 ++ PTP_PIN_SETFUNC2 = 0x80603d10 ++ PTP_SYS_OFFSET = 0x83403d05 ++ PTP_SYS_OFFSET2 = 0x83403d0e + PTRACE_GETEVRREGS = 0x14 + PTRACE_GETFPREGS = 0xe + PTRACE_GETREGS64 = 0x16 +@@ -336,6 +356,8 @@ const ( + RTC_WIE_ON = 0x2000700f + RTC_WKALM_RD = 0x40287010 + RTC_WKALM_SET = 0x8028700f ++ SCM_DEVMEM_DMABUF = 0x4f ++ SCM_DEVMEM_LINEAR = 0x4e + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a +@@ -374,6 +396,9 @@ const ( + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DEVMEM_DMABUF = 0x4f ++ SO_DEVMEM_DONTNEED = 0x50 ++ SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x27 + SO_DONTROUTE = 0x5 + SO_ERROR = 0x4 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go +index a02fb49..e921ebc 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go +@@ -108,6 +108,7 @@ const ( + HIDIOCGRAWINFO = 0x40084803 + HIDIOCGRDESC = 0x50044802 + HIDIOCGRDESCSIZE = 0x40044801 ++ HIDIOCREVOKE = 0x8004480d + HUPCL = 0x4000 + ICANON = 0x100 + IEXTEN = 0x400 +@@ -152,9 +153,14 @@ const ( + NL3 = 0x300 + NLDLY = 0x300 + NOFLSH = 0x80000000 ++ NS_GET_MNTNS_ID = 0x4008b705 + NS_GET_NSTYPE = 0x2000b703 + NS_GET_OWNER_UID = 0x2000b704 + NS_GET_PARENT = 0x2000b702 ++ NS_GET_PID_FROM_PIDNS = 0x4004b706 ++ NS_GET_PID_IN_PIDNS = 0x4004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x4004b707 ++ NS_GET_TGID_IN_PIDNS = 0x4004b709 + NS_GET_USERNS = 0x2000b701 + OLCUC = 0x4 + ONLCR = 0x2 +@@ -232,6 +238,20 @@ const ( + PPPIOCXFERUNIT = 0x2000744e + PROT_SAO = 0x10 + PR_SET_PTRACER_ANY = 0xffffffffffffffff ++ PTP_CLOCK_GETCAPS = 0x40503d01 ++ PTP_CLOCK_GETCAPS2 = 0x40503d0a ++ PTP_ENABLE_PPS = 0x80043d04 ++ PTP_ENABLE_PPS2 = 0x80043d0d ++ PTP_EXTTS_REQUEST = 0x80103d02 ++ PTP_EXTTS_REQUEST2 = 0x80103d0b ++ PTP_MASK_CLEAR_ALL = 0x20003d13 ++ PTP_MASK_EN_SINGLE = 0x80043d14 ++ PTP_PEROUT_REQUEST = 0x80383d03 ++ PTP_PEROUT_REQUEST2 = 0x80383d0c ++ PTP_PIN_SETFUNC = 0x80603d07 ++ PTP_PIN_SETFUNC2 = 0x80603d10 ++ PTP_SYS_OFFSET = 0x83403d05 ++ PTP_SYS_OFFSET2 = 0x83403d0e + PTRACE_GETEVRREGS = 0x14 + PTRACE_GETFPREGS = 0xe + PTRACE_GETREGS64 = 0x16 +@@ -336,6 +356,8 @@ const ( + RTC_WIE_ON = 0x2000700f + RTC_WKALM_RD = 0x40287010 + RTC_WKALM_SET = 0x8028700f ++ SCM_DEVMEM_DMABUF = 0x4f ++ SCM_DEVMEM_LINEAR = 0x4e + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a +@@ -374,6 +396,9 @@ const ( + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DEVMEM_DMABUF = 0x4f ++ SO_DEVMEM_DONTNEED = 0x50 ++ SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x27 + SO_DONTROUTE = 0x5 + SO_ERROR = 0x4 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go +index e26a7c6..38ba81c 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go +@@ -108,6 +108,7 @@ const ( + HIDIOCGRAWINFO = 0x80084803 + HIDIOCGRDESC = 0x90044802 + HIDIOCGRDESCSIZE = 0x80044801 ++ HIDIOCREVOKE = 0x4004480d + HUPCL = 0x400 + ICANON = 0x2 + IEXTEN = 0x8000 +@@ -150,9 +151,14 @@ const ( + NFDBITS = 0x40 + NLDLY = 0x100 + NOFLSH = 0x80 ++ NS_GET_MNTNS_ID = 0x8008b705 + NS_GET_NSTYPE = 0xb703 + NS_GET_OWNER_UID = 0xb704 + NS_GET_PARENT = 0xb702 ++ NS_GET_PID_FROM_PIDNS = 0x8004b706 ++ NS_GET_PID_IN_PIDNS = 0x8004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x8004b707 ++ NS_GET_TGID_IN_PIDNS = 0x8004b709 + NS_GET_USERNS = 0xb701 + OLCUC = 0x2 + ONLCR = 0x4 +@@ -229,6 +235,20 @@ const ( + PPPIOCUNBRIDGECHAN = 0x7434 + PPPIOCXFERUNIT = 0x744e + PR_SET_PTRACER_ANY = 0xffffffffffffffff ++ PTP_CLOCK_GETCAPS = 0x80503d01 ++ PTP_CLOCK_GETCAPS2 = 0x80503d0a ++ PTP_ENABLE_PPS = 0x40043d04 ++ PTP_ENABLE_PPS2 = 0x40043d0d ++ PTP_EXTTS_REQUEST = 0x40103d02 ++ PTP_EXTTS_REQUEST2 = 0x40103d0b ++ PTP_MASK_CLEAR_ALL = 0x3d13 ++ PTP_MASK_EN_SINGLE = 0x40043d14 ++ PTP_PEROUT_REQUEST = 0x40383d03 ++ PTP_PEROUT_REQUEST2 = 0x40383d0c ++ PTP_PIN_SETFUNC = 0x40603d07 ++ PTP_PIN_SETFUNC2 = 0x40603d10 ++ PTP_SYS_OFFSET = 0x43403d05 ++ PTP_SYS_OFFSET2 = 0x43403d0e + PTRACE_GETFDPIC = 0x21 + PTRACE_GETFDPIC_EXEC = 0x0 + PTRACE_GETFDPIC_INTERP = 0x1 +@@ -268,6 +288,8 @@ const ( + RTC_WIE_ON = 0x700f + RTC_WKALM_RD = 0x80287010 + RTC_WKALM_SET = 0x4028700f ++ SCM_DEVMEM_DMABUF = 0x4f ++ SCM_DEVMEM_LINEAR = 0x4e + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a +@@ -306,6 +328,9 @@ const ( + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DEVMEM_DMABUF = 0x4f ++ SO_DEVMEM_DONTNEED = 0x50 ++ SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x27 + SO_DONTROUTE = 0x5 + SO_ERROR = 0x4 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go b/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go +index c48f7c2..71f0400 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go +@@ -108,6 +108,7 @@ const ( + HIDIOCGRAWINFO = 0x80084803 + HIDIOCGRDESC = 0x90044802 + HIDIOCGRDESCSIZE = 0x80044801 ++ HIDIOCREVOKE = 0x4004480d + HUPCL = 0x400 + ICANON = 0x2 + IEXTEN = 0x8000 +@@ -150,9 +151,14 @@ const ( + NFDBITS = 0x40 + NLDLY = 0x100 + NOFLSH = 0x80 ++ NS_GET_MNTNS_ID = 0x8008b705 + NS_GET_NSTYPE = 0xb703 + NS_GET_OWNER_UID = 0xb704 + NS_GET_PARENT = 0xb702 ++ NS_GET_PID_FROM_PIDNS = 0x8004b706 ++ NS_GET_PID_IN_PIDNS = 0x8004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x8004b707 ++ NS_GET_TGID_IN_PIDNS = 0x8004b709 + NS_GET_USERNS = 0xb701 + OLCUC = 0x2 + ONLCR = 0x4 +@@ -229,6 +235,20 @@ const ( + PPPIOCUNBRIDGECHAN = 0x7434 + PPPIOCXFERUNIT = 0x744e + PR_SET_PTRACER_ANY = 0xffffffffffffffff ++ PTP_CLOCK_GETCAPS = 0x80503d01 ++ PTP_CLOCK_GETCAPS2 = 0x80503d0a ++ PTP_ENABLE_PPS = 0x40043d04 ++ PTP_ENABLE_PPS2 = 0x40043d0d ++ PTP_EXTTS_REQUEST = 0x40103d02 ++ PTP_EXTTS_REQUEST2 = 0x40103d0b ++ PTP_MASK_CLEAR_ALL = 0x3d13 ++ PTP_MASK_EN_SINGLE = 0x40043d14 ++ PTP_PEROUT_REQUEST = 0x40383d03 ++ PTP_PEROUT_REQUEST2 = 0x40383d0c ++ PTP_PIN_SETFUNC = 0x40603d07 ++ PTP_PIN_SETFUNC2 = 0x40603d10 ++ PTP_SYS_OFFSET = 0x43403d05 ++ PTP_SYS_OFFSET2 = 0x43403d0e + PTRACE_DISABLE_TE = 0x5010 + PTRACE_ENABLE_TE = 0x5009 + PTRACE_GET_LAST_BREAK = 0x5006 +@@ -340,6 +360,8 @@ const ( + RTC_WIE_ON = 0x700f + RTC_WKALM_RD = 0x80287010 + RTC_WKALM_SET = 0x4028700f ++ SCM_DEVMEM_DMABUF = 0x4f ++ SCM_DEVMEM_LINEAR = 0x4e + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a +@@ -378,6 +400,9 @@ const ( + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DEVMEM_DMABUF = 0x4f ++ SO_DEVMEM_DONTNEED = 0x50 ++ SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x27 + SO_DONTROUTE = 0x5 + SO_ERROR = 0x4 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go +index ad4b9aa..c44a313 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go +@@ -112,6 +112,7 @@ const ( + HIDIOCGRAWINFO = 0x40084803 + HIDIOCGRDESC = 0x50044802 + HIDIOCGRDESCSIZE = 0x40044801 ++ HIDIOCREVOKE = 0x8004480d + HUPCL = 0x400 + ICANON = 0x2 + IEXTEN = 0x8000 +@@ -155,9 +156,14 @@ const ( + NFDBITS = 0x40 + NLDLY = 0x100 + NOFLSH = 0x80 ++ NS_GET_MNTNS_ID = 0x4008b705 + NS_GET_NSTYPE = 0x2000b703 + NS_GET_OWNER_UID = 0x2000b704 + NS_GET_PARENT = 0x2000b702 ++ NS_GET_PID_FROM_PIDNS = 0x4004b706 ++ NS_GET_PID_IN_PIDNS = 0x4004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x4004b707 ++ NS_GET_TGID_IN_PIDNS = 0x4004b709 + NS_GET_USERNS = 0x2000b701 + OLCUC = 0x2 + ONLCR = 0x4 +@@ -234,6 +240,20 @@ const ( + PPPIOCUNBRIDGECHAN = 0x20007434 + PPPIOCXFERUNIT = 0x2000744e + PR_SET_PTRACER_ANY = 0xffffffffffffffff ++ PTP_CLOCK_GETCAPS = 0x40503d01 ++ PTP_CLOCK_GETCAPS2 = 0x40503d0a ++ PTP_ENABLE_PPS = 0x80043d04 ++ PTP_ENABLE_PPS2 = 0x80043d0d ++ PTP_EXTTS_REQUEST = 0x80103d02 ++ PTP_EXTTS_REQUEST2 = 0x80103d0b ++ PTP_MASK_CLEAR_ALL = 0x20003d13 ++ PTP_MASK_EN_SINGLE = 0x80043d14 ++ PTP_PEROUT_REQUEST = 0x80383d03 ++ PTP_PEROUT_REQUEST2 = 0x80383d0c ++ PTP_PIN_SETFUNC = 0x80603d07 ++ PTP_PIN_SETFUNC2 = 0x80603d10 ++ PTP_SYS_OFFSET = 0x83403d05 ++ PTP_SYS_OFFSET2 = 0x83403d0e + PTRACE_GETFPAREGS = 0x14 + PTRACE_GETFPREGS = 0xe + PTRACE_GETFPREGS64 = 0x19 +@@ -331,6 +351,8 @@ const ( + RTC_WIE_ON = 0x2000700f + RTC_WKALM_RD = 0x40287010 + RTC_WKALM_SET = 0x8028700f ++ SCM_DEVMEM_DMABUF = 0x58 ++ SCM_DEVMEM_LINEAR = 0x57 + SCM_TIMESTAMPING = 0x23 + SCM_TIMESTAMPING_OPT_STATS = 0x38 + SCM_TIMESTAMPING_PKTINFO = 0x3c +@@ -417,6 +439,9 @@ const ( + SO_CNX_ADVICE = 0x37 + SO_COOKIE = 0x3b + SO_DETACH_REUSEPORT_BPF = 0x47 ++ SO_DEVMEM_DMABUF = 0x58 ++ SO_DEVMEM_DONTNEED = 0x59 ++ SO_DEVMEM_LINEAR = 0x57 + SO_DOMAIN = 0x1029 + SO_DONTROUTE = 0x10 + SO_ERROR = 0x1007 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_zos_s390x.go b/vendor/golang.org/x/sys/unix/zerrors_zos_s390x.go +index da08b2a..1ec2b14 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_zos_s390x.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_zos_s390x.go +@@ -581,6 +581,8 @@ const ( + AT_EMPTY_PATH = 0x1000 + AT_REMOVEDIR = 0x200 + RENAME_NOREPLACE = 1 << 0 ++ ST_RDONLY = 1 ++ ST_NOSUID = 2 + ) + + const ( +diff --git a/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go b/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go +index b622533..24b346e 100644 +--- a/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go ++++ b/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go +@@ -841,6 +841,26 @@ var libc_pthread_fchdir_np_trampoline_addr uintptr + + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + ++func connectx(fd int, endpoints *SaEndpoints, associd SaeAssocID, flags uint32, iov []Iovec, n *uintptr, connid *SaeConnID) (err error) { ++ var _p0 unsafe.Pointer ++ if len(iov) > 0 { ++ _p0 = unsafe.Pointer(&iov[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ _, _, e1 := syscall_syscall9(libc_connectx_trampoline_addr, uintptr(fd), uintptr(unsafe.Pointer(endpoints)), uintptr(associd), uintptr(flags), uintptr(_p0), uintptr(len(iov)), uintptr(unsafe.Pointer(n)), uintptr(unsafe.Pointer(connid)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++var libc_connectx_trampoline_addr uintptr ++ ++//go:cgo_import_dynamic libc_connectx connectx "/usr/lib/libSystem.B.dylib" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ + func sendfile(infd int, outfd int, offset int64, len *int64, hdtr unsafe.Pointer, flags int) (err error) { + _, _, e1 := syscall_syscall6(libc_sendfile_trampoline_addr, uintptr(infd), uintptr(outfd), uintptr(offset), uintptr(unsafe.Pointer(len)), uintptr(hdtr), uintptr(flags)) + if e1 != 0 { +diff --git a/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.s b/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.s +index cfe6646..ebd2131 100644 +--- a/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.s ++++ b/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.s +@@ -248,6 +248,11 @@ TEXT libc_pthread_fchdir_np_trampoline<>(SB),NOSPLIT,$0-0 + GLOBL ·libc_pthread_fchdir_np_trampoline_addr(SB), RODATA, $8 + DATA ·libc_pthread_fchdir_np_trampoline_addr(SB)/8, $libc_pthread_fchdir_np_trampoline<>(SB) + ++TEXT libc_connectx_trampoline<>(SB),NOSPLIT,$0-0 ++ JMP libc_connectx(SB) ++GLOBL ·libc_connectx_trampoline_addr(SB), RODATA, $8 ++DATA ·libc_connectx_trampoline_addr(SB)/8, $libc_connectx_trampoline<>(SB) ++ + TEXT libc_sendfile_trampoline<>(SB),NOSPLIT,$0-0 + JMP libc_sendfile(SB) + GLOBL ·libc_sendfile_trampoline_addr(SB), RODATA, $8 +diff --git a/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go b/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go +index 13f624f..824b9c2 100644 +--- a/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go ++++ b/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go +@@ -841,6 +841,26 @@ var libc_pthread_fchdir_np_trampoline_addr uintptr + + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + ++func connectx(fd int, endpoints *SaEndpoints, associd SaeAssocID, flags uint32, iov []Iovec, n *uintptr, connid *SaeConnID) (err error) { ++ var _p0 unsafe.Pointer ++ if len(iov) > 0 { ++ _p0 = unsafe.Pointer(&iov[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ _, _, e1 := syscall_syscall9(libc_connectx_trampoline_addr, uintptr(fd), uintptr(unsafe.Pointer(endpoints)), uintptr(associd), uintptr(flags), uintptr(_p0), uintptr(len(iov)), uintptr(unsafe.Pointer(n)), uintptr(unsafe.Pointer(connid)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++var libc_connectx_trampoline_addr uintptr ++ ++//go:cgo_import_dynamic libc_connectx connectx "/usr/lib/libSystem.B.dylib" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ + func sendfile(infd int, outfd int, offset int64, len *int64, hdtr unsafe.Pointer, flags int) (err error) { + _, _, e1 := syscall_syscall6(libc_sendfile_trampoline_addr, uintptr(infd), uintptr(outfd), uintptr(offset), uintptr(unsafe.Pointer(len)), uintptr(hdtr), uintptr(flags)) + if e1 != 0 { +diff --git a/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.s b/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.s +index fe222b7..4f178a2 100644 +--- a/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.s ++++ b/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.s +@@ -248,6 +248,11 @@ TEXT libc_pthread_fchdir_np_trampoline<>(SB),NOSPLIT,$0-0 + GLOBL ·libc_pthread_fchdir_np_trampoline_addr(SB), RODATA, $8 + DATA ·libc_pthread_fchdir_np_trampoline_addr(SB)/8, $libc_pthread_fchdir_np_trampoline<>(SB) + ++TEXT libc_connectx_trampoline<>(SB),NOSPLIT,$0-0 ++ JMP libc_connectx(SB) ++GLOBL ·libc_connectx_trampoline_addr(SB), RODATA, $8 ++DATA ·libc_connectx_trampoline_addr(SB)/8, $libc_connectx_trampoline<>(SB) ++ + TEXT libc_sendfile_trampoline<>(SB),NOSPLIT,$0-0 + JMP libc_sendfile(SB) + GLOBL ·libc_sendfile_trampoline_addr(SB), RODATA, $8 +diff --git a/vendor/golang.org/x/sys/unix/zsyscall_linux.go b/vendor/golang.org/x/sys/unix/zsyscall_linux.go +index 1bc1a5a..5cc1e8e 100644 +--- a/vendor/golang.org/x/sys/unix/zsyscall_linux.go ++++ b/vendor/golang.org/x/sys/unix/zsyscall_linux.go +@@ -592,6 +592,16 @@ func ClockGettime(clockid int32, time *Timespec) (err error) { + + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + ++func ClockSettime(clockid int32, time *Timespec) (err error) { ++ _, _, e1 := Syscall(SYS_CLOCK_SETTIME, uintptr(clockid), uintptr(unsafe.Pointer(time)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ + func ClockNanosleep(clockid int32, flags int, request *Timespec, remain *Timespec) (err error) { + _, _, e1 := Syscall6(SYS_CLOCK_NANOSLEEP, uintptr(clockid), uintptr(flags), uintptr(unsafe.Pointer(request)), uintptr(unsafe.Pointer(remain)), 0, 0) + if e1 != 0 { +@@ -971,23 +981,6 @@ func Getpriority(which int, who int) (prio int, err error) { + + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +-func Getrandom(buf []byte, flags int) (n int, err error) { +- var _p0 unsafe.Pointer +- if len(buf) > 0 { +- _p0 = unsafe.Pointer(&buf[0]) +- } else { +- _p0 = unsafe.Pointer(&_zero) +- } +- r0, _, e1 := Syscall(SYS_GETRANDOM, uintptr(_p0), uintptr(len(buf)), uintptr(flags)) +- n = int(r0) +- if e1 != 0 { +- err = errnoErr(e1) +- } +- return +-} +- +-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT +- + func Getrusage(who int, rusage *Rusage) (err error) { + _, _, e1 := RawSyscall(SYS_GETRUSAGE, uintptr(who), uintptr(unsafe.Pointer(rusage)), 0) + if e1 != 0 { +diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go +index d3e38f6..f485dbf 100644 +--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go ++++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go +@@ -341,6 +341,7 @@ const ( + SYS_STATX = 332 + SYS_IO_PGETEVENTS = 333 + SYS_RSEQ = 334 ++ SYS_URETPROBE = 335 + SYS_PIDFD_SEND_SIGNAL = 424 + SYS_IO_URING_SETUP = 425 + SYS_IO_URING_ENTER = 426 +diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go +index 6c778c2..1893e2f 100644 +--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go ++++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go +@@ -85,7 +85,7 @@ const ( + SYS_SPLICE = 76 + SYS_TEE = 77 + SYS_READLINKAT = 78 +- SYS_FSTATAT = 79 ++ SYS_NEWFSTATAT = 79 + SYS_FSTAT = 80 + SYS_SYNC = 81 + SYS_FSYNC = 82 +diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_loong64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_loong64.go +index 37281cf..16a4017 100644 +--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_loong64.go ++++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_loong64.go +@@ -84,6 +84,8 @@ const ( + SYS_SPLICE = 76 + SYS_TEE = 77 + SYS_READLINKAT = 78 ++ SYS_NEWFSTATAT = 79 ++ SYS_FSTAT = 80 + SYS_SYNC = 81 + SYS_FSYNC = 82 + SYS_FDATASYNC = 83 +diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go +index 9889f6a..a5459e7 100644 +--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go ++++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go +@@ -84,7 +84,7 @@ const ( + SYS_SPLICE = 76 + SYS_TEE = 77 + SYS_READLINKAT = 78 +- SYS_FSTATAT = 79 ++ SYS_NEWFSTATAT = 79 + SYS_FSTAT = 80 + SYS_SYNC = 81 + SYS_FSYNC = 82 +diff --git a/vendor/golang.org/x/sys/unix/ztypes_darwin_amd64.go b/vendor/golang.org/x/sys/unix/ztypes_darwin_amd64.go +index 091d107..17c53bd 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_darwin_amd64.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_darwin_amd64.go +@@ -306,6 +306,19 @@ type XVSockPgen struct { + + type _Socklen uint32 + ++type SaeAssocID uint32 ++ ++type SaeConnID uint32 ++ ++type SaEndpoints struct { ++ Srcif uint32 ++ Srcaddr *RawSockaddr ++ Srcaddrlen uint32 ++ Dstaddr *RawSockaddr ++ Dstaddrlen uint32 ++ _ [4]byte ++} ++ + type Xucred struct { + Version uint32 + Uid uint32 +@@ -449,11 +462,14 @@ type FdSet struct { + + const ( + SizeofIfMsghdr = 0x70 ++ SizeofIfMsghdr2 = 0xa0 + SizeofIfData = 0x60 ++ SizeofIfData64 = 0x80 + SizeofIfaMsghdr = 0x14 + SizeofIfmaMsghdr = 0x10 + SizeofIfmaMsghdr2 = 0x14 + SizeofRtMsghdr = 0x5c ++ SizeofRtMsghdr2 = 0x5c + SizeofRtMetrics = 0x38 + ) + +@@ -467,6 +483,20 @@ type IfMsghdr struct { + Data IfData + } + ++type IfMsghdr2 struct { ++ Msglen uint16 ++ Version uint8 ++ Type uint8 ++ Addrs int32 ++ Flags int32 ++ Index uint16 ++ Snd_len int32 ++ Snd_maxlen int32 ++ Snd_drops int32 ++ Timer int32 ++ Data IfData64 ++} ++ + type IfData struct { + Type uint8 + Typelen uint8 +@@ -499,6 +529,34 @@ type IfData struct { + Reserved2 uint32 + } + ++type IfData64 struct { ++ Type uint8 ++ Typelen uint8 ++ Physical uint8 ++ Addrlen uint8 ++ Hdrlen uint8 ++ Recvquota uint8 ++ Xmitquota uint8 ++ Unused1 uint8 ++ Mtu uint32 ++ Metric uint32 ++ Baudrate uint64 ++ Ipackets uint64 ++ Ierrors uint64 ++ Opackets uint64 ++ Oerrors uint64 ++ Collisions uint64 ++ Ibytes uint64 ++ Obytes uint64 ++ Imcasts uint64 ++ Omcasts uint64 ++ Iqdrops uint64 ++ Noproto uint64 ++ Recvtiming uint32 ++ Xmittiming uint32 ++ Lastchange Timeval32 ++} ++ + type IfaMsghdr struct { + Msglen uint16 + Version uint8 +@@ -544,6 +602,21 @@ type RtMsghdr struct { + Rmx RtMetrics + } + ++type RtMsghdr2 struct { ++ Msglen uint16 ++ Version uint8 ++ Type uint8 ++ Index uint16 ++ Flags int32 ++ Addrs int32 ++ Refcnt int32 ++ Parentflags int32 ++ Reserved int32 ++ Use int32 ++ Inits uint32 ++ Rmx RtMetrics ++} ++ + type RtMetrics struct { + Locks uint32 + Mtu uint32 +diff --git a/vendor/golang.org/x/sys/unix/ztypes_darwin_arm64.go b/vendor/golang.org/x/sys/unix/ztypes_darwin_arm64.go +index 28ff4ef..2392226 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_darwin_arm64.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_darwin_arm64.go +@@ -306,6 +306,19 @@ type XVSockPgen struct { + + type _Socklen uint32 + ++type SaeAssocID uint32 ++ ++type SaeConnID uint32 ++ ++type SaEndpoints struct { ++ Srcif uint32 ++ Srcaddr *RawSockaddr ++ Srcaddrlen uint32 ++ Dstaddr *RawSockaddr ++ Dstaddrlen uint32 ++ _ [4]byte ++} ++ + type Xucred struct { + Version uint32 + Uid uint32 +@@ -449,11 +462,14 @@ type FdSet struct { + + const ( + SizeofIfMsghdr = 0x70 ++ SizeofIfMsghdr2 = 0xa0 + SizeofIfData = 0x60 ++ SizeofIfData64 = 0x80 + SizeofIfaMsghdr = 0x14 + SizeofIfmaMsghdr = 0x10 + SizeofIfmaMsghdr2 = 0x14 + SizeofRtMsghdr = 0x5c ++ SizeofRtMsghdr2 = 0x5c + SizeofRtMetrics = 0x38 + ) + +@@ -467,6 +483,20 @@ type IfMsghdr struct { + Data IfData + } + ++type IfMsghdr2 struct { ++ Msglen uint16 ++ Version uint8 ++ Type uint8 ++ Addrs int32 ++ Flags int32 ++ Index uint16 ++ Snd_len int32 ++ Snd_maxlen int32 ++ Snd_drops int32 ++ Timer int32 ++ Data IfData64 ++} ++ + type IfData struct { + Type uint8 + Typelen uint8 +@@ -499,6 +529,34 @@ type IfData struct { + Reserved2 uint32 + } + ++type IfData64 struct { ++ Type uint8 ++ Typelen uint8 ++ Physical uint8 ++ Addrlen uint8 ++ Hdrlen uint8 ++ Recvquota uint8 ++ Xmitquota uint8 ++ Unused1 uint8 ++ Mtu uint32 ++ Metric uint32 ++ Baudrate uint64 ++ Ipackets uint64 ++ Ierrors uint64 ++ Opackets uint64 ++ Oerrors uint64 ++ Collisions uint64 ++ Ibytes uint64 ++ Obytes uint64 ++ Imcasts uint64 ++ Omcasts uint64 ++ Iqdrops uint64 ++ Noproto uint64 ++ Recvtiming uint32 ++ Xmittiming uint32 ++ Lastchange Timeval32 ++} ++ + type IfaMsghdr struct { + Msglen uint16 + Version uint8 +@@ -544,6 +602,21 @@ type RtMsghdr struct { + Rmx RtMetrics + } + ++type RtMsghdr2 struct { ++ Msglen uint16 ++ Version uint8 ++ Type uint8 ++ Index uint16 ++ Flags int32 ++ Addrs int32 ++ Refcnt int32 ++ Parentflags int32 ++ Reserved int32 ++ Use int32 ++ Inits uint32 ++ Rmx RtMetrics ++} ++ + type RtMetrics struct { + Locks uint32 + Mtu uint32 +diff --git a/vendor/golang.org/x/sys/unix/ztypes_freebsd_386.go b/vendor/golang.org/x/sys/unix/ztypes_freebsd_386.go +index 6cbd094..51e13eb 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_freebsd_386.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_freebsd_386.go +@@ -625,6 +625,7 @@ const ( + POLLRDNORM = 0x40 + POLLWRBAND = 0x100 + POLLWRNORM = 0x4 ++ POLLRDHUP = 0x4000 + ) + + type CapRights struct { +diff --git a/vendor/golang.org/x/sys/unix/ztypes_freebsd_amd64.go b/vendor/golang.org/x/sys/unix/ztypes_freebsd_amd64.go +index 7c03b6e..d002d8e 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_freebsd_amd64.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_freebsd_amd64.go +@@ -630,6 +630,7 @@ const ( + POLLRDNORM = 0x40 + POLLWRBAND = 0x100 + POLLWRNORM = 0x4 ++ POLLRDHUP = 0x4000 + ) + + type CapRights struct { +diff --git a/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm.go b/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm.go +index 422107e..3f863d8 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm.go +@@ -616,6 +616,7 @@ const ( + POLLRDNORM = 0x40 + POLLWRBAND = 0x100 + POLLWRNORM = 0x4 ++ POLLRDHUP = 0x4000 + ) + + type CapRights struct { +diff --git a/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm64.go b/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm64.go +index 505a12a..61c7293 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm64.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm64.go +@@ -610,6 +610,7 @@ const ( + POLLRDNORM = 0x40 + POLLWRBAND = 0x100 + POLLWRNORM = 0x4 ++ POLLRDHUP = 0x4000 + ) + + type CapRights struct { +diff --git a/vendor/golang.org/x/sys/unix/ztypes_freebsd_riscv64.go b/vendor/golang.org/x/sys/unix/ztypes_freebsd_riscv64.go +index cc986c7..b5d1741 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_freebsd_riscv64.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_freebsd_riscv64.go +@@ -612,6 +612,7 @@ const ( + POLLRDNORM = 0x40 + POLLWRBAND = 0x100 + POLLWRNORM = 0x4 ++ POLLRDHUP = 0x4000 + ) + + type CapRights struct { +diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux.go b/vendor/golang.org/x/sys/unix/ztypes_linux.go +index b102b95..5537148 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_linux.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_linux.go +@@ -87,31 +87,35 @@ type StatxTimestamp struct { + } + + type Statx_t struct { +- Mask uint32 +- Blksize uint32 +- Attributes uint64 +- Nlink uint32 +- Uid uint32 +- Gid uint32 +- Mode uint16 +- _ [1]uint16 +- Ino uint64 +- Size uint64 +- Blocks uint64 +- Attributes_mask uint64 +- Atime StatxTimestamp +- Btime StatxTimestamp +- Ctime StatxTimestamp +- Mtime StatxTimestamp +- Rdev_major uint32 +- Rdev_minor uint32 +- Dev_major uint32 +- Dev_minor uint32 +- Mnt_id uint64 +- Dio_mem_align uint32 +- Dio_offset_align uint32 +- Subvol uint64 +- _ [11]uint64 ++ Mask uint32 ++ Blksize uint32 ++ Attributes uint64 ++ Nlink uint32 ++ Uid uint32 ++ Gid uint32 ++ Mode uint16 ++ _ [1]uint16 ++ Ino uint64 ++ Size uint64 ++ Blocks uint64 ++ Attributes_mask uint64 ++ Atime StatxTimestamp ++ Btime StatxTimestamp ++ Ctime StatxTimestamp ++ Mtime StatxTimestamp ++ Rdev_major uint32 ++ Rdev_minor uint32 ++ Dev_major uint32 ++ Dev_minor uint32 ++ Mnt_id uint64 ++ Dio_mem_align uint32 ++ Dio_offset_align uint32 ++ Subvol uint64 ++ Atomic_write_unit_min uint32 ++ Atomic_write_unit_max uint32 ++ Atomic_write_segments_max uint32 ++ _ [1]uint32 ++ _ [9]uint64 + } + + type Fsid struct { +@@ -516,6 +520,29 @@ type TCPInfo struct { + Total_rto_time uint32 + } + ++type TCPVegasInfo struct { ++ Enabled uint32 ++ Rttcnt uint32 ++ Rtt uint32 ++ Minrtt uint32 ++} ++ ++type TCPDCTCPInfo struct { ++ Enabled uint16 ++ Ce_state uint16 ++ Alpha uint32 ++ Ab_ecn uint32 ++ Ab_tot uint32 ++} ++ ++type TCPBBRInfo struct { ++ Bw_lo uint32 ++ Bw_hi uint32 ++ Min_rtt uint32 ++ Pacing_gain uint32 ++ Cwnd_gain uint32 ++} ++ + type CanFilter struct { + Id uint32 + Mask uint32 +@@ -557,6 +584,7 @@ const ( + SizeofICMPv6Filter = 0x20 + SizeofUcred = 0xc + SizeofTCPInfo = 0xf8 ++ SizeofTCPCCInfo = 0x14 + SizeofCanFilter = 0x8 + SizeofTCPRepairOpt = 0x8 + ) +@@ -1724,12 +1752,6 @@ const ( + IFLA_IPVLAN_UNSPEC = 0x0 + IFLA_IPVLAN_MODE = 0x1 + IFLA_IPVLAN_FLAGS = 0x2 +- NETKIT_NEXT = -0x1 +- NETKIT_PASS = 0x0 +- NETKIT_DROP = 0x2 +- NETKIT_REDIRECT = 0x7 +- NETKIT_L2 = 0x0 +- NETKIT_L3 = 0x1 + IFLA_NETKIT_UNSPEC = 0x0 + IFLA_NETKIT_PEER_INFO = 0x1 + IFLA_NETKIT_PRIMARY = 0x2 +@@ -1768,6 +1790,7 @@ const ( + IFLA_VXLAN_DF = 0x1d + IFLA_VXLAN_VNIFILTER = 0x1e + IFLA_VXLAN_LOCALBYPASS = 0x1f ++ IFLA_VXLAN_LABEL_POLICY = 0x20 + IFLA_GENEVE_UNSPEC = 0x0 + IFLA_GENEVE_ID = 0x1 + IFLA_GENEVE_REMOTE = 0x2 +@@ -1797,6 +1820,8 @@ const ( + IFLA_GTP_ROLE = 0x4 + IFLA_GTP_CREATE_SOCKETS = 0x5 + IFLA_GTP_RESTART_COUNT = 0x6 ++ IFLA_GTP_LOCAL = 0x7 ++ IFLA_GTP_LOCAL6 = 0x8 + IFLA_BOND_UNSPEC = 0x0 + IFLA_BOND_MODE = 0x1 + IFLA_BOND_ACTIVE_SLAVE = 0x2 +@@ -1829,6 +1854,7 @@ const ( + IFLA_BOND_AD_LACP_ACTIVE = 0x1d + IFLA_BOND_MISSED_MAX = 0x1e + IFLA_BOND_NS_IP6_TARGET = 0x1f ++ IFLA_BOND_COUPLED_CONTROL = 0x20 + IFLA_BOND_AD_INFO_UNSPEC = 0x0 + IFLA_BOND_AD_INFO_AGGREGATOR = 0x1 + IFLA_BOND_AD_INFO_NUM_PORTS = 0x2 +@@ -1897,6 +1923,7 @@ const ( + IFLA_HSR_SEQ_NR = 0x5 + IFLA_HSR_VERSION = 0x6 + IFLA_HSR_PROTOCOL = 0x7 ++ IFLA_HSR_INTERLINK = 0x8 + IFLA_STATS_UNSPEC = 0x0 + IFLA_STATS_LINK_64 = 0x1 + IFLA_STATS_LINK_XSTATS = 0x2 +@@ -1949,6 +1976,15 @@ const ( + IFLA_DSA_MASTER = 0x1 + ) + ++const ( ++ NETKIT_NEXT = -0x1 ++ NETKIT_PASS = 0x0 ++ NETKIT_DROP = 0x2 ++ NETKIT_REDIRECT = 0x7 ++ NETKIT_L2 = 0x0 ++ NETKIT_L3 = 0x1 ++) ++ + const ( + NF_INET_PRE_ROUTING = 0x0 + NF_INET_LOCAL_IN = 0x1 +@@ -2486,7 +2522,7 @@ type XDPMmapOffsets struct { + type XDPUmemReg struct { + Addr uint64 + Len uint64 +- Chunk_size uint32 ++ Size uint32 + Headroom uint32 + Flags uint32 + Tx_metadata_len uint32 +@@ -2558,8 +2594,8 @@ const ( + SOF_TIMESTAMPING_BIND_PHC = 0x8000 + SOF_TIMESTAMPING_OPT_ID_TCP = 0x10000 + +- SOF_TIMESTAMPING_LAST = 0x10000 +- SOF_TIMESTAMPING_MASK = 0x1ffff ++ SOF_TIMESTAMPING_LAST = 0x20000 ++ SOF_TIMESTAMPING_MASK = 0x3ffff + + SCM_TSTAMP_SND = 0x0 + SCM_TSTAMP_SCHED = 0x1 +@@ -3505,7 +3541,7 @@ type Nhmsg struct { + type NexthopGrp struct { + Id uint32 + Weight uint8 +- Resvd1 uint8 ++ High uint8 + Resvd2 uint16 + } + +@@ -3766,7 +3802,7 @@ const ( + ETHTOOL_MSG_PSE_GET = 0x24 + ETHTOOL_MSG_PSE_SET = 0x25 + ETHTOOL_MSG_RSS_GET = 0x26 +- ETHTOOL_MSG_USER_MAX = 0x2b ++ ETHTOOL_MSG_USER_MAX = 0x2d + ETHTOOL_MSG_KERNEL_NONE = 0x0 + ETHTOOL_MSG_STRSET_GET_REPLY = 0x1 + ETHTOOL_MSG_LINKINFO_GET_REPLY = 0x2 +@@ -3806,12 +3842,15 @@ const ( + ETHTOOL_MSG_MODULE_NTF = 0x24 + ETHTOOL_MSG_PSE_GET_REPLY = 0x25 + ETHTOOL_MSG_RSS_GET_REPLY = 0x26 +- ETHTOOL_MSG_KERNEL_MAX = 0x2b ++ ETHTOOL_MSG_KERNEL_MAX = 0x2e ++ ETHTOOL_FLAG_COMPACT_BITSETS = 0x1 ++ ETHTOOL_FLAG_OMIT_REPLY = 0x2 ++ ETHTOOL_FLAG_STATS = 0x4 + ETHTOOL_A_HEADER_UNSPEC = 0x0 + ETHTOOL_A_HEADER_DEV_INDEX = 0x1 + ETHTOOL_A_HEADER_DEV_NAME = 0x2 + ETHTOOL_A_HEADER_FLAGS = 0x3 +- ETHTOOL_A_HEADER_MAX = 0x3 ++ ETHTOOL_A_HEADER_MAX = 0x4 + ETHTOOL_A_BITSET_BIT_UNSPEC = 0x0 + ETHTOOL_A_BITSET_BIT_INDEX = 0x1 + ETHTOOL_A_BITSET_BIT_NAME = 0x2 +@@ -3948,7 +3987,7 @@ const ( + ETHTOOL_A_COALESCE_RATE_SAMPLE_INTERVAL = 0x17 + ETHTOOL_A_COALESCE_USE_CQE_MODE_TX = 0x18 + ETHTOOL_A_COALESCE_USE_CQE_MODE_RX = 0x19 +- ETHTOOL_A_COALESCE_MAX = 0x1c ++ ETHTOOL_A_COALESCE_MAX = 0x1e + ETHTOOL_A_PAUSE_UNSPEC = 0x0 + ETHTOOL_A_PAUSE_HEADER = 0x1 + ETHTOOL_A_PAUSE_AUTONEG = 0x2 +@@ -3992,11 +4031,11 @@ const ( + ETHTOOL_A_CABLE_RESULT_UNSPEC = 0x0 + ETHTOOL_A_CABLE_RESULT_PAIR = 0x1 + ETHTOOL_A_CABLE_RESULT_CODE = 0x2 +- ETHTOOL_A_CABLE_RESULT_MAX = 0x2 ++ ETHTOOL_A_CABLE_RESULT_MAX = 0x3 + ETHTOOL_A_CABLE_FAULT_LENGTH_UNSPEC = 0x0 + ETHTOOL_A_CABLE_FAULT_LENGTH_PAIR = 0x1 + ETHTOOL_A_CABLE_FAULT_LENGTH_CM = 0x2 +- ETHTOOL_A_CABLE_FAULT_LENGTH_MAX = 0x2 ++ ETHTOOL_A_CABLE_FAULT_LENGTH_MAX = 0x3 + ETHTOOL_A_CABLE_TEST_NTF_STATUS_UNSPEC = 0x0 + ETHTOOL_A_CABLE_TEST_NTF_STATUS_STARTED = 0x1 + ETHTOOL_A_CABLE_TEST_NTF_STATUS_COMPLETED = 0x2 +@@ -4079,6 +4118,107 @@ type EthtoolDrvinfo struct { + Regdump_len uint32 + } + ++type EthtoolTsInfo struct { ++ Cmd uint32 ++ So_timestamping uint32 ++ Phc_index int32 ++ Tx_types uint32 ++ Tx_reserved [3]uint32 ++ Rx_filters uint32 ++ Rx_reserved [3]uint32 ++} ++ ++type HwTstampConfig struct { ++ Flags int32 ++ Tx_type int32 ++ Rx_filter int32 ++} ++ ++const ( ++ HWTSTAMP_FILTER_NONE = 0x0 ++ HWTSTAMP_FILTER_ALL = 0x1 ++ HWTSTAMP_FILTER_SOME = 0x2 ++ HWTSTAMP_FILTER_PTP_V1_L4_EVENT = 0x3 ++ HWTSTAMP_FILTER_PTP_V2_L4_EVENT = 0x6 ++ HWTSTAMP_FILTER_PTP_V2_L2_EVENT = 0x9 ++ HWTSTAMP_FILTER_PTP_V2_EVENT = 0xc ++) ++ ++const ( ++ HWTSTAMP_TX_OFF = 0x0 ++ HWTSTAMP_TX_ON = 0x1 ++ HWTSTAMP_TX_ONESTEP_SYNC = 0x2 ++) ++ ++type ( ++ PtpClockCaps struct { ++ Max_adj int32 ++ N_alarm int32 ++ N_ext_ts int32 ++ N_per_out int32 ++ Pps int32 ++ N_pins int32 ++ Cross_timestamping int32 ++ Adjust_phase int32 ++ Max_phase_adj int32 ++ Rsv [11]int32 ++ } ++ PtpClockTime struct { ++ Sec int64 ++ Nsec uint32 ++ Reserved uint32 ++ } ++ PtpExttsEvent struct { ++ T PtpClockTime ++ Index uint32 ++ Flags uint32 ++ Rsv [2]uint32 ++ } ++ PtpExttsRequest struct { ++ Index uint32 ++ Flags uint32 ++ Rsv [2]uint32 ++ } ++ PtpPeroutRequest struct { ++ StartOrPhase PtpClockTime ++ Period PtpClockTime ++ Index uint32 ++ Flags uint32 ++ On PtpClockTime ++ } ++ PtpPinDesc struct { ++ Name [64]byte ++ Index uint32 ++ Func uint32 ++ Chan uint32 ++ Rsv [5]uint32 ++ } ++ PtpSysOffset struct { ++ Samples uint32 ++ Rsv [3]uint32 ++ Ts [51]PtpClockTime ++ } ++ PtpSysOffsetExtended struct { ++ Samples uint32 ++ Clockid int32 ++ Rsv [2]uint32 ++ Ts [25][3]PtpClockTime ++ } ++ PtpSysOffsetPrecise struct { ++ Device PtpClockTime ++ Realtime PtpClockTime ++ Monoraw PtpClockTime ++ Rsv [4]uint32 ++ } ++) ++ ++const ( ++ PTP_PF_NONE = 0x0 ++ PTP_PF_EXTTS = 0x1 ++ PTP_PF_PEROUT = 0x2 ++ PTP_PF_PHYSYNC = 0x3 ++) ++ + type ( + HIDRawReportDescriptor struct { + Size uint32 +@@ -4260,6 +4400,7 @@ const ( + type LandlockRulesetAttr struct { + Access_fs uint64 + Access_net uint64 ++ Scoped uint64 + } + + type LandlockPathBeneathAttr struct { +@@ -4606,7 +4747,7 @@ const ( + NL80211_ATTR_MAC_HINT = 0xc8 + NL80211_ATTR_MAC_MASK = 0xd7 + NL80211_ATTR_MAX_AP_ASSOC_STA = 0xca +- NL80211_ATTR_MAX = 0x14a ++ NL80211_ATTR_MAX = 0x14c + NL80211_ATTR_MAX_CRIT_PROT_DURATION = 0xb4 + NL80211_ATTR_MAX_CSA_COUNTERS = 0xce + NL80211_ATTR_MAX_MATCH_SETS = 0x85 +@@ -5210,7 +5351,7 @@ const ( + NL80211_FREQUENCY_ATTR_GO_CONCURRENT = 0xf + NL80211_FREQUENCY_ATTR_INDOOR_ONLY = 0xe + NL80211_FREQUENCY_ATTR_IR_CONCURRENT = 0xf +- NL80211_FREQUENCY_ATTR_MAX = 0x20 ++ NL80211_FREQUENCY_ATTR_MAX = 0x21 + NL80211_FREQUENCY_ATTR_MAX_TX_POWER = 0x6 + NL80211_FREQUENCY_ATTR_NO_10MHZ = 0x11 + NL80211_FREQUENCY_ATTR_NO_160MHZ = 0xc +diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go b/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go +index 15adc04..ad05b51 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go +@@ -727,6 +727,37 @@ const ( + RISCV_HWPROBE_EXT_ZBA = 0x8 + RISCV_HWPROBE_EXT_ZBB = 0x10 + RISCV_HWPROBE_EXT_ZBS = 0x20 ++ RISCV_HWPROBE_EXT_ZICBOZ = 0x40 ++ RISCV_HWPROBE_EXT_ZBC = 0x80 ++ RISCV_HWPROBE_EXT_ZBKB = 0x100 ++ RISCV_HWPROBE_EXT_ZBKC = 0x200 ++ RISCV_HWPROBE_EXT_ZBKX = 0x400 ++ RISCV_HWPROBE_EXT_ZKND = 0x800 ++ RISCV_HWPROBE_EXT_ZKNE = 0x1000 ++ RISCV_HWPROBE_EXT_ZKNH = 0x2000 ++ RISCV_HWPROBE_EXT_ZKSED = 0x4000 ++ RISCV_HWPROBE_EXT_ZKSH = 0x8000 ++ RISCV_HWPROBE_EXT_ZKT = 0x10000 ++ RISCV_HWPROBE_EXT_ZVBB = 0x20000 ++ RISCV_HWPROBE_EXT_ZVBC = 0x40000 ++ RISCV_HWPROBE_EXT_ZVKB = 0x80000 ++ RISCV_HWPROBE_EXT_ZVKG = 0x100000 ++ RISCV_HWPROBE_EXT_ZVKNED = 0x200000 ++ RISCV_HWPROBE_EXT_ZVKNHA = 0x400000 ++ RISCV_HWPROBE_EXT_ZVKNHB = 0x800000 ++ RISCV_HWPROBE_EXT_ZVKSED = 0x1000000 ++ RISCV_HWPROBE_EXT_ZVKSH = 0x2000000 ++ RISCV_HWPROBE_EXT_ZVKT = 0x4000000 ++ RISCV_HWPROBE_EXT_ZFH = 0x8000000 ++ RISCV_HWPROBE_EXT_ZFHMIN = 0x10000000 ++ RISCV_HWPROBE_EXT_ZIHINTNTL = 0x20000000 ++ RISCV_HWPROBE_EXT_ZVFH = 0x40000000 ++ RISCV_HWPROBE_EXT_ZVFHMIN = 0x80000000 ++ RISCV_HWPROBE_EXT_ZFA = 0x100000000 ++ RISCV_HWPROBE_EXT_ZTSO = 0x200000000 ++ RISCV_HWPROBE_EXT_ZACAS = 0x400000000 ++ RISCV_HWPROBE_EXT_ZICOND = 0x800000000 ++ RISCV_HWPROBE_EXT_ZIHINTPAUSE = 0x1000000000 + RISCV_HWPROBE_KEY_CPUPERF_0 = 0x5 + RISCV_HWPROBE_MISALIGNED_UNKNOWN = 0x0 + RISCV_HWPROBE_MISALIGNED_EMULATED = 0x1 +@@ -734,4 +765,6 @@ const ( + RISCV_HWPROBE_MISALIGNED_FAST = 0x3 + RISCV_HWPROBE_MISALIGNED_UNSUPPORTED = 0x4 + RISCV_HWPROBE_MISALIGNED_MASK = 0x7 ++ RISCV_HWPROBE_KEY_ZICBOZ_BLOCK_SIZE = 0x6 ++ RISCV_HWPROBE_WHICH_CPUS = 0x1 + ) +diff --git a/vendor/golang.org/x/sys/unix/ztypes_zos_s390x.go b/vendor/golang.org/x/sys/unix/ztypes_zos_s390x.go +index d9a13af..2e5d5a4 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_zos_s390x.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_zos_s390x.go +@@ -377,6 +377,12 @@ type Flock_t struct { + Pid int32 + } + ++type F_cnvrt struct { ++ Cvtcmd int32 ++ Pccsid int16 ++ Fccsid int16 ++} ++ + type Termios struct { + Cflag uint32 + Iflag uint32 +diff --git a/vendor/golang.org/x/sys/windows/dll_windows.go b/vendor/golang.org/x/sys/windows/dll_windows.go +index 115341f..4e613cf 100644 +--- a/vendor/golang.org/x/sys/windows/dll_windows.go ++++ b/vendor/golang.org/x/sys/windows/dll_windows.go +@@ -65,7 +65,7 @@ func LoadDLL(name string) (dll *DLL, err error) { + return d, nil + } + +-// MustLoadDLL is like LoadDLL but panics if load operation failes. ++// MustLoadDLL is like LoadDLL but panics if load operation fails. + func MustLoadDLL(name string) *DLL { + d, e := LoadDLL(name) + if e != nil { +diff --git a/vendor/golang.org/x/sys/windows/syscall_windows.go b/vendor/golang.org/x/sys/windows/syscall_windows.go +index 1fa34fd..4a32543 100644 +--- a/vendor/golang.org/x/sys/windows/syscall_windows.go ++++ b/vendor/golang.org/x/sys/windows/syscall_windows.go +@@ -168,6 +168,8 @@ func NewCallbackCDecl(fn interface{}) uintptr { + //sys CreateNamedPipe(name *uint16, flags uint32, pipeMode uint32, maxInstances uint32, outSize uint32, inSize uint32, defaultTimeout uint32, sa *SecurityAttributes) (handle Handle, err error) [failretval==InvalidHandle] = CreateNamedPipeW + //sys ConnectNamedPipe(pipe Handle, overlapped *Overlapped) (err error) + //sys DisconnectNamedPipe(pipe Handle) (err error) ++//sys GetNamedPipeClientProcessId(pipe Handle, clientProcessID *uint32) (err error) ++//sys GetNamedPipeServerProcessId(pipe Handle, serverProcessID *uint32) (err error) + //sys GetNamedPipeInfo(pipe Handle, flags *uint32, outSize *uint32, inSize *uint32, maxInstances *uint32) (err error) + //sys GetNamedPipeHandleState(pipe Handle, state *uint32, curInstances *uint32, maxCollectionCount *uint32, collectDataTimeout *uint32, userName *uint16, maxUserNameSize uint32) (err error) = GetNamedPipeHandleStateW + //sys SetNamedPipeHandleState(pipe Handle, state *uint32, maxCollectionCount *uint32, collectDataTimeout *uint32) (err error) = SetNamedPipeHandleState +@@ -313,6 +315,10 @@ func NewCallbackCDecl(fn interface{}) uintptr { + //sys SetConsoleMode(console Handle, mode uint32) (err error) = kernel32.SetConsoleMode + //sys GetConsoleScreenBufferInfo(console Handle, info *ConsoleScreenBufferInfo) (err error) = kernel32.GetConsoleScreenBufferInfo + //sys setConsoleCursorPosition(console Handle, position uint32) (err error) = kernel32.SetConsoleCursorPosition ++//sys GetConsoleCP() (cp uint32, err error) = kernel32.GetConsoleCP ++//sys GetConsoleOutputCP() (cp uint32, err error) = kernel32.GetConsoleOutputCP ++//sys SetConsoleCP(cp uint32) (err error) = kernel32.SetConsoleCP ++//sys SetConsoleOutputCP(cp uint32) (err error) = kernel32.SetConsoleOutputCP + //sys WriteConsole(console Handle, buf *uint16, towrite uint32, written *uint32, reserved *byte) (err error) = kernel32.WriteConsoleW + //sys ReadConsole(console Handle, buf *uint16, toread uint32, read *uint32, inputControl *byte) (err error) = kernel32.ReadConsoleW + //sys resizePseudoConsole(pconsole Handle, size uint32) (hr error) = kernel32.ResizePseudoConsole +@@ -721,20 +727,12 @@ func DurationSinceBoot() time.Duration { + } + + func Ftruncate(fd Handle, length int64) (err error) { +- curoffset, e := Seek(fd, 0, 1) +- if e != nil { +- return e +- } +- defer Seek(fd, curoffset, 0) +- _, e = Seek(fd, length, 0) +- if e != nil { +- return e ++ type _FILE_END_OF_FILE_INFO struct { ++ EndOfFile int64 + } +- e = SetEndOfFile(fd) +- if e != nil { +- return e +- } +- return nil ++ var info _FILE_END_OF_FILE_INFO ++ info.EndOfFile = length ++ return SetFileInformationByHandle(fd, FileEndOfFileInfo, (*byte)(unsafe.Pointer(&info)), uint32(unsafe.Sizeof(info))) + } + + func Gettimeofday(tv *Timeval) (err error) { +@@ -890,6 +888,11 @@ const socket_error = uintptr(^uint32(0)) + //sys GetACP() (acp uint32) = kernel32.GetACP + //sys MultiByteToWideChar(codePage uint32, dwFlags uint32, str *byte, nstr int32, wchar *uint16, nwchar int32) (nwrite int32, err error) = kernel32.MultiByteToWideChar + //sys getBestInterfaceEx(sockaddr unsafe.Pointer, pdwBestIfIndex *uint32) (errcode error) = iphlpapi.GetBestInterfaceEx ++//sys GetIfEntry2Ex(level uint32, row *MibIfRow2) (errcode error) = iphlpapi.GetIfEntry2Ex ++//sys GetUnicastIpAddressEntry(row *MibUnicastIpAddressRow) (errcode error) = iphlpapi.GetUnicastIpAddressEntry ++//sys NotifyIpInterfaceChange(family uint16, callback uintptr, callerContext unsafe.Pointer, initialNotification bool, notificationHandle *Handle) (errcode error) = iphlpapi.NotifyIpInterfaceChange ++//sys NotifyUnicastIpAddressChange(family uint16, callback uintptr, callerContext unsafe.Pointer, initialNotification bool, notificationHandle *Handle) (errcode error) = iphlpapi.NotifyUnicastIpAddressChange ++//sys CancelMibChangeNotify2(notificationHandle Handle) (errcode error) = iphlpapi.CancelMibChangeNotify2 + + // For testing: clients can set this flag to force + // creation of IPv6 sockets to return EAFNOSUPPORT. +@@ -1681,13 +1684,16 @@ func (s NTStatus) Error() string { + // do not use NTUnicodeString, and instead UTF16PtrFromString should be used for + // the more common *uint16 string type. + func NewNTUnicodeString(s string) (*NTUnicodeString, error) { +- var u NTUnicodeString +- s16, err := UTF16PtrFromString(s) ++ s16, err := UTF16FromString(s) + if err != nil { + return nil, err + } +- RtlInitUnicodeString(&u, s16) +- return &u, nil ++ n := uint16(len(s16) * 2) ++ return &NTUnicodeString{ ++ Length: n - 2, // subtract 2 bytes for the NULL terminator ++ MaximumLength: n, ++ Buffer: &s16[0], ++ }, nil + } + + // Slice returns a uint16 slice that aliases the data in the NTUnicodeString. +diff --git a/vendor/golang.org/x/sys/windows/types_windows.go b/vendor/golang.org/x/sys/windows/types_windows.go +index 4d0c157..9d138de 100644 +--- a/vendor/golang.org/x/sys/windows/types_windows.go ++++ b/vendor/golang.org/x/sys/windows/types_windows.go +@@ -176,6 +176,7 @@ const ( + WAIT_FAILED = 0xFFFFFFFF + + // Access rights for process. ++ PROCESS_ALL_ACCESS = 0xFFFF + PROCESS_CREATE_PROCESS = 0x0080 + PROCESS_CREATE_THREAD = 0x0002 + PROCESS_DUP_HANDLE = 0x0040 +@@ -1060,6 +1061,7 @@ const ( + SIO_GET_EXTENSION_FUNCTION_POINTER = IOC_INOUT | IOC_WS2 | 6 + SIO_KEEPALIVE_VALS = IOC_IN | IOC_VENDOR | 4 + SIO_UDP_CONNRESET = IOC_IN | IOC_VENDOR | 12 ++ SIO_UDP_NETRESET = IOC_IN | IOC_VENDOR | 15 + + // cf. http://support.microsoft.com/default.aspx?scid=kb;en-us;257460 + +@@ -2031,6 +2033,50 @@ const ( + IF_TYPE_IEEE1394 = 144 + ) + ++// Enum NL_PREFIX_ORIGIN for [IpAdapterUnicastAddress], see ++// https://learn.microsoft.com/en-us/windows/win32/api/nldef/ne-nldef-nl_prefix_origin ++const ( ++ IpPrefixOriginOther = 0 ++ IpPrefixOriginManual = 1 ++ IpPrefixOriginWellKnown = 2 ++ IpPrefixOriginDhcp = 3 ++ IpPrefixOriginRouterAdvertisement = 4 ++ IpPrefixOriginUnchanged = 1 << 4 ++) ++ ++// Enum NL_SUFFIX_ORIGIN for [IpAdapterUnicastAddress], see ++// https://learn.microsoft.com/en-us/windows/win32/api/nldef/ne-nldef-nl_suffix_origin ++const ( ++ NlsoOther = 0 ++ NlsoManual = 1 ++ NlsoWellKnown = 2 ++ NlsoDhcp = 3 ++ NlsoLinkLayerAddress = 4 ++ NlsoRandom = 5 ++ IpSuffixOriginOther = 0 ++ IpSuffixOriginManual = 1 ++ IpSuffixOriginWellKnown = 2 ++ IpSuffixOriginDhcp = 3 ++ IpSuffixOriginLinkLayerAddress = 4 ++ IpSuffixOriginRandom = 5 ++ IpSuffixOriginUnchanged = 1 << 4 ++) ++ ++// Enum NL_DAD_STATE for [IpAdapterUnicastAddress], see ++// https://learn.microsoft.com/en-us/windows/win32/api/nldef/ne-nldef-nl_dad_state ++const ( ++ NldsInvalid = 0 ++ NldsTentative = 1 ++ NldsDuplicate = 2 ++ NldsDeprecated = 3 ++ NldsPreferred = 4 ++ IpDadStateInvalid = 0 ++ IpDadStateTentative = 1 ++ IpDadStateDuplicate = 2 ++ IpDadStateDeprecated = 3 ++ IpDadStatePreferred = 4 ++) ++ + type SocketAddress struct { + Sockaddr *syscall.RawSockaddrAny + SockaddrLength int32 +@@ -2158,6 +2204,132 @@ const ( + IfOperStatusLowerLayerDown = 7 + ) + ++const ( ++ IF_MAX_PHYS_ADDRESS_LENGTH = 32 ++ IF_MAX_STRING_SIZE = 256 ++) ++ ++// MIB_IF_ENTRY_LEVEL enumeration from netioapi.h or ++// https://learn.microsoft.com/en-us/windows/win32/api/netioapi/nf-netioapi-getifentry2ex. ++const ( ++ MibIfEntryNormal = 0 ++ MibIfEntryNormalWithoutStatistics = 2 ++) ++ ++// MIB_NOTIFICATION_TYPE enumeration from netioapi.h or ++// https://learn.microsoft.com/en-us/windows/win32/api/netioapi/ne-netioapi-mib_notification_type. ++const ( ++ MibParameterNotification = 0 ++ MibAddInstance = 1 ++ MibDeleteInstance = 2 ++ MibInitialNotification = 3 ++) ++ ++// MibIfRow2 stores information about a particular interface. See ++// https://learn.microsoft.com/en-us/windows/win32/api/netioapi/ns-netioapi-mib_if_row2. ++type MibIfRow2 struct { ++ InterfaceLuid uint64 ++ InterfaceIndex uint32 ++ InterfaceGuid GUID ++ Alias [IF_MAX_STRING_SIZE + 1]uint16 ++ Description [IF_MAX_STRING_SIZE + 1]uint16 ++ PhysicalAddressLength uint32 ++ PhysicalAddress [IF_MAX_PHYS_ADDRESS_LENGTH]uint8 ++ PermanentPhysicalAddress [IF_MAX_PHYS_ADDRESS_LENGTH]uint8 ++ Mtu uint32 ++ Type uint32 ++ TunnelType uint32 ++ MediaType uint32 ++ PhysicalMediumType uint32 ++ AccessType uint32 ++ DirectionType uint32 ++ InterfaceAndOperStatusFlags uint8 ++ OperStatus uint32 ++ AdminStatus uint32 ++ MediaConnectState uint32 ++ NetworkGuid GUID ++ ConnectionType uint32 ++ TransmitLinkSpeed uint64 ++ ReceiveLinkSpeed uint64 ++ InOctets uint64 ++ InUcastPkts uint64 ++ InNUcastPkts uint64 ++ InDiscards uint64 ++ InErrors uint64 ++ InUnknownProtos uint64 ++ InUcastOctets uint64 ++ InMulticastOctets uint64 ++ InBroadcastOctets uint64 ++ OutOctets uint64 ++ OutUcastPkts uint64 ++ OutNUcastPkts uint64 ++ OutDiscards uint64 ++ OutErrors uint64 ++ OutUcastOctets uint64 ++ OutMulticastOctets uint64 ++ OutBroadcastOctets uint64 ++ OutQLen uint64 ++} ++ ++// MIB_UNICASTIPADDRESS_ROW stores information about a unicast IP address. See ++// https://learn.microsoft.com/en-us/windows/win32/api/netioapi/ns-netioapi-mib_unicastipaddress_row. ++type MibUnicastIpAddressRow struct { ++ Address RawSockaddrInet6 // SOCKADDR_INET union ++ InterfaceLuid uint64 ++ InterfaceIndex uint32 ++ PrefixOrigin uint32 ++ SuffixOrigin uint32 ++ ValidLifetime uint32 ++ PreferredLifetime uint32 ++ OnLinkPrefixLength uint8 ++ SkipAsSource uint8 ++ DadState uint32 ++ ScopeId uint32 ++ CreationTimeStamp Filetime ++} ++ ++const ScopeLevelCount = 16 ++ ++// MIB_IPINTERFACE_ROW stores interface management information for a particular IP address family on a network interface. ++// See https://learn.microsoft.com/en-us/windows/win32/api/netioapi/ns-netioapi-mib_ipinterface_row. ++type MibIpInterfaceRow struct { ++ Family uint16 ++ InterfaceLuid uint64 ++ InterfaceIndex uint32 ++ MaxReassemblySize uint32 ++ InterfaceIdentifier uint64 ++ MinRouterAdvertisementInterval uint32 ++ MaxRouterAdvertisementInterval uint32 ++ AdvertisingEnabled uint8 ++ ForwardingEnabled uint8 ++ WeakHostSend uint8 ++ WeakHostReceive uint8 ++ UseAutomaticMetric uint8 ++ UseNeighborUnreachabilityDetection uint8 ++ ManagedAddressConfigurationSupported uint8 ++ OtherStatefulConfigurationSupported uint8 ++ AdvertiseDefaultRoute uint8 ++ RouterDiscoveryBehavior uint32 ++ DadTransmits uint32 ++ BaseReachableTime uint32 ++ RetransmitTime uint32 ++ PathMtuDiscoveryTimeout uint32 ++ LinkLocalAddressBehavior uint32 ++ LinkLocalAddressTimeout uint32 ++ ZoneIndices [ScopeLevelCount]uint32 ++ SitePrefixLength uint32 ++ Metric uint32 ++ NlMtu uint32 ++ Connected uint8 ++ SupportsWakeUpPatterns uint8 ++ SupportsNeighborDiscovery uint8 ++ SupportsRouterDiscovery uint8 ++ ReachableTime uint32 ++ TransmitOffload uint32 ++ ReceiveOffload uint32 ++ DisableDefaultRoutes uint8 ++} ++ + // Console related constants used for the mode parameter to SetConsoleMode. See + // https://docs.microsoft.com/en-us/windows/console/setconsolemode for details. + +diff --git a/vendor/golang.org/x/sys/windows/zsyscall_windows.go b/vendor/golang.org/x/sys/windows/zsyscall_windows.go +index 9bb979a..01c0716 100644 +--- a/vendor/golang.org/x/sys/windows/zsyscall_windows.go ++++ b/vendor/golang.org/x/sys/windows/zsyscall_windows.go +@@ -181,10 +181,15 @@ var ( + procDnsRecordListFree = moddnsapi.NewProc("DnsRecordListFree") + procDwmGetWindowAttribute = moddwmapi.NewProc("DwmGetWindowAttribute") + procDwmSetWindowAttribute = moddwmapi.NewProc("DwmSetWindowAttribute") ++ procCancelMibChangeNotify2 = modiphlpapi.NewProc("CancelMibChangeNotify2") + procGetAdaptersAddresses = modiphlpapi.NewProc("GetAdaptersAddresses") + procGetAdaptersInfo = modiphlpapi.NewProc("GetAdaptersInfo") + procGetBestInterfaceEx = modiphlpapi.NewProc("GetBestInterfaceEx") + procGetIfEntry = modiphlpapi.NewProc("GetIfEntry") ++ procGetIfEntry2Ex = modiphlpapi.NewProc("GetIfEntry2Ex") ++ procGetUnicastIpAddressEntry = modiphlpapi.NewProc("GetUnicastIpAddressEntry") ++ procNotifyIpInterfaceChange = modiphlpapi.NewProc("NotifyIpInterfaceChange") ++ procNotifyUnicastIpAddressChange = modiphlpapi.NewProc("NotifyUnicastIpAddressChange") + procAddDllDirectory = modkernel32.NewProc("AddDllDirectory") + procAssignProcessToJobObject = modkernel32.NewProc("AssignProcessToJobObject") + procCancelIo = modkernel32.NewProc("CancelIo") +@@ -247,7 +252,9 @@ var ( + procGetCommandLineW = modkernel32.NewProc("GetCommandLineW") + procGetComputerNameExW = modkernel32.NewProc("GetComputerNameExW") + procGetComputerNameW = modkernel32.NewProc("GetComputerNameW") ++ procGetConsoleCP = modkernel32.NewProc("GetConsoleCP") + procGetConsoleMode = modkernel32.NewProc("GetConsoleMode") ++ procGetConsoleOutputCP = modkernel32.NewProc("GetConsoleOutputCP") + procGetConsoleScreenBufferInfo = modkernel32.NewProc("GetConsoleScreenBufferInfo") + procGetCurrentDirectoryW = modkernel32.NewProc("GetCurrentDirectoryW") + procGetCurrentProcessId = modkernel32.NewProc("GetCurrentProcessId") +@@ -273,8 +280,10 @@ var ( + procGetMaximumProcessorCount = modkernel32.NewProc("GetMaximumProcessorCount") + procGetModuleFileNameW = modkernel32.NewProc("GetModuleFileNameW") + procGetModuleHandleExW = modkernel32.NewProc("GetModuleHandleExW") ++ procGetNamedPipeClientProcessId = modkernel32.NewProc("GetNamedPipeClientProcessId") + procGetNamedPipeHandleStateW = modkernel32.NewProc("GetNamedPipeHandleStateW") + procGetNamedPipeInfo = modkernel32.NewProc("GetNamedPipeInfo") ++ procGetNamedPipeServerProcessId = modkernel32.NewProc("GetNamedPipeServerProcessId") + procGetOverlappedResult = modkernel32.NewProc("GetOverlappedResult") + procGetPriorityClass = modkernel32.NewProc("GetPriorityClass") + procGetProcAddress = modkernel32.NewProc("GetProcAddress") +@@ -347,8 +356,10 @@ var ( + procSetCommMask = modkernel32.NewProc("SetCommMask") + procSetCommState = modkernel32.NewProc("SetCommState") + procSetCommTimeouts = modkernel32.NewProc("SetCommTimeouts") ++ procSetConsoleCP = modkernel32.NewProc("SetConsoleCP") + procSetConsoleCursorPosition = modkernel32.NewProc("SetConsoleCursorPosition") + procSetConsoleMode = modkernel32.NewProc("SetConsoleMode") ++ procSetConsoleOutputCP = modkernel32.NewProc("SetConsoleOutputCP") + procSetCurrentDirectoryW = modkernel32.NewProc("SetCurrentDirectoryW") + procSetDefaultDllDirectories = modkernel32.NewProc("SetDefaultDllDirectories") + procSetDllDirectoryW = modkernel32.NewProc("SetDllDirectoryW") +@@ -1602,6 +1613,14 @@ func DwmSetWindowAttribute(hwnd HWND, attribute uint32, value unsafe.Pointer, si + return + } + ++func CancelMibChangeNotify2(notificationHandle Handle) (errcode error) { ++ r0, _, _ := syscall.Syscall(procCancelMibChangeNotify2.Addr(), 1, uintptr(notificationHandle), 0, 0) ++ if r0 != 0 { ++ errcode = syscall.Errno(r0) ++ } ++ return ++} ++ + func GetAdaptersAddresses(family uint32, flags uint32, reserved uintptr, adapterAddresses *IpAdapterAddresses, sizePointer *uint32) (errcode error) { + r0, _, _ := syscall.Syscall6(procGetAdaptersAddresses.Addr(), 5, uintptr(family), uintptr(flags), uintptr(reserved), uintptr(unsafe.Pointer(adapterAddresses)), uintptr(unsafe.Pointer(sizePointer)), 0) + if r0 != 0 { +@@ -1634,6 +1653,46 @@ func GetIfEntry(pIfRow *MibIfRow) (errcode error) { + return + } + ++func GetIfEntry2Ex(level uint32, row *MibIfRow2) (errcode error) { ++ r0, _, _ := syscall.Syscall(procGetIfEntry2Ex.Addr(), 2, uintptr(level), uintptr(unsafe.Pointer(row)), 0) ++ if r0 != 0 { ++ errcode = syscall.Errno(r0) ++ } ++ return ++} ++ ++func GetUnicastIpAddressEntry(row *MibUnicastIpAddressRow) (errcode error) { ++ r0, _, _ := syscall.Syscall(procGetUnicastIpAddressEntry.Addr(), 1, uintptr(unsafe.Pointer(row)), 0, 0) ++ if r0 != 0 { ++ errcode = syscall.Errno(r0) ++ } ++ return ++} ++ ++func NotifyIpInterfaceChange(family uint16, callback uintptr, callerContext unsafe.Pointer, initialNotification bool, notificationHandle *Handle) (errcode error) { ++ var _p0 uint32 ++ if initialNotification { ++ _p0 = 1 ++ } ++ r0, _, _ := syscall.Syscall6(procNotifyIpInterfaceChange.Addr(), 5, uintptr(family), uintptr(callback), uintptr(callerContext), uintptr(_p0), uintptr(unsafe.Pointer(notificationHandle)), 0) ++ if r0 != 0 { ++ errcode = syscall.Errno(r0) ++ } ++ return ++} ++ ++func NotifyUnicastIpAddressChange(family uint16, callback uintptr, callerContext unsafe.Pointer, initialNotification bool, notificationHandle *Handle) (errcode error) { ++ var _p0 uint32 ++ if initialNotification { ++ _p0 = 1 ++ } ++ r0, _, _ := syscall.Syscall6(procNotifyUnicastIpAddressChange.Addr(), 5, uintptr(family), uintptr(callback), uintptr(callerContext), uintptr(_p0), uintptr(unsafe.Pointer(notificationHandle)), 0) ++ if r0 != 0 { ++ errcode = syscall.Errno(r0) ++ } ++ return ++} ++ + func AddDllDirectory(path *uint16) (cookie uintptr, err error) { + r0, _, e1 := syscall.Syscall(procAddDllDirectory.Addr(), 1, uintptr(unsafe.Pointer(path)), 0, 0) + cookie = uintptr(r0) +@@ -2162,6 +2221,15 @@ func GetComputerName(buf *uint16, n *uint32) (err error) { + return + } + ++func GetConsoleCP() (cp uint32, err error) { ++ r0, _, e1 := syscall.Syscall(procGetConsoleCP.Addr(), 0, 0, 0, 0) ++ cp = uint32(r0) ++ if cp == 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ + func GetConsoleMode(console Handle, mode *uint32) (err error) { + r1, _, e1 := syscall.Syscall(procGetConsoleMode.Addr(), 2, uintptr(console), uintptr(unsafe.Pointer(mode)), 0) + if r1 == 0 { +@@ -2170,6 +2238,15 @@ func GetConsoleMode(console Handle, mode *uint32) (err error) { + return + } + ++func GetConsoleOutputCP() (cp uint32, err error) { ++ r0, _, e1 := syscall.Syscall(procGetConsoleOutputCP.Addr(), 0, 0, 0, 0) ++ cp = uint32(r0) ++ if cp == 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ + func GetConsoleScreenBufferInfo(console Handle, info *ConsoleScreenBufferInfo) (err error) { + r1, _, e1 := syscall.Syscall(procGetConsoleScreenBufferInfo.Addr(), 2, uintptr(console), uintptr(unsafe.Pointer(info)), 0) + if r1 == 0 { +@@ -2371,6 +2448,14 @@ func GetModuleHandleEx(flags uint32, moduleName *uint16, module *Handle) (err er + return + } + ++func GetNamedPipeClientProcessId(pipe Handle, clientProcessID *uint32) (err error) { ++ r1, _, e1 := syscall.Syscall(procGetNamedPipeClientProcessId.Addr(), 2, uintptr(pipe), uintptr(unsafe.Pointer(clientProcessID)), 0) ++ if r1 == 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ + func GetNamedPipeHandleState(pipe Handle, state *uint32, curInstances *uint32, maxCollectionCount *uint32, collectDataTimeout *uint32, userName *uint16, maxUserNameSize uint32) (err error) { + r1, _, e1 := syscall.Syscall9(procGetNamedPipeHandleStateW.Addr(), 7, uintptr(pipe), uintptr(unsafe.Pointer(state)), uintptr(unsafe.Pointer(curInstances)), uintptr(unsafe.Pointer(maxCollectionCount)), uintptr(unsafe.Pointer(collectDataTimeout)), uintptr(unsafe.Pointer(userName)), uintptr(maxUserNameSize), 0, 0) + if r1 == 0 { +@@ -2387,6 +2472,14 @@ func GetNamedPipeInfo(pipe Handle, flags *uint32, outSize *uint32, inSize *uint3 + return + } + ++func GetNamedPipeServerProcessId(pipe Handle, serverProcessID *uint32) (err error) { ++ r1, _, e1 := syscall.Syscall(procGetNamedPipeServerProcessId.Addr(), 2, uintptr(pipe), uintptr(unsafe.Pointer(serverProcessID)), 0) ++ if r1 == 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ + func GetOverlappedResult(handle Handle, overlapped *Overlapped, done *uint32, wait bool) (err error) { + var _p0 uint32 + if wait { +@@ -3038,6 +3131,14 @@ func SetCommTimeouts(handle Handle, timeouts *CommTimeouts) (err error) { + return + } + ++func SetConsoleCP(cp uint32) (err error) { ++ r1, _, e1 := syscall.Syscall(procSetConsoleCP.Addr(), 1, uintptr(cp), 0, 0) ++ if r1 == 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ + func setConsoleCursorPosition(console Handle, position uint32) (err error) { + r1, _, e1 := syscall.Syscall(procSetConsoleCursorPosition.Addr(), 2, uintptr(console), uintptr(position), 0) + if r1 == 0 { +@@ -3054,6 +3155,14 @@ func SetConsoleMode(console Handle, mode uint32) (err error) { + return + } + ++func SetConsoleOutputCP(cp uint32) (err error) { ++ r1, _, e1 := syscall.Syscall(procSetConsoleOutputCP.Addr(), 1, uintptr(cp), 0, 0) ++ if r1 == 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ + func SetCurrentDirectory(path *uint16) (err error) { + r1, _, e1 := syscall.Syscall(procSetCurrentDirectoryW.Addr(), 1, uintptr(unsafe.Pointer(path)), 0, 0) + if r1 == 0 { +diff --git a/vendor/modules.txt b/vendor/modules.txt +index 6b39e77..be1b84e 100644 +--- a/vendor/modules.txt ++++ b/vendor/modules.txt +@@ -152,7 +152,7 @@ go.uber.org/zap/internal/exit + go.uber.org/zap/internal/pool + go.uber.org/zap/internal/stacktrace + go.uber.org/zap/zapcore +-# golang.org/x/net v0.28.0 ++# golang.org/x/net v0.33.0 + ## explicit; go 1.18 + golang.org/x/net/http/httpguts + golang.org/x/net/http2 +@@ -160,11 +160,11 @@ golang.org/x/net/http2/hpack + golang.org/x/net/idna + golang.org/x/net/internal/timeseries + golang.org/x/net/trace +-# golang.org/x/sys v0.23.0 ++# golang.org/x/sys v0.28.0 + ## explicit; go 1.18 + golang.org/x/sys/unix + golang.org/x/sys/windows +-# golang.org/x/text v0.17.0 ++# golang.org/x/text v0.21.0 + ## explicit; go 1.18 + golang.org/x/text/secure/bidirule + golang.org/x/text/transform +-- +2.40.1 + diff --git a/projects/kubernetes-csi/livenessprobe/1-32/patches/0001-Address-CVE-2024-45338.patch b/projects/kubernetes-csi/livenessprobe/1-32/patches/0001-Address-CVE-2024-45338.patch new file mode 100644 index 000000000..d284d9f1d --- /dev/null +++ b/projects/kubernetes-csi/livenessprobe/1-32/patches/0001-Address-CVE-2024-45338.patch @@ -0,0 +1,5325 @@ +From f846b95fea50c3bbb26a8702870a4c2979e671fe Mon Sep 17 00:00:00 2001 +From: torredil +Date: Mon, 23 Dec 2024 18:55:24 +0000 +Subject: [PATCH] Address CVE-2024-45338 + +Signed-off-by: torredil +--- + go.mod | 6 +- + go.sum | 12 +- + .../x/net/http2/client_conn_pool.go | 8 +- + vendor/golang.org/x/net/http2/config.go | 122 +++++ + vendor/golang.org/x/net/http2/config_go124.go | 61 +++ + .../x/net/http2/config_pre_go124.go | 16 + + vendor/golang.org/x/net/http2/frame.go | 4 +- + vendor/golang.org/x/net/http2/http2.go | 95 +++- + vendor/golang.org/x/net/http2/server.go | 244 ++++++--- + vendor/golang.org/x/net/http2/transport.go | 516 ++++++++++++------ + vendor/golang.org/x/net/http2/unencrypted.go | 32 ++ + vendor/golang.org/x/net/http2/write.go | 10 + + vendor/golang.org/x/sys/unix/README.md | 2 +- + vendor/golang.org/x/sys/unix/ioctl_linux.go | 96 ++++ + vendor/golang.org/x/sys/unix/mkerrors.sh | 17 +- + vendor/golang.org/x/sys/unix/syscall_aix.go | 2 +- + .../golang.org/x/sys/unix/syscall_darwin.go | 37 ++ + vendor/golang.org/x/sys/unix/syscall_hurd.go | 1 + + vendor/golang.org/x/sys/unix/syscall_linux.go | 64 ++- + .../x/sys/unix/syscall_linux_arm64.go | 2 + + .../x/sys/unix/syscall_linux_loong64.go | 2 + + .../x/sys/unix/syscall_linux_riscv64.go | 2 + + .../x/sys/unix/syscall_zos_s390x.go | 104 +++- + .../golang.org/x/sys/unix/vgetrandom_linux.go | 13 + + .../x/sys/unix/vgetrandom_unsupported.go | 11 + + .../x/sys/unix/zerrors_darwin_amd64.go | 7 + + .../x/sys/unix/zerrors_darwin_arm64.go | 7 + + vendor/golang.org/x/sys/unix/zerrors_linux.go | 44 +- + .../x/sys/unix/zerrors_linux_386.go | 25 + + .../x/sys/unix/zerrors_linux_amd64.go | 25 + + .../x/sys/unix/zerrors_linux_arm.go | 25 + + .../x/sys/unix/zerrors_linux_arm64.go | 26 + + .../x/sys/unix/zerrors_linux_loong64.go | 25 + + .../x/sys/unix/zerrors_linux_mips.go | 25 + + .../x/sys/unix/zerrors_linux_mips64.go | 25 + + .../x/sys/unix/zerrors_linux_mips64le.go | 25 + + .../x/sys/unix/zerrors_linux_mipsle.go | 25 + + .../x/sys/unix/zerrors_linux_ppc.go | 25 + + .../x/sys/unix/zerrors_linux_ppc64.go | 25 + + .../x/sys/unix/zerrors_linux_ppc64le.go | 25 + + .../x/sys/unix/zerrors_linux_riscv64.go | 25 + + .../x/sys/unix/zerrors_linux_s390x.go | 25 + + .../x/sys/unix/zerrors_linux_sparc64.go | 25 + + .../x/sys/unix/zerrors_zos_s390x.go | 2 + + .../x/sys/unix/zsyscall_darwin_amd64.go | 20 + + .../x/sys/unix/zsyscall_darwin_amd64.s | 5 + + .../x/sys/unix/zsyscall_darwin_arm64.go | 20 + + .../x/sys/unix/zsyscall_darwin_arm64.s | 5 + + .../golang.org/x/sys/unix/zsyscall_linux.go | 27 +- + .../x/sys/unix/zsysnum_linux_amd64.go | 1 + + .../x/sys/unix/zsysnum_linux_arm64.go | 2 +- + .../x/sys/unix/zsysnum_linux_loong64.go | 2 + + .../x/sys/unix/zsysnum_linux_riscv64.go | 2 +- + .../x/sys/unix/ztypes_darwin_amd64.go | 73 +++ + .../x/sys/unix/ztypes_darwin_arm64.go | 73 +++ + .../x/sys/unix/ztypes_freebsd_386.go | 1 + + .../x/sys/unix/ztypes_freebsd_amd64.go | 1 + + .../x/sys/unix/ztypes_freebsd_arm.go | 1 + + .../x/sys/unix/ztypes_freebsd_arm64.go | 1 + + .../x/sys/unix/ztypes_freebsd_riscv64.go | 1 + + vendor/golang.org/x/sys/unix/ztypes_linux.go | 227 ++++++-- + .../x/sys/unix/ztypes_linux_riscv64.go | 33 ++ + .../golang.org/x/sys/unix/ztypes_zos_s390x.go | 6 + + .../golang.org/x/sys/windows/dll_windows.go | 2 +- + .../x/sys/windows/syscall_windows.go | 40 +- + .../golang.org/x/sys/windows/types_windows.go | 172 ++++++ + .../x/sys/windows/zsyscall_windows.go | 109 ++++ + vendor/modules.txt | 6 +- + 68 files changed, 2370 insertions(+), 375 deletions(-) + create mode 100644 vendor/golang.org/x/net/http2/config.go + create mode 100644 vendor/golang.org/x/net/http2/config_go124.go + create mode 100644 vendor/golang.org/x/net/http2/config_pre_go124.go + create mode 100644 vendor/golang.org/x/net/http2/unencrypted.go + create mode 100644 vendor/golang.org/x/sys/unix/vgetrandom_linux.go + create mode 100644 vendor/golang.org/x/sys/unix/vgetrandom_unsupported.go + +diff --git a/go.mod b/go.mod +index 235ec1f..b8ded7e 100644 +--- a/go.mod ++++ b/go.mod +@@ -42,9 +42,9 @@ require ( + go.opentelemetry.io/otel/trace v1.28.0 // indirect + go.uber.org/multierr v1.11.0 // indirect + go.uber.org/zap v1.27.0 // indirect +- golang.org/x/net v0.28.0 // indirect +- golang.org/x/sys v0.23.0 // indirect +- golang.org/x/text v0.17.0 // indirect ++ golang.org/x/net v0.33.0 // indirect ++ golang.org/x/sys v0.28.0 // indirect ++ golang.org/x/text v0.21.0 // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20240701130421-f6361c86f094 // indirect + google.golang.org/grpc v1.65.0 // indirect + google.golang.org/protobuf v1.34.2 // indirect +diff --git a/go.sum b/go.sum +index 4a2470f..db27122 100644 +--- a/go.sum ++++ b/go.sum +@@ -109,8 +109,8 @@ golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLL + golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= + golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= + golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= +-golang.org/x/net v0.28.0 h1:a9JDOJc5GMUJ0+UDqmLT86WiEy7iWyIhz8gz8E4e5hE= +-golang.org/x/net v0.28.0/go.mod h1:yqtgsTWOOnlGLG9GFRrK3++bGOUEkNBoHZc8MEDWPNg= ++golang.org/x/net v0.33.0 h1:74SYHlV8BIgHIFC/LrYkOGIwL19eTYXQ5wc6TBuO36I= ++golang.org/x/net v0.33.0/go.mod h1:HXLR5J+9DxmrqMwG9qjGCxZ+zKXxBru04zlTvWlWuN4= + golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= + golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= + golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +@@ -121,13 +121,13 @@ golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7w + golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= + golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= + golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +-golang.org/x/sys v0.23.0 h1:YfKFowiIMvtgl1UERQoTPPToxltDeZfbj4H7dVUCwmM= +-golang.org/x/sys v0.23.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= ++golang.org/x/sys v0.28.0 h1:Fksou7UEQUWlKvIdsqzJmUmCX3cZuD2+P3XyyzwMhlA= ++golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= + golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= + golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= + golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +-golang.org/x/text v0.17.0 h1:XtiM5bkSOt+ewxlOE/aE/AKEHibwj/6gvWMl9Rsh0Qc= +-golang.org/x/text v0.17.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY= ++golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo= ++golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ= + golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= + golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= + golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +diff --git a/vendor/golang.org/x/net/http2/client_conn_pool.go b/vendor/golang.org/x/net/http2/client_conn_pool.go +index 780968d..e81b73e 100644 +--- a/vendor/golang.org/x/net/http2/client_conn_pool.go ++++ b/vendor/golang.org/x/net/http2/client_conn_pool.go +@@ -8,8 +8,8 @@ package http2 + + import ( + "context" +- "crypto/tls" + "errors" ++ "net" + "net/http" + "sync" + ) +@@ -158,7 +158,7 @@ func (c *dialCall) dial(ctx context.Context, addr string) { + // This code decides which ones live or die. + // The return value used is whether c was used. + // c is never closed. +-func (p *clientConnPool) addConnIfNeeded(key string, t *Transport, c *tls.Conn) (used bool, err error) { ++func (p *clientConnPool) addConnIfNeeded(key string, t *Transport, c net.Conn) (used bool, err error) { + p.mu.Lock() + for _, cc := range p.conns[key] { + if cc.CanTakeNewRequest() { +@@ -194,8 +194,8 @@ type addConnCall struct { + err error + } + +-func (c *addConnCall) run(t *Transport, key string, tc *tls.Conn) { +- cc, err := t.NewClientConn(tc) ++func (c *addConnCall) run(t *Transport, key string, nc net.Conn) { ++ cc, err := t.NewClientConn(nc) + + p := c.p + p.mu.Lock() +diff --git a/vendor/golang.org/x/net/http2/config.go b/vendor/golang.org/x/net/http2/config.go +new file mode 100644 +index 0000000..de58dfb +--- /dev/null ++++ b/vendor/golang.org/x/net/http2/config.go +@@ -0,0 +1,122 @@ ++// Copyright 2024 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 http2 ++ ++import ( ++ "math" ++ "net/http" ++ "time" ++) ++ ++// http2Config is a package-internal version of net/http.HTTP2Config. ++// ++// http.HTTP2Config was added in Go 1.24. ++// When running with a version of net/http that includes HTTP2Config, ++// we merge the configuration with the fields in Transport or Server ++// to produce an http2Config. ++// ++// Zero valued fields in http2Config are interpreted as in the ++// net/http.HTTPConfig documentation. ++// ++// Precedence order for reconciling configurations is: ++// ++// - Use the net/http.{Server,Transport}.HTTP2Config value, when non-zero. ++// - Otherwise use the http2.{Server.Transport} value. ++// - If the resulting value is zero or out of range, use a default. ++type http2Config struct { ++ MaxConcurrentStreams uint32 ++ MaxDecoderHeaderTableSize uint32 ++ MaxEncoderHeaderTableSize uint32 ++ MaxReadFrameSize uint32 ++ MaxUploadBufferPerConnection int32 ++ MaxUploadBufferPerStream int32 ++ SendPingTimeout time.Duration ++ PingTimeout time.Duration ++ WriteByteTimeout time.Duration ++ PermitProhibitedCipherSuites bool ++ CountError func(errType string) ++} ++ ++// configFromServer merges configuration settings from ++// net/http.Server.HTTP2Config and http2.Server. ++func configFromServer(h1 *http.Server, h2 *Server) http2Config { ++ conf := http2Config{ ++ MaxConcurrentStreams: h2.MaxConcurrentStreams, ++ MaxEncoderHeaderTableSize: h2.MaxEncoderHeaderTableSize, ++ MaxDecoderHeaderTableSize: h2.MaxDecoderHeaderTableSize, ++ MaxReadFrameSize: h2.MaxReadFrameSize, ++ MaxUploadBufferPerConnection: h2.MaxUploadBufferPerConnection, ++ MaxUploadBufferPerStream: h2.MaxUploadBufferPerStream, ++ SendPingTimeout: h2.ReadIdleTimeout, ++ PingTimeout: h2.PingTimeout, ++ WriteByteTimeout: h2.WriteByteTimeout, ++ PermitProhibitedCipherSuites: h2.PermitProhibitedCipherSuites, ++ CountError: h2.CountError, ++ } ++ fillNetHTTPServerConfig(&conf, h1) ++ setConfigDefaults(&conf, true) ++ return conf ++} ++ ++// configFromServer merges configuration settings from h2 and h2.t1.HTTP2 ++// (the net/http Transport). ++func configFromTransport(h2 *Transport) http2Config { ++ conf := http2Config{ ++ MaxEncoderHeaderTableSize: h2.MaxEncoderHeaderTableSize, ++ MaxDecoderHeaderTableSize: h2.MaxDecoderHeaderTableSize, ++ MaxReadFrameSize: h2.MaxReadFrameSize, ++ SendPingTimeout: h2.ReadIdleTimeout, ++ PingTimeout: h2.PingTimeout, ++ WriteByteTimeout: h2.WriteByteTimeout, ++ } ++ ++ // Unlike most config fields, where out-of-range values revert to the default, ++ // Transport.MaxReadFrameSize clips. ++ if conf.MaxReadFrameSize < minMaxFrameSize { ++ conf.MaxReadFrameSize = minMaxFrameSize ++ } else if conf.MaxReadFrameSize > maxFrameSize { ++ conf.MaxReadFrameSize = maxFrameSize ++ } ++ ++ if h2.t1 != nil { ++ fillNetHTTPTransportConfig(&conf, h2.t1) ++ } ++ setConfigDefaults(&conf, false) ++ return conf ++} ++ ++func setDefault[T ~int | ~int32 | ~uint32 | ~int64](v *T, minval, maxval, defval T) { ++ if *v < minval || *v > maxval { ++ *v = defval ++ } ++} ++ ++func setConfigDefaults(conf *http2Config, server bool) { ++ setDefault(&conf.MaxConcurrentStreams, 1, math.MaxUint32, defaultMaxStreams) ++ setDefault(&conf.MaxEncoderHeaderTableSize, 1, math.MaxUint32, initialHeaderTableSize) ++ setDefault(&conf.MaxDecoderHeaderTableSize, 1, math.MaxUint32, initialHeaderTableSize) ++ if server { ++ setDefault(&conf.MaxUploadBufferPerConnection, initialWindowSize, math.MaxInt32, 1<<20) ++ } else { ++ setDefault(&conf.MaxUploadBufferPerConnection, initialWindowSize, math.MaxInt32, transportDefaultConnFlow) ++ } ++ if server { ++ setDefault(&conf.MaxUploadBufferPerStream, 1, math.MaxInt32, 1<<20) ++ } else { ++ setDefault(&conf.MaxUploadBufferPerStream, 1, math.MaxInt32, transportDefaultStreamFlow) ++ } ++ setDefault(&conf.MaxReadFrameSize, minMaxFrameSize, maxFrameSize, defaultMaxReadFrameSize) ++ setDefault(&conf.PingTimeout, 1, math.MaxInt64, 15*time.Second) ++} ++ ++// adjustHTTP1MaxHeaderSize converts a limit in bytes on the size of an HTTP/1 header ++// to an HTTP/2 MAX_HEADER_LIST_SIZE value. ++func adjustHTTP1MaxHeaderSize(n int64) int64 { ++ // http2's count is in a slightly different unit and includes 32 bytes per pair. ++ // So, take the net/http.Server value and pad it up a bit, assuming 10 headers. ++ const perFieldOverhead = 32 // per http2 spec ++ const typicalHeaders = 10 // conservative ++ return n + typicalHeaders*perFieldOverhead ++} +diff --git a/vendor/golang.org/x/net/http2/config_go124.go b/vendor/golang.org/x/net/http2/config_go124.go +new file mode 100644 +index 0000000..e378412 +--- /dev/null ++++ b/vendor/golang.org/x/net/http2/config_go124.go +@@ -0,0 +1,61 @@ ++// Copyright 2024 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. ++ ++//go:build go1.24 ++ ++package http2 ++ ++import "net/http" ++ ++// fillNetHTTPServerConfig sets fields in conf from srv.HTTP2. ++func fillNetHTTPServerConfig(conf *http2Config, srv *http.Server) { ++ fillNetHTTPConfig(conf, srv.HTTP2) ++} ++ ++// fillNetHTTPServerConfig sets fields in conf from tr.HTTP2. ++func fillNetHTTPTransportConfig(conf *http2Config, tr *http.Transport) { ++ fillNetHTTPConfig(conf, tr.HTTP2) ++} ++ ++func fillNetHTTPConfig(conf *http2Config, h2 *http.HTTP2Config) { ++ if h2 == nil { ++ return ++ } ++ if h2.MaxConcurrentStreams != 0 { ++ conf.MaxConcurrentStreams = uint32(h2.MaxConcurrentStreams) ++ } ++ if h2.MaxEncoderHeaderTableSize != 0 { ++ conf.MaxEncoderHeaderTableSize = uint32(h2.MaxEncoderHeaderTableSize) ++ } ++ if h2.MaxDecoderHeaderTableSize != 0 { ++ conf.MaxDecoderHeaderTableSize = uint32(h2.MaxDecoderHeaderTableSize) ++ } ++ if h2.MaxConcurrentStreams != 0 { ++ conf.MaxConcurrentStreams = uint32(h2.MaxConcurrentStreams) ++ } ++ if h2.MaxReadFrameSize != 0 { ++ conf.MaxReadFrameSize = uint32(h2.MaxReadFrameSize) ++ } ++ if h2.MaxReceiveBufferPerConnection != 0 { ++ conf.MaxUploadBufferPerConnection = int32(h2.MaxReceiveBufferPerConnection) ++ } ++ if h2.MaxReceiveBufferPerStream != 0 { ++ conf.MaxUploadBufferPerStream = int32(h2.MaxReceiveBufferPerStream) ++ } ++ if h2.SendPingTimeout != 0 { ++ conf.SendPingTimeout = h2.SendPingTimeout ++ } ++ if h2.PingTimeout != 0 { ++ conf.PingTimeout = h2.PingTimeout ++ } ++ if h2.WriteByteTimeout != 0 { ++ conf.WriteByteTimeout = h2.WriteByteTimeout ++ } ++ if h2.PermitProhibitedCipherSuites { ++ conf.PermitProhibitedCipherSuites = true ++ } ++ if h2.CountError != nil { ++ conf.CountError = h2.CountError ++ } ++} +diff --git a/vendor/golang.org/x/net/http2/config_pre_go124.go b/vendor/golang.org/x/net/http2/config_pre_go124.go +new file mode 100644 +index 0000000..060fd6c +--- /dev/null ++++ b/vendor/golang.org/x/net/http2/config_pre_go124.go +@@ -0,0 +1,16 @@ ++// Copyright 2024 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. ++ ++//go:build !go1.24 ++ ++package http2 ++ ++import "net/http" ++ ++// Pre-Go 1.24 fallback. ++// The Server.HTTP2 and Transport.HTTP2 config fields were added in Go 1.24. ++ ++func fillNetHTTPServerConfig(conf *http2Config, srv *http.Server) {} ++ ++func fillNetHTTPTransportConfig(conf *http2Config, tr *http.Transport) {} +diff --git a/vendor/golang.org/x/net/http2/frame.go b/vendor/golang.org/x/net/http2/frame.go +index 105c3b2..81faec7 100644 +--- a/vendor/golang.org/x/net/http2/frame.go ++++ b/vendor/golang.org/x/net/http2/frame.go +@@ -1490,7 +1490,7 @@ func (mh *MetaHeadersFrame) checkPseudos() error { + pf := mh.PseudoFields() + for i, hf := range pf { + switch hf.Name { +- case ":method", ":path", ":scheme", ":authority": ++ case ":method", ":path", ":scheme", ":authority", ":protocol": + isRequest = true + case ":status": + isResponse = true +@@ -1498,7 +1498,7 @@ func (mh *MetaHeadersFrame) checkPseudos() error { + return pseudoHeaderError(hf.Name) + } + // Check for duplicates. +- // This would be a bad algorithm, but N is 4. ++ // This would be a bad algorithm, but N is 5. + // And this doesn't allocate. + for _, hf2 := range pf[:i] { + if hf.Name == hf2.Name { +diff --git a/vendor/golang.org/x/net/http2/http2.go b/vendor/golang.org/x/net/http2/http2.go +index 003e649..c7601c9 100644 +--- a/vendor/golang.org/x/net/http2/http2.go ++++ b/vendor/golang.org/x/net/http2/http2.go +@@ -19,8 +19,9 @@ import ( + "bufio" + "context" + "crypto/tls" ++ "errors" + "fmt" +- "io" ++ "net" + "net/http" + "os" + "sort" +@@ -33,10 +34,11 @@ import ( + ) + + var ( +- VerboseLogs bool +- logFrameWrites bool +- logFrameReads bool +- inTests bool ++ VerboseLogs bool ++ logFrameWrites bool ++ logFrameReads bool ++ inTests bool ++ disableExtendedConnectProtocol bool + ) + + func init() { +@@ -49,6 +51,9 @@ func init() { + logFrameWrites = true + logFrameReads = true + } ++ if strings.Contains(e, "http2xconnect=0") { ++ disableExtendedConnectProtocol = true ++ } + } + + const ( +@@ -140,6 +145,10 @@ func (s Setting) Valid() error { + if s.Val < 16384 || s.Val > 1<<24-1 { + return ConnectionError(ErrCodeProtocol) + } ++ case SettingEnableConnectProtocol: ++ if s.Val != 1 && s.Val != 0 { ++ return ConnectionError(ErrCodeProtocol) ++ } + } + return nil + } +@@ -149,21 +158,23 @@ func (s Setting) Valid() error { + type SettingID uint16 + + const ( +- SettingHeaderTableSize SettingID = 0x1 +- SettingEnablePush SettingID = 0x2 +- SettingMaxConcurrentStreams SettingID = 0x3 +- SettingInitialWindowSize SettingID = 0x4 +- SettingMaxFrameSize SettingID = 0x5 +- SettingMaxHeaderListSize SettingID = 0x6 ++ SettingHeaderTableSize SettingID = 0x1 ++ SettingEnablePush SettingID = 0x2 ++ SettingMaxConcurrentStreams SettingID = 0x3 ++ SettingInitialWindowSize SettingID = 0x4 ++ SettingMaxFrameSize SettingID = 0x5 ++ SettingMaxHeaderListSize SettingID = 0x6 ++ SettingEnableConnectProtocol SettingID = 0x8 + ) + + var settingName = map[SettingID]string{ +- SettingHeaderTableSize: "HEADER_TABLE_SIZE", +- SettingEnablePush: "ENABLE_PUSH", +- SettingMaxConcurrentStreams: "MAX_CONCURRENT_STREAMS", +- SettingInitialWindowSize: "INITIAL_WINDOW_SIZE", +- SettingMaxFrameSize: "MAX_FRAME_SIZE", +- SettingMaxHeaderListSize: "MAX_HEADER_LIST_SIZE", ++ SettingHeaderTableSize: "HEADER_TABLE_SIZE", ++ SettingEnablePush: "ENABLE_PUSH", ++ SettingMaxConcurrentStreams: "MAX_CONCURRENT_STREAMS", ++ SettingInitialWindowSize: "INITIAL_WINDOW_SIZE", ++ SettingMaxFrameSize: "MAX_FRAME_SIZE", ++ SettingMaxHeaderListSize: "MAX_HEADER_LIST_SIZE", ++ SettingEnableConnectProtocol: "ENABLE_CONNECT_PROTOCOL", + } + + func (s SettingID) String() string { +@@ -237,13 +248,19 @@ func (cw closeWaiter) Wait() { + // Its buffered writer is lazily allocated as needed, to minimize + // idle memory usage with many connections. + type bufferedWriter struct { +- _ incomparable +- w io.Writer // immutable +- bw *bufio.Writer // non-nil when data is buffered ++ _ incomparable ++ group synctestGroupInterface // immutable ++ conn net.Conn // immutable ++ bw *bufio.Writer // non-nil when data is buffered ++ byteTimeout time.Duration // immutable, WriteByteTimeout + } + +-func newBufferedWriter(w io.Writer) *bufferedWriter { +- return &bufferedWriter{w: w} ++func newBufferedWriter(group synctestGroupInterface, conn net.Conn, timeout time.Duration) *bufferedWriter { ++ return &bufferedWriter{ ++ group: group, ++ conn: conn, ++ byteTimeout: timeout, ++ } + } + + // bufWriterPoolBufferSize is the size of bufio.Writer's +@@ -270,7 +287,7 @@ func (w *bufferedWriter) Available() int { + func (w *bufferedWriter) Write(p []byte) (n int, err error) { + if w.bw == nil { + bw := bufWriterPool.Get().(*bufio.Writer) +- bw.Reset(w.w) ++ bw.Reset((*bufferedWriterTimeoutWriter)(w)) + w.bw = bw + } + return w.bw.Write(p) +@@ -288,6 +305,38 @@ func (w *bufferedWriter) Flush() error { + return err + } + ++type bufferedWriterTimeoutWriter bufferedWriter ++ ++func (w *bufferedWriterTimeoutWriter) Write(p []byte) (n int, err error) { ++ return writeWithByteTimeout(w.group, w.conn, w.byteTimeout, p) ++} ++ ++// writeWithByteTimeout writes to conn. ++// If more than timeout passes without any bytes being written to the connection, ++// the write fails. ++func writeWithByteTimeout(group synctestGroupInterface, conn net.Conn, timeout time.Duration, p []byte) (n int, err error) { ++ if timeout <= 0 { ++ return conn.Write(p) ++ } ++ for { ++ var now time.Time ++ if group == nil { ++ now = time.Now() ++ } else { ++ now = group.Now() ++ } ++ conn.SetWriteDeadline(now.Add(timeout)) ++ nn, err := conn.Write(p[n:]) ++ n += nn ++ if n == len(p) || nn == 0 || !errors.Is(err, os.ErrDeadlineExceeded) { ++ // Either we finished the write, made no progress, or hit the deadline. ++ // Whichever it is, we're done now. ++ conn.SetWriteDeadline(time.Time{}) ++ return n, err ++ } ++ } ++} ++ + func mustUint31(v int32) uint32 { + if v < 0 || v > 2147483647 { + panic("out of range") +diff --git a/vendor/golang.org/x/net/http2/server.go b/vendor/golang.org/x/net/http2/server.go +index 6c349f3..b55547a 100644 +--- a/vendor/golang.org/x/net/http2/server.go ++++ b/vendor/golang.org/x/net/http2/server.go +@@ -29,6 +29,7 @@ import ( + "bufio" + "bytes" + "context" ++ "crypto/rand" + "crypto/tls" + "errors" + "fmt" +@@ -52,10 +53,14 @@ import ( + ) + + const ( +- prefaceTimeout = 10 * time.Second +- firstSettingsTimeout = 2 * time.Second // should be in-flight with preface anyway +- handlerChunkWriteSize = 4 << 10 +- defaultMaxStreams = 250 // TODO: make this 100 as the GFE seems to? ++ prefaceTimeout = 10 * time.Second ++ firstSettingsTimeout = 2 * time.Second // should be in-flight with preface anyway ++ handlerChunkWriteSize = 4 << 10 ++ defaultMaxStreams = 250 // TODO: make this 100 as the GFE seems to? ++ ++ // maxQueuedControlFrames is the maximum number of control frames like ++ // SETTINGS, PING and RST_STREAM that will be queued for writing before ++ // the connection is closed to prevent memory exhaustion attacks. + maxQueuedControlFrames = 10000 + ) + +@@ -127,6 +132,22 @@ type Server struct { + // If zero or negative, there is no timeout. + IdleTimeout time.Duration + ++ // ReadIdleTimeout is the timeout after which a health check using a ping ++ // frame will be carried out if no frame is received on the connection. ++ // If zero, no health check is performed. ++ ReadIdleTimeout time.Duration ++ ++ // PingTimeout is the timeout after which the connection will be closed ++ // if a response to a ping is not received. ++ // If zero, a default of 15 seconds is used. ++ PingTimeout time.Duration ++ ++ // WriteByteTimeout is the timeout after which a connection will be ++ // closed if no data can be written to it. The timeout begins when data is ++ // available to write, and is extended whenever any bytes are written. ++ // If zero or negative, there is no timeout. ++ WriteByteTimeout time.Duration ++ + // MaxUploadBufferPerConnection is the size of the initial flow + // control window for each connections. The HTTP/2 spec does not + // allow this to be smaller than 65535 or larger than 2^32-1. +@@ -189,57 +210,6 @@ func (s *Server) afterFunc(d time.Duration, f func()) timer { + return timeTimer{time.AfterFunc(d, f)} + } + +-func (s *Server) initialConnRecvWindowSize() int32 { +- if s.MaxUploadBufferPerConnection >= initialWindowSize { +- return s.MaxUploadBufferPerConnection +- } +- return 1 << 20 +-} +- +-func (s *Server) initialStreamRecvWindowSize() int32 { +- if s.MaxUploadBufferPerStream > 0 { +- return s.MaxUploadBufferPerStream +- } +- return 1 << 20 +-} +- +-func (s *Server) maxReadFrameSize() uint32 { +- if v := s.MaxReadFrameSize; v >= minMaxFrameSize && v <= maxFrameSize { +- return v +- } +- return defaultMaxReadFrameSize +-} +- +-func (s *Server) maxConcurrentStreams() uint32 { +- if v := s.MaxConcurrentStreams; v > 0 { +- return v +- } +- return defaultMaxStreams +-} +- +-func (s *Server) maxDecoderHeaderTableSize() uint32 { +- if v := s.MaxDecoderHeaderTableSize; v > 0 { +- return v +- } +- return initialHeaderTableSize +-} +- +-func (s *Server) maxEncoderHeaderTableSize() uint32 { +- if v := s.MaxEncoderHeaderTableSize; v > 0 { +- return v +- } +- return initialHeaderTableSize +-} +- +-// maxQueuedControlFrames is the maximum number of control frames like +-// SETTINGS, PING and RST_STREAM that will be queued for writing before +-// the connection is closed to prevent memory exhaustion attacks. +-func (s *Server) maxQueuedControlFrames() int { +- // TODO: if anybody asks, add a Server field, and remember to define the +- // behavior of negative values. +- return maxQueuedControlFrames +-} +- + type serverInternalState struct { + mu sync.Mutex + activeConns map[*serverConn]struct{} +@@ -336,7 +306,7 @@ func ConfigureServer(s *http.Server, conf *Server) error { + if s.TLSNextProto == nil { + s.TLSNextProto = map[string]func(*http.Server, *tls.Conn, http.Handler){} + } +- protoHandler := func(hs *http.Server, c *tls.Conn, h http.Handler) { ++ protoHandler := func(hs *http.Server, c net.Conn, h http.Handler, sawClientPreface bool) { + if testHookOnConn != nil { + testHookOnConn() + } +@@ -353,12 +323,31 @@ func ConfigureServer(s *http.Server, conf *Server) error { + ctx = bc.BaseContext() + } + conf.ServeConn(c, &ServeConnOpts{ +- Context: ctx, +- Handler: h, +- BaseConfig: hs, ++ Context: ctx, ++ Handler: h, ++ BaseConfig: hs, ++ SawClientPreface: sawClientPreface, + }) + } +- s.TLSNextProto[NextProtoTLS] = protoHandler ++ s.TLSNextProto[NextProtoTLS] = func(hs *http.Server, c *tls.Conn, h http.Handler) { ++ protoHandler(hs, c, h, false) ++ } ++ // The "unencrypted_http2" TLSNextProto key is used to pass off non-TLS HTTP/2 conns. ++ // ++ // A connection passed in this method has already had the HTTP/2 preface read from it. ++ s.TLSNextProto[nextProtoUnencryptedHTTP2] = func(hs *http.Server, c *tls.Conn, h http.Handler) { ++ nc, err := unencryptedNetConnFromTLSConn(c) ++ if err != nil { ++ if lg := hs.ErrorLog; lg != nil { ++ lg.Print(err) ++ } else { ++ log.Print(err) ++ } ++ go c.Close() ++ return ++ } ++ protoHandler(hs, nc, h, true) ++ } + return nil + } + +@@ -440,13 +429,15 @@ func (s *Server) serveConn(c net.Conn, opts *ServeConnOpts, newf func(*serverCon + baseCtx, cancel := serverConnBaseContext(c, opts) + defer cancel() + ++ http1srv := opts.baseConfig() ++ conf := configFromServer(http1srv, s) + sc := &serverConn{ + srv: s, +- hs: opts.baseConfig(), ++ hs: http1srv, + conn: c, + baseCtx: baseCtx, + remoteAddrStr: c.RemoteAddr().String(), +- bw: newBufferedWriter(c), ++ bw: newBufferedWriter(s.group, c, conf.WriteByteTimeout), + handler: opts.handler(), + streams: make(map[uint32]*stream), + readFrameCh: make(chan readFrameResult), +@@ -456,9 +447,12 @@ func (s *Server) serveConn(c net.Conn, opts *ServeConnOpts, newf func(*serverCon + bodyReadCh: make(chan bodyReadMsg), // buffering doesn't matter either way + doneServing: make(chan struct{}), + clientMaxStreams: math.MaxUint32, // Section 6.5.2: "Initially, there is no limit to this value" +- advMaxStreams: s.maxConcurrentStreams(), ++ advMaxStreams: conf.MaxConcurrentStreams, + initialStreamSendWindowSize: initialWindowSize, ++ initialStreamRecvWindowSize: conf.MaxUploadBufferPerStream, + maxFrameSize: initialMaxFrameSize, ++ pingTimeout: conf.PingTimeout, ++ countErrorFunc: conf.CountError, + serveG: newGoroutineLock(), + pushEnabled: true, + sawClientPreface: opts.SawClientPreface, +@@ -491,15 +485,15 @@ func (s *Server) serveConn(c net.Conn, opts *ServeConnOpts, newf func(*serverCon + sc.flow.add(initialWindowSize) + sc.inflow.init(initialWindowSize) + sc.hpackEncoder = hpack.NewEncoder(&sc.headerWriteBuf) +- sc.hpackEncoder.SetMaxDynamicTableSizeLimit(s.maxEncoderHeaderTableSize()) ++ sc.hpackEncoder.SetMaxDynamicTableSizeLimit(conf.MaxEncoderHeaderTableSize) + + fr := NewFramer(sc.bw, c) +- if s.CountError != nil { +- fr.countError = s.CountError ++ if conf.CountError != nil { ++ fr.countError = conf.CountError + } +- fr.ReadMetaHeaders = hpack.NewDecoder(s.maxDecoderHeaderTableSize(), nil) ++ fr.ReadMetaHeaders = hpack.NewDecoder(conf.MaxDecoderHeaderTableSize, nil) + fr.MaxHeaderListSize = sc.maxHeaderListSize() +- fr.SetMaxReadFrameSize(s.maxReadFrameSize()) ++ fr.SetMaxReadFrameSize(conf.MaxReadFrameSize) + sc.framer = fr + + if tc, ok := c.(connectionStater); ok { +@@ -532,7 +526,7 @@ func (s *Server) serveConn(c net.Conn, opts *ServeConnOpts, newf func(*serverCon + // So for now, do nothing here again. + } + +- if !s.PermitProhibitedCipherSuites && isBadCipher(sc.tlsState.CipherSuite) { ++ if !conf.PermitProhibitedCipherSuites && isBadCipher(sc.tlsState.CipherSuite) { + // "Endpoints MAY choose to generate a connection error + // (Section 5.4.1) of type INADEQUATE_SECURITY if one of + // the prohibited cipher suites are negotiated." +@@ -569,7 +563,7 @@ func (s *Server) serveConn(c net.Conn, opts *ServeConnOpts, newf func(*serverCon + opts.UpgradeRequest = nil + } + +- sc.serve() ++ sc.serve(conf) + } + + func serverConnBaseContext(c net.Conn, opts *ServeConnOpts) (ctx context.Context, cancel func()) { +@@ -609,6 +603,7 @@ type serverConn struct { + tlsState *tls.ConnectionState // shared by all handlers, like net/http + remoteAddrStr string + writeSched WriteScheduler ++ countErrorFunc func(errType string) + + // Everything following is owned by the serve loop; use serveG.check(): + serveG goroutineLock // used to verify funcs are on serve() +@@ -628,6 +623,7 @@ type serverConn struct { + streams map[uint32]*stream + unstartedHandlers []unstartedHandler + initialStreamSendWindowSize int32 ++ initialStreamRecvWindowSize int32 + maxFrameSize int32 + peerMaxHeaderListSize uint32 // zero means unknown (default) + canonHeader map[string]string // http2-lower-case -> Go-Canonical-Case +@@ -638,9 +634,14 @@ type serverConn struct { + inGoAway bool // we've started to or sent GOAWAY + inFrameScheduleLoop bool // whether we're in the scheduleFrameWrite loop + needToSendGoAway bool // we need to schedule a GOAWAY frame write ++ pingSent bool ++ sentPingData [8]byte + goAwayCode ErrCode + shutdownTimer timer // nil until used + idleTimer timer // nil if unused ++ readIdleTimeout time.Duration ++ pingTimeout time.Duration ++ readIdleTimer timer // nil if unused + + // Owned by the writeFrameAsync goroutine: + headerWriteBuf bytes.Buffer +@@ -655,11 +656,7 @@ func (sc *serverConn) maxHeaderListSize() uint32 { + if n <= 0 { + n = http.DefaultMaxHeaderBytes + } +- // http2's count is in a slightly different unit and includes 32 bytes per pair. +- // So, take the net/http.Server value and pad it up a bit, assuming 10 headers. +- const perFieldOverhead = 32 // per http2 spec +- const typicalHeaders = 10 // conservative +- return uint32(n + typicalHeaders*perFieldOverhead) ++ return uint32(adjustHTTP1MaxHeaderSize(int64(n))) + } + + func (sc *serverConn) curOpenStreams() uint32 { +@@ -923,7 +920,7 @@ func (sc *serverConn) notePanic() { + } + } + +-func (sc *serverConn) serve() { ++func (sc *serverConn) serve(conf http2Config) { + sc.serveG.check() + defer sc.notePanic() + defer sc.conn.Close() +@@ -935,20 +932,24 @@ func (sc *serverConn) serve() { + sc.vlogf("http2: server connection from %v on %p", sc.conn.RemoteAddr(), sc.hs) + } + ++ settings := writeSettings{ ++ {SettingMaxFrameSize, conf.MaxReadFrameSize}, ++ {SettingMaxConcurrentStreams, sc.advMaxStreams}, ++ {SettingMaxHeaderListSize, sc.maxHeaderListSize()}, ++ {SettingHeaderTableSize, conf.MaxDecoderHeaderTableSize}, ++ {SettingInitialWindowSize, uint32(sc.initialStreamRecvWindowSize)}, ++ } ++ if !disableExtendedConnectProtocol { ++ settings = append(settings, Setting{SettingEnableConnectProtocol, 1}) ++ } + sc.writeFrame(FrameWriteRequest{ +- write: writeSettings{ +- {SettingMaxFrameSize, sc.srv.maxReadFrameSize()}, +- {SettingMaxConcurrentStreams, sc.advMaxStreams}, +- {SettingMaxHeaderListSize, sc.maxHeaderListSize()}, +- {SettingHeaderTableSize, sc.srv.maxDecoderHeaderTableSize()}, +- {SettingInitialWindowSize, uint32(sc.srv.initialStreamRecvWindowSize())}, +- }, ++ write: settings, + }) + sc.unackedSettings++ + + // Each connection starts with initialWindowSize inflow tokens. + // If a higher value is configured, we add more tokens. +- if diff := sc.srv.initialConnRecvWindowSize() - initialWindowSize; diff > 0 { ++ if diff := conf.MaxUploadBufferPerConnection - initialWindowSize; diff > 0 { + sc.sendWindowUpdate(nil, int(diff)) + } + +@@ -968,11 +969,18 @@ func (sc *serverConn) serve() { + defer sc.idleTimer.Stop() + } + ++ if conf.SendPingTimeout > 0 { ++ sc.readIdleTimeout = conf.SendPingTimeout ++ sc.readIdleTimer = sc.srv.afterFunc(conf.SendPingTimeout, sc.onReadIdleTimer) ++ defer sc.readIdleTimer.Stop() ++ } ++ + go sc.readFrames() // closed by defer sc.conn.Close above + + settingsTimer := sc.srv.afterFunc(firstSettingsTimeout, sc.onSettingsTimer) + defer settingsTimer.Stop() + ++ lastFrameTime := sc.srv.now() + loopNum := 0 + for { + loopNum++ +@@ -986,6 +994,7 @@ func (sc *serverConn) serve() { + case res := <-sc.wroteFrameCh: + sc.wroteFrame(res) + case res := <-sc.readFrameCh: ++ lastFrameTime = sc.srv.now() + // Process any written frames before reading new frames from the client since a + // written frame could have triggered a new stream to be started. + if sc.writingFrameAsync { +@@ -1017,6 +1026,8 @@ func (sc *serverConn) serve() { + case idleTimerMsg: + sc.vlogf("connection is idle") + sc.goAway(ErrCodeNo) ++ case readIdleTimerMsg: ++ sc.handlePingTimer(lastFrameTime) + case shutdownTimerMsg: + sc.vlogf("GOAWAY close timer fired; closing conn from %v", sc.conn.RemoteAddr()) + return +@@ -1039,7 +1050,7 @@ func (sc *serverConn) serve() { + // If the peer is causing us to generate a lot of control frames, + // but not reading them from us, assume they are trying to make us + // run out of memory. +- if sc.queuedControlFrames > sc.srv.maxQueuedControlFrames() { ++ if sc.queuedControlFrames > maxQueuedControlFrames { + sc.vlogf("http2: too many control frames in send queue, closing connection") + return + } +@@ -1055,12 +1066,39 @@ func (sc *serverConn) serve() { + } + } + ++func (sc *serverConn) handlePingTimer(lastFrameReadTime time.Time) { ++ if sc.pingSent { ++ sc.vlogf("timeout waiting for PING response") ++ sc.conn.Close() ++ return ++ } ++ ++ pingAt := lastFrameReadTime.Add(sc.readIdleTimeout) ++ now := sc.srv.now() ++ if pingAt.After(now) { ++ // We received frames since arming the ping timer. ++ // Reset it for the next possible timeout. ++ sc.readIdleTimer.Reset(pingAt.Sub(now)) ++ return ++ } ++ ++ sc.pingSent = true ++ // Ignore crypto/rand.Read errors: It generally can't fail, and worse case if it does ++ // is we send a PING frame containing 0s. ++ _, _ = rand.Read(sc.sentPingData[:]) ++ sc.writeFrame(FrameWriteRequest{ ++ write: &writePing{data: sc.sentPingData}, ++ }) ++ sc.readIdleTimer.Reset(sc.pingTimeout) ++} ++ + type serverMessage int + + // Message values sent to serveMsgCh. + var ( + settingsTimerMsg = new(serverMessage) + idleTimerMsg = new(serverMessage) ++ readIdleTimerMsg = new(serverMessage) + shutdownTimerMsg = new(serverMessage) + gracefulShutdownMsg = new(serverMessage) + handlerDoneMsg = new(serverMessage) +@@ -1068,6 +1106,7 @@ var ( + + func (sc *serverConn) onSettingsTimer() { sc.sendServeMsg(settingsTimerMsg) } + func (sc *serverConn) onIdleTimer() { sc.sendServeMsg(idleTimerMsg) } ++func (sc *serverConn) onReadIdleTimer() { sc.sendServeMsg(readIdleTimerMsg) } + func (sc *serverConn) onShutdownTimer() { sc.sendServeMsg(shutdownTimerMsg) } + + func (sc *serverConn) sendServeMsg(msg interface{}) { +@@ -1320,6 +1359,10 @@ func (sc *serverConn) wroteFrame(res frameWriteResult) { + sc.writingFrame = false + sc.writingFrameAsync = false + ++ if res.err != nil { ++ sc.conn.Close() ++ } ++ + wr := res.wr + + if writeEndsStream(wr.write) { +@@ -1594,6 +1637,11 @@ func (sc *serverConn) processFrame(f Frame) error { + func (sc *serverConn) processPing(f *PingFrame) error { + sc.serveG.check() + if f.IsAck() { ++ if sc.pingSent && sc.sentPingData == f.Data { ++ // This is a response to a PING we sent. ++ sc.pingSent = false ++ sc.readIdleTimer.Reset(sc.readIdleTimeout) ++ } + // 6.7 PING: " An endpoint MUST NOT respond to PING frames + // containing this flag." + return nil +@@ -1757,6 +1805,9 @@ func (sc *serverConn) processSetting(s Setting) error { + sc.maxFrameSize = int32(s.Val) // the maximum valid s.Val is < 2^31 + case SettingMaxHeaderListSize: + sc.peerMaxHeaderListSize = s.Val ++ case SettingEnableConnectProtocol: ++ // Receipt of this parameter by a server does not ++ // have any impact + default: + // Unknown setting: "An endpoint that receives a SETTINGS + // frame with any unknown or unsupported identifier MUST +@@ -2160,7 +2211,7 @@ func (sc *serverConn) newStream(id, pusherID uint32, state streamState) *stream + st.cw.Init() + st.flow.conn = &sc.flow // link to conn-level counter + st.flow.add(sc.initialStreamSendWindowSize) +- st.inflow.init(sc.srv.initialStreamRecvWindowSize()) ++ st.inflow.init(sc.initialStreamRecvWindowSize) + if sc.hs.WriteTimeout > 0 { + st.writeDeadline = sc.srv.afterFunc(sc.hs.WriteTimeout, st.onWriteTimeout) + } +@@ -2187,11 +2238,17 @@ func (sc *serverConn) newWriterAndRequest(st *stream, f *MetaHeadersFrame) (*res + scheme: f.PseudoValue("scheme"), + authority: f.PseudoValue("authority"), + path: f.PseudoValue("path"), ++ protocol: f.PseudoValue("protocol"), ++ } ++ ++ // extended connect is disabled, so we should not see :protocol ++ if disableExtendedConnectProtocol && rp.protocol != "" { ++ return nil, nil, sc.countError("bad_connect", streamError(f.StreamID, ErrCodeProtocol)) + } + + isConnect := rp.method == "CONNECT" + if isConnect { +- if rp.path != "" || rp.scheme != "" || rp.authority == "" { ++ if rp.protocol == "" && (rp.path != "" || rp.scheme != "" || rp.authority == "") { + return nil, nil, sc.countError("bad_connect", streamError(f.StreamID, ErrCodeProtocol)) + } + } else if rp.method == "" || rp.path == "" || (rp.scheme != "https" && rp.scheme != "http") { +@@ -2215,6 +2272,9 @@ func (sc *serverConn) newWriterAndRequest(st *stream, f *MetaHeadersFrame) (*res + if rp.authority == "" { + rp.authority = rp.header.Get("Host") + } ++ if rp.protocol != "" { ++ rp.header.Set(":protocol", rp.protocol) ++ } + + rw, req, err := sc.newWriterAndRequestNoBody(st, rp) + if err != nil { +@@ -2241,6 +2301,7 @@ func (sc *serverConn) newWriterAndRequest(st *stream, f *MetaHeadersFrame) (*res + type requestParam struct { + method string + scheme, authority, path string ++ protocol string + header http.Header + } + +@@ -2282,7 +2343,7 @@ func (sc *serverConn) newWriterAndRequestNoBody(st *stream, rp requestParam) (*r + + var url_ *url.URL + var requestURI string +- if rp.method == "CONNECT" { ++ if rp.method == "CONNECT" && rp.protocol == "" { + url_ = &url.URL{Host: rp.authority} + requestURI = rp.authority // mimic HTTP/1 server behavior + } else { +@@ -2855,6 +2916,11 @@ func (w *responseWriter) SetWriteDeadline(deadline time.Time) error { + return nil + } + ++func (w *responseWriter) EnableFullDuplex() error { ++ // We always support full duplex responses, so this is a no-op. ++ return nil ++} ++ + func (w *responseWriter) Flush() { + w.FlushError() + } +@@ -3301,7 +3367,7 @@ func (sc *serverConn) countError(name string, err error) error { + if sc == nil || sc.srv == nil { + return err + } +- f := sc.srv.CountError ++ f := sc.countErrorFunc + if f == nil { + return err + } +diff --git a/vendor/golang.org/x/net/http2/transport.go b/vendor/golang.org/x/net/http2/transport.go +index 61f511f..090d0e1 100644 +--- a/vendor/golang.org/x/net/http2/transport.go ++++ b/vendor/golang.org/x/net/http2/transport.go +@@ -25,7 +25,6 @@ import ( + "net/http" + "net/http/httptrace" + "net/textproto" +- "os" + "sort" + "strconv" + "strings" +@@ -203,6 +202,20 @@ func (t *Transport) markNewGoroutine() { + } + } + ++func (t *Transport) now() time.Time { ++ if t != nil && t.transportTestHooks != nil { ++ return t.transportTestHooks.group.Now() ++ } ++ return time.Now() ++} ++ ++func (t *Transport) timeSince(when time.Time) time.Duration { ++ if t != nil && t.transportTestHooks != nil { ++ return t.now().Sub(when) ++ } ++ return time.Since(when) ++} ++ + // newTimer creates a new time.Timer, or a synthetic timer in tests. + func (t *Transport) newTimer(d time.Duration) timer { + if t.transportTestHooks != nil { +@@ -227,40 +240,26 @@ func (t *Transport) contextWithTimeout(ctx context.Context, d time.Duration) (co + } + + func (t *Transport) maxHeaderListSize() uint32 { +- if t.MaxHeaderListSize == 0 { ++ n := int64(t.MaxHeaderListSize) ++ if t.t1 != nil && t.t1.MaxResponseHeaderBytes != 0 { ++ n = t.t1.MaxResponseHeaderBytes ++ if n > 0 { ++ n = adjustHTTP1MaxHeaderSize(n) ++ } ++ } ++ if n <= 0 { + return 10 << 20 + } +- if t.MaxHeaderListSize == 0xffffffff { ++ if n >= 0xffffffff { + return 0 + } +- return t.MaxHeaderListSize +-} +- +-func (t *Transport) maxFrameReadSize() uint32 { +- if t.MaxReadFrameSize == 0 { +- return 0 // use the default provided by the peer +- } +- if t.MaxReadFrameSize < minMaxFrameSize { +- return minMaxFrameSize +- } +- if t.MaxReadFrameSize > maxFrameSize { +- return maxFrameSize +- } +- return t.MaxReadFrameSize ++ return uint32(n) + } + + func (t *Transport) disableCompression() bool { + return t.DisableCompression || (t.t1 != nil && t.t1.DisableCompression) + } + +-func (t *Transport) pingTimeout() time.Duration { +- if t.PingTimeout == 0 { +- return 15 * time.Second +- } +- return t.PingTimeout +- +-} +- + // ConfigureTransport configures a net/http HTTP/1 Transport to use HTTP/2. + // It returns an error if t1 has already been HTTP/2-enabled. + // +@@ -296,8 +295,8 @@ func configureTransports(t1 *http.Transport) (*Transport, error) { + if !strSliceContains(t1.TLSClientConfig.NextProtos, "http/1.1") { + t1.TLSClientConfig.NextProtos = append(t1.TLSClientConfig.NextProtos, "http/1.1") + } +- upgradeFn := func(authority string, c *tls.Conn) http.RoundTripper { +- addr := authorityAddr("https", authority) ++ upgradeFn := func(scheme, authority string, c net.Conn) http.RoundTripper { ++ addr := authorityAddr(scheme, authority) + if used, err := connPool.addConnIfNeeded(addr, t2, c); err != nil { + go c.Close() + return erringRoundTripper{err} +@@ -308,18 +307,37 @@ func configureTransports(t1 *http.Transport) (*Transport, error) { + // was unknown) + go c.Close() + } ++ if scheme == "http" { ++ return (*unencryptedTransport)(t2) ++ } + return t2 + } +- if m := t1.TLSNextProto; len(m) == 0 { +- t1.TLSNextProto = map[string]func(string, *tls.Conn) http.RoundTripper{ +- "h2": upgradeFn, ++ if t1.TLSNextProto == nil { ++ t1.TLSNextProto = make(map[string]func(string, *tls.Conn) http.RoundTripper) ++ } ++ t1.TLSNextProto[NextProtoTLS] = func(authority string, c *tls.Conn) http.RoundTripper { ++ return upgradeFn("https", authority, c) ++ } ++ // The "unencrypted_http2" TLSNextProto key is used to pass off non-TLS HTTP/2 conns. ++ t1.TLSNextProto[nextProtoUnencryptedHTTP2] = func(authority string, c *tls.Conn) http.RoundTripper { ++ nc, err := unencryptedNetConnFromTLSConn(c) ++ if err != nil { ++ go c.Close() ++ return erringRoundTripper{err} + } +- } else { +- m["h2"] = upgradeFn ++ return upgradeFn("http", authority, nc) + } + return t2, nil + } + ++// unencryptedTransport is a Transport with a RoundTrip method that ++// always permits http:// URLs. ++type unencryptedTransport Transport ++ ++func (t *unencryptedTransport) RoundTrip(req *http.Request) (*http.Response, error) { ++ return (*Transport)(t).RoundTripOpt(req, RoundTripOpt{allowHTTP: true}) ++} ++ + func (t *Transport) connPool() ClientConnPool { + t.connPoolOnce.Do(t.initConnPool) + return t.connPoolOrDef +@@ -339,7 +357,7 @@ type ClientConn struct { + t *Transport + tconn net.Conn // usually *tls.Conn, except specialized impls + tlsState *tls.ConnectionState // nil only for specialized impls +- reused uint32 // whether conn is being reused; atomic ++ atomicReused uint32 // whether conn is being reused; atomic + singleUse bool // whether being used for a single http.Request + getConnCalled bool // used by clientConnPool + +@@ -350,31 +368,54 @@ type ClientConn struct { + idleTimeout time.Duration // or 0 for never + idleTimer timer + +- mu sync.Mutex // guards following +- cond *sync.Cond // hold mu; broadcast on flow/closed changes +- flow outflow // our conn-level flow control quota (cs.outflow is per stream) +- inflow inflow // peer's conn-level flow control +- doNotReuse bool // whether conn is marked to not be reused for any future requests +- closing bool +- closed bool +- seenSettings bool // true if we've seen a settings frame, false otherwise +- wantSettingsAck bool // we sent a SETTINGS frame and haven't heard back +- goAway *GoAwayFrame // if non-nil, the GoAwayFrame we received +- goAwayDebug string // goAway frame's debug data, retained as a string +- streams map[uint32]*clientStream // client-initiated +- streamsReserved int // incr by ReserveNewRequest; decr on RoundTrip +- nextStreamID uint32 +- pendingRequests int // requests blocked and waiting to be sent because len(streams) == maxConcurrentStreams +- pings map[[8]byte]chan struct{} // in flight ping data to notification channel +- br *bufio.Reader +- lastActive time.Time +- lastIdle time.Time // time last idle ++ mu sync.Mutex // guards following ++ cond *sync.Cond // hold mu; broadcast on flow/closed changes ++ flow outflow // our conn-level flow control quota (cs.outflow is per stream) ++ inflow inflow // peer's conn-level flow control ++ doNotReuse bool // whether conn is marked to not be reused for any future requests ++ closing bool ++ closed bool ++ seenSettings bool // true if we've seen a settings frame, false otherwise ++ seenSettingsChan chan struct{} // closed when seenSettings is true or frame reading fails ++ wantSettingsAck bool // we sent a SETTINGS frame and haven't heard back ++ goAway *GoAwayFrame // if non-nil, the GoAwayFrame we received ++ goAwayDebug string // goAway frame's debug data, retained as a string ++ streams map[uint32]*clientStream // client-initiated ++ streamsReserved int // incr by ReserveNewRequest; decr on RoundTrip ++ nextStreamID uint32 ++ pendingRequests int // requests blocked and waiting to be sent because len(streams) == maxConcurrentStreams ++ pings map[[8]byte]chan struct{} // in flight ping data to notification channel ++ br *bufio.Reader ++ lastActive time.Time ++ lastIdle time.Time // time last idle + // Settings from peer: (also guarded by wmu) +- maxFrameSize uint32 +- maxConcurrentStreams uint32 +- peerMaxHeaderListSize uint64 +- peerMaxHeaderTableSize uint32 +- initialWindowSize uint32 ++ maxFrameSize uint32 ++ maxConcurrentStreams uint32 ++ peerMaxHeaderListSize uint64 ++ peerMaxHeaderTableSize uint32 ++ initialWindowSize uint32 ++ initialStreamRecvWindowSize int32 ++ readIdleTimeout time.Duration ++ pingTimeout time.Duration ++ extendedConnectAllowed bool ++ ++ // rstStreamPingsBlocked works around an unfortunate gRPC behavior. ++ // gRPC strictly limits the number of PING frames that it will receive. ++ // The default is two pings per two hours, but the limit resets every time ++ // the gRPC endpoint sends a HEADERS or DATA frame. See golang/go#70575. ++ // ++ // rstStreamPingsBlocked is set after receiving a response to a PING frame ++ // bundled with an RST_STREAM (see pendingResets below), and cleared after ++ // receiving a HEADERS or DATA frame. ++ rstStreamPingsBlocked bool ++ ++ // pendingResets is the number of RST_STREAM frames we have sent to the peer, ++ // without confirming that the peer has received them. When we send a RST_STREAM, ++ // we bundle it with a PING frame, unless a PING is already in flight. We count ++ // the reset stream against the connection's concurrency limit until we get ++ // a PING response. This limits the number of requests we'll try to send to a ++ // completely unresponsive connection. ++ pendingResets int + + // reqHeaderMu is a 1-element semaphore channel controlling access to sending new requests. + // Write to reqHeaderMu to lock it, read from it to unlock. +@@ -432,12 +473,12 @@ type clientStream struct { + sentHeaders bool + + // owned by clientConnReadLoop: +- firstByte bool // got the first response byte +- pastHeaders bool // got first MetaHeadersFrame (actual headers) +- pastTrailers bool // got optional second MetaHeadersFrame (trailers) +- num1xx uint8 // number of 1xx responses seen +- readClosed bool // peer sent an END_STREAM flag +- readAborted bool // read loop reset the stream ++ firstByte bool // got the first response byte ++ pastHeaders bool // got first MetaHeadersFrame (actual headers) ++ pastTrailers bool // got optional second MetaHeadersFrame (trailers) ++ readClosed bool // peer sent an END_STREAM flag ++ readAborted bool // read loop reset the stream ++ totalHeaderSize int64 // total size of 1xx headers seen + + trailer http.Header // accumulated trailers + resTrailer *http.Header // client's Response.Trailer +@@ -499,6 +540,7 @@ func (cs *clientStream) closeReqBodyLocked() { + } + + type stickyErrWriter struct { ++ group synctestGroupInterface + conn net.Conn + timeout time.Duration + err *error +@@ -508,22 +550,9 @@ func (sew stickyErrWriter) Write(p []byte) (n int, err error) { + if *sew.err != nil { + return 0, *sew.err + } +- for { +- if sew.timeout != 0 { +- sew.conn.SetWriteDeadline(time.Now().Add(sew.timeout)) +- } +- nn, err := sew.conn.Write(p[n:]) +- n += nn +- if n < len(p) && nn > 0 && errors.Is(err, os.ErrDeadlineExceeded) { +- // Keep extending the deadline so long as we're making progress. +- continue +- } +- if sew.timeout != 0 { +- sew.conn.SetWriteDeadline(time.Time{}) +- } +- *sew.err = err +- return n, err +- } ++ n, err = writeWithByteTimeout(sew.group, sew.conn, sew.timeout, p) ++ *sew.err = err ++ return n, err + } + + // noCachedConnError is the concrete type of ErrNoCachedConn, which +@@ -554,6 +583,8 @@ type RoundTripOpt struct { + // no cached connection is available, RoundTripOpt + // will return ErrNoCachedConn. + OnlyCachedConn bool ++ ++ allowHTTP bool // allow http:// URLs + } + + func (t *Transport) RoundTrip(req *http.Request) (*http.Response, error) { +@@ -586,7 +617,14 @@ func authorityAddr(scheme string, authority string) (addr string) { + + // RoundTripOpt is like RoundTrip, but takes options. + func (t *Transport) RoundTripOpt(req *http.Request, opt RoundTripOpt) (*http.Response, error) { +- if !(req.URL.Scheme == "https" || (req.URL.Scheme == "http" && t.AllowHTTP)) { ++ switch req.URL.Scheme { ++ case "https": ++ // Always okay. ++ case "http": ++ if !t.AllowHTTP && !opt.allowHTTP { ++ return nil, errors.New("http2: unencrypted HTTP/2 not enabled") ++ } ++ default: + return nil, errors.New("http2: unsupported scheme") + } + +@@ -597,7 +635,7 @@ func (t *Transport) RoundTripOpt(req *http.Request, opt RoundTripOpt) (*http.Res + t.vlogf("http2: Transport failed to get client conn for %s: %v", addr, err) + return nil, err + } +- reused := !atomic.CompareAndSwapUint32(&cc.reused, 0, 1) ++ reused := !atomic.CompareAndSwapUint32(&cc.atomicReused, 0, 1) + traceGotConn(req, cc, reused) + res, err := cc.RoundTrip(req) + if err != nil && retry <= 6 { +@@ -622,6 +660,22 @@ func (t *Transport) RoundTripOpt(req *http.Request, opt RoundTripOpt) (*http.Res + } + } + } ++ if err == errClientConnNotEstablished { ++ // This ClientConn was created recently, ++ // this is the first request to use it, ++ // and the connection is closed and not usable. ++ // ++ // In this state, cc.idleTimer will remove the conn from the pool ++ // when it fires. Stop the timer and remove it here so future requests ++ // won't try to use this connection. ++ // ++ // If the timer has already fired and we're racing it, the redundant ++ // call to MarkDead is harmless. ++ if cc.idleTimer != nil { ++ cc.idleTimer.Stop() ++ } ++ t.connPool().MarkDead(cc) ++ } + if err != nil { + t.vlogf("RoundTrip failure: %v", err) + return nil, err +@@ -640,9 +694,10 @@ func (t *Transport) CloseIdleConnections() { + } + + var ( +- errClientConnClosed = errors.New("http2: client conn is closed") +- errClientConnUnusable = errors.New("http2: client conn not usable") +- errClientConnGotGoAway = errors.New("http2: Transport received Server's graceful shutdown GOAWAY") ++ errClientConnClosed = errors.New("http2: client conn is closed") ++ errClientConnUnusable = errors.New("http2: client conn not usable") ++ errClientConnNotEstablished = errors.New("http2: client conn could not be established") ++ errClientConnGotGoAway = errors.New("http2: Transport received Server's graceful shutdown GOAWAY") + ) + + // shouldRetryRequest is called by RoundTrip when a request fails to get +@@ -758,44 +813,38 @@ func (t *Transport) expectContinueTimeout() time.Duration { + return t.t1.ExpectContinueTimeout + } + +-func (t *Transport) maxDecoderHeaderTableSize() uint32 { +- if v := t.MaxDecoderHeaderTableSize; v > 0 { +- return v +- } +- return initialHeaderTableSize +-} +- +-func (t *Transport) maxEncoderHeaderTableSize() uint32 { +- if v := t.MaxEncoderHeaderTableSize; v > 0 { +- return v +- } +- return initialHeaderTableSize +-} +- + func (t *Transport) NewClientConn(c net.Conn) (*ClientConn, error) { + return t.newClientConn(c, t.disableKeepAlives()) + } + + func (t *Transport) newClientConn(c net.Conn, singleUse bool) (*ClientConn, error) { ++ conf := configFromTransport(t) + cc := &ClientConn{ +- t: t, +- tconn: c, +- readerDone: make(chan struct{}), +- nextStreamID: 1, +- maxFrameSize: 16 << 10, // spec default +- initialWindowSize: 65535, // spec default +- maxConcurrentStreams: initialMaxConcurrentStreams, // "infinite", per spec. Use a smaller value until we have received server settings. +- peerMaxHeaderListSize: 0xffffffffffffffff, // "infinite", per spec. Use 2^64-1 instead. +- streams: make(map[uint32]*clientStream), +- singleUse: singleUse, +- wantSettingsAck: true, +- pings: make(map[[8]byte]chan struct{}), +- reqHeaderMu: make(chan struct{}, 1), +- } ++ t: t, ++ tconn: c, ++ readerDone: make(chan struct{}), ++ nextStreamID: 1, ++ maxFrameSize: 16 << 10, // spec default ++ initialWindowSize: 65535, // spec default ++ initialStreamRecvWindowSize: conf.MaxUploadBufferPerStream, ++ maxConcurrentStreams: initialMaxConcurrentStreams, // "infinite", per spec. Use a smaller value until we have received server settings. ++ peerMaxHeaderListSize: 0xffffffffffffffff, // "infinite", per spec. Use 2^64-1 instead. ++ streams: make(map[uint32]*clientStream), ++ singleUse: singleUse, ++ seenSettingsChan: make(chan struct{}), ++ wantSettingsAck: true, ++ readIdleTimeout: conf.SendPingTimeout, ++ pingTimeout: conf.PingTimeout, ++ pings: make(map[[8]byte]chan struct{}), ++ reqHeaderMu: make(chan struct{}, 1), ++ lastActive: t.now(), ++ } ++ var group synctestGroupInterface + if t.transportTestHooks != nil { + t.markNewGoroutine() + t.transportTestHooks.newclientconn(cc) + c = cc.tconn ++ group = t.group + } + if VerboseLogs { + t.vlogf("http2: Transport creating client conn %p to %v", cc, c.RemoteAddr()) +@@ -807,24 +856,23 @@ func (t *Transport) newClientConn(c net.Conn, singleUse bool) (*ClientConn, erro + // TODO: adjust this writer size to account for frame size + + // MTU + crypto/tls record padding. + cc.bw = bufio.NewWriter(stickyErrWriter{ ++ group: group, + conn: c, +- timeout: t.WriteByteTimeout, ++ timeout: conf.WriteByteTimeout, + err: &cc.werr, + }) + cc.br = bufio.NewReader(c) + cc.fr = NewFramer(cc.bw, cc.br) +- if t.maxFrameReadSize() != 0 { +- cc.fr.SetMaxReadFrameSize(t.maxFrameReadSize()) +- } ++ cc.fr.SetMaxReadFrameSize(conf.MaxReadFrameSize) + if t.CountError != nil { + cc.fr.countError = t.CountError + } +- maxHeaderTableSize := t.maxDecoderHeaderTableSize() ++ maxHeaderTableSize := conf.MaxDecoderHeaderTableSize + cc.fr.ReadMetaHeaders = hpack.NewDecoder(maxHeaderTableSize, nil) + cc.fr.MaxHeaderListSize = t.maxHeaderListSize() + + cc.henc = hpack.NewEncoder(&cc.hbuf) +- cc.henc.SetMaxDynamicTableSizeLimit(t.maxEncoderHeaderTableSize()) ++ cc.henc.SetMaxDynamicTableSizeLimit(conf.MaxEncoderHeaderTableSize) + cc.peerMaxHeaderTableSize = initialHeaderTableSize + + if cs, ok := c.(connectionStater); ok { +@@ -834,11 +882,9 @@ func (t *Transport) newClientConn(c net.Conn, singleUse bool) (*ClientConn, erro + + initialSettings := []Setting{ + {ID: SettingEnablePush, Val: 0}, +- {ID: SettingInitialWindowSize, Val: transportDefaultStreamFlow}, +- } +- if max := t.maxFrameReadSize(); max != 0 { +- initialSettings = append(initialSettings, Setting{ID: SettingMaxFrameSize, Val: max}) ++ {ID: SettingInitialWindowSize, Val: uint32(cc.initialStreamRecvWindowSize)}, + } ++ initialSettings = append(initialSettings, Setting{ID: SettingMaxFrameSize, Val: conf.MaxReadFrameSize}) + if max := t.maxHeaderListSize(); max != 0 { + initialSettings = append(initialSettings, Setting{ID: SettingMaxHeaderListSize, Val: max}) + } +@@ -848,8 +894,8 @@ func (t *Transport) newClientConn(c net.Conn, singleUse bool) (*ClientConn, erro + + cc.bw.Write(clientPreface) + cc.fr.WriteSettings(initialSettings...) +- cc.fr.WriteWindowUpdate(0, transportDefaultConnFlow) +- cc.inflow.init(transportDefaultConnFlow + initialWindowSize) ++ cc.fr.WriteWindowUpdate(0, uint32(conf.MaxUploadBufferPerConnection)) ++ cc.inflow.init(conf.MaxUploadBufferPerConnection + initialWindowSize) + cc.bw.Flush() + if cc.werr != nil { + cc.Close() +@@ -867,7 +913,7 @@ func (t *Transport) newClientConn(c net.Conn, singleUse bool) (*ClientConn, erro + } + + func (cc *ClientConn) healthCheck() { +- pingTimeout := cc.t.pingTimeout() ++ pingTimeout := cc.pingTimeout + // We don't need to periodically ping in the health check, because the readLoop of ClientConn will + // trigger the healthCheck again if there is no frame received. + ctx, cancel := cc.t.contextWithTimeout(context.Background(), pingTimeout) +@@ -995,7 +1041,7 @@ func (cc *ClientConn) State() ClientConnState { + return ClientConnState{ + Closed: cc.closed, + Closing: cc.closing || cc.singleUse || cc.doNotReuse || cc.goAway != nil, +- StreamsActive: len(cc.streams), ++ StreamsActive: len(cc.streams) + cc.pendingResets, + StreamsReserved: cc.streamsReserved, + StreamsPending: cc.pendingRequests, + LastIdle: cc.lastIdle, +@@ -1027,16 +1073,38 @@ func (cc *ClientConn) idleStateLocked() (st clientConnIdleState) { + // writing it. + maxConcurrentOkay = true + } else { +- maxConcurrentOkay = int64(len(cc.streams)+cc.streamsReserved+1) <= int64(cc.maxConcurrentStreams) ++ // We can take a new request if the total of ++ // - active streams; ++ // - reservation slots for new streams; and ++ // - streams for which we have sent a RST_STREAM and a PING, ++ // but received no subsequent frame ++ // is less than the concurrency limit. ++ maxConcurrentOkay = cc.currentRequestCountLocked() < int(cc.maxConcurrentStreams) + } + + st.canTakeNewRequest = cc.goAway == nil && !cc.closed && !cc.closing && maxConcurrentOkay && + !cc.doNotReuse && + int64(cc.nextStreamID)+2*int64(cc.pendingRequests) < math.MaxInt32 && + !cc.tooIdleLocked() ++ ++ // If this connection has never been used for a request and is closed, ++ // then let it take a request (which will fail). ++ // ++ // This avoids a situation where an error early in a connection's lifetime ++ // goes unreported. ++ if cc.nextStreamID == 1 && cc.streamsReserved == 0 && cc.closed { ++ st.canTakeNewRequest = true ++ } ++ + return + } + ++// currentRequestCountLocked reports the number of concurrency slots currently in use, ++// including active streams, reserved slots, and reset streams waiting for acknowledgement. ++func (cc *ClientConn) currentRequestCountLocked() int { ++ return len(cc.streams) + cc.streamsReserved + cc.pendingResets ++} ++ + func (cc *ClientConn) canTakeNewRequestLocked() bool { + st := cc.idleStateLocked() + return st.canTakeNewRequest +@@ -1049,7 +1117,7 @@ func (cc *ClientConn) tooIdleLocked() bool { + // times are compared based on their wall time. We don't want + // to reuse a connection that's been sitting idle during + // VM/laptop suspend if monotonic time was also frozen. +- return cc.idleTimeout != 0 && !cc.lastIdle.IsZero() && time.Since(cc.lastIdle.Round(0)) > cc.idleTimeout ++ return cc.idleTimeout != 0 && !cc.lastIdle.IsZero() && cc.t.timeSince(cc.lastIdle.Round(0)) > cc.idleTimeout + } + + // onIdleTimeout is called from a time.AfterFunc goroutine. It will +@@ -1411,6 +1479,8 @@ func (cs *clientStream) doRequest(req *http.Request, streamf func(*clientStream) + cs.cleanupWriteRequest(err) + } + ++var errExtendedConnectNotSupported = errors.New("net/http: extended connect not supported by peer") ++ + // writeRequest sends a request. + // + // It returns nil after the request is written, the response read, +@@ -1426,12 +1496,31 @@ func (cs *clientStream) writeRequest(req *http.Request, streamf func(*clientStre + return err + } + ++ // wait for setting frames to be received, a server can change this value later, ++ // but we just wait for the first settings frame ++ var isExtendedConnect bool ++ if req.Method == "CONNECT" && req.Header.Get(":protocol") != "" { ++ isExtendedConnect = true ++ } ++ + // Acquire the new-request lock by writing to reqHeaderMu. + // This lock guards the critical section covering allocating a new stream ID + // (requires mu) and creating the stream (requires wmu). + if cc.reqHeaderMu == nil { + panic("RoundTrip on uninitialized ClientConn") // for tests + } ++ if isExtendedConnect { ++ select { ++ case <-cs.reqCancel: ++ return errRequestCanceled ++ case <-ctx.Done(): ++ return ctx.Err() ++ case <-cc.seenSettingsChan: ++ if !cc.extendedConnectAllowed { ++ return errExtendedConnectNotSupported ++ } ++ } ++ } + select { + case cc.reqHeaderMu <- struct{}{}: + case <-cs.reqCancel: +@@ -1613,6 +1702,7 @@ func (cs *clientStream) cleanupWriteRequest(err error) { + cs.reqBodyClosed = make(chan struct{}) + } + bodyClosed := cs.reqBodyClosed ++ closeOnIdle := cc.singleUse || cc.doNotReuse || cc.t.disableKeepAlives() || cc.goAway != nil + cc.mu.Unlock() + if mustCloseBody { + cs.reqBody.Close() +@@ -1637,16 +1727,44 @@ func (cs *clientStream) cleanupWriteRequest(err error) { + if cs.sentHeaders { + if se, ok := err.(StreamError); ok { + if se.Cause != errFromPeer { +- cc.writeStreamReset(cs.ID, se.Code, err) ++ cc.writeStreamReset(cs.ID, se.Code, false, err) + } + } else { +- cc.writeStreamReset(cs.ID, ErrCodeCancel, err) ++ // We're cancelling an in-flight request. ++ // ++ // This could be due to the server becoming unresponsive. ++ // To avoid sending too many requests on a dead connection, ++ // we let the request continue to consume a concurrency slot ++ // until we can confirm the server is still responding. ++ // We do this by sending a PING frame along with the RST_STREAM ++ // (unless a ping is already in flight). ++ // ++ // For simplicity, we don't bother tracking the PING payload: ++ // We reset cc.pendingResets any time we receive a PING ACK. ++ // ++ // We skip this if the conn is going to be closed on idle, ++ // because it's short lived and will probably be closed before ++ // we get the ping response. ++ ping := false ++ if !closeOnIdle { ++ cc.mu.Lock() ++ // rstStreamPingsBlocked works around a gRPC behavior: ++ // see comment on the field for details. ++ if !cc.rstStreamPingsBlocked { ++ if cc.pendingResets == 0 { ++ ping = true ++ } ++ cc.pendingResets++ ++ } ++ cc.mu.Unlock() ++ } ++ cc.writeStreamReset(cs.ID, ErrCodeCancel, ping, err) + } + } + cs.bufPipe.CloseWithError(err) // no-op if already closed + } else { + if cs.sentHeaders && !cs.sentEndStream { +- cc.writeStreamReset(cs.ID, ErrCodeNo, nil) ++ cc.writeStreamReset(cs.ID, ErrCodeNo, false, nil) + } + cs.bufPipe.CloseWithError(errRequestCanceled) + } +@@ -1668,12 +1786,17 @@ func (cs *clientStream) cleanupWriteRequest(err error) { + // Must hold cc.mu. + func (cc *ClientConn) awaitOpenSlotForStreamLocked(cs *clientStream) error { + for { +- cc.lastActive = time.Now() ++ if cc.closed && cc.nextStreamID == 1 && cc.streamsReserved == 0 { ++ // This is the very first request sent to this connection. ++ // Return a fatal error which aborts the retry loop. ++ return errClientConnNotEstablished ++ } ++ cc.lastActive = cc.t.now() + if cc.closed || !cc.canTakeNewRequestLocked() { + return errClientConnUnusable + } + cc.lastIdle = time.Time{} +- if int64(len(cc.streams)) < int64(cc.maxConcurrentStreams) { ++ if cc.currentRequestCountLocked() < int(cc.maxConcurrentStreams) { + return nil + } + cc.pendingRequests++ +@@ -1945,7 +2068,7 @@ func (cs *clientStream) awaitFlowControl(maxBytes int) (taken int32, err error) + + func validateHeaders(hdrs http.Header) string { + for k, vv := range hdrs { +- if !httpguts.ValidHeaderFieldName(k) { ++ if !httpguts.ValidHeaderFieldName(k) && k != ":protocol" { + return fmt.Sprintf("name %q", k) + } + for _, v := range vv { +@@ -1961,6 +2084,10 @@ func validateHeaders(hdrs http.Header) string { + + var errNilRequestURL = errors.New("http2: Request.URI is nil") + ++func isNormalConnect(req *http.Request) bool { ++ return req.Method == "CONNECT" && req.Header.Get(":protocol") == "" ++} ++ + // requires cc.wmu be held. + func (cc *ClientConn) encodeHeaders(req *http.Request, addGzipHeader bool, trailers string, contentLength int64) ([]byte, error) { + cc.hbuf.Reset() +@@ -1981,7 +2108,7 @@ func (cc *ClientConn) encodeHeaders(req *http.Request, addGzipHeader bool, trail + } + + var path string +- if req.Method != "CONNECT" { ++ if !isNormalConnect(req) { + path = req.URL.RequestURI() + if !validPseudoPath(path) { + orig := path +@@ -2018,7 +2145,7 @@ func (cc *ClientConn) encodeHeaders(req *http.Request, addGzipHeader bool, trail + m = http.MethodGet + } + f(":method", m) +- if req.Method != "CONNECT" { ++ if !isNormalConnect(req) { + f(":path", path) + f(":scheme", req.URL.Scheme) + } +@@ -2199,7 +2326,7 @@ type resAndError struct { + func (cc *ClientConn) addStreamLocked(cs *clientStream) { + cs.flow.add(int32(cc.initialWindowSize)) + cs.flow.setConnFlow(&cc.flow) +- cs.inflow.init(transportDefaultStreamFlow) ++ cs.inflow.init(cc.initialStreamRecvWindowSize) + cs.ID = cc.nextStreamID + cc.nextStreamID += 2 + cc.streams[cs.ID] = cs +@@ -2215,10 +2342,10 @@ func (cc *ClientConn) forgetStreamID(id uint32) { + if len(cc.streams) != slen-1 { + panic("forgetting unknown stream id") + } +- cc.lastActive = time.Now() ++ cc.lastActive = cc.t.now() + if len(cc.streams) == 0 && cc.idleTimer != nil { + cc.idleTimer.Reset(cc.idleTimeout) +- cc.lastIdle = time.Now() ++ cc.lastIdle = cc.t.now() + } + // Wake up writeRequestBody via clientStream.awaitFlowControl and + // wake up RoundTrip if there is a pending request. +@@ -2278,7 +2405,6 @@ func isEOFOrNetReadError(err error) bool { + + func (rl *clientConnReadLoop) cleanup() { + cc := rl.cc +- cc.t.connPool().MarkDead(cc) + defer cc.closeConn() + defer close(cc.readerDone) + +@@ -2302,6 +2428,24 @@ func (rl *clientConnReadLoop) cleanup() { + } + cc.closed = true + ++ // If the connection has never been used, and has been open for only a short time, ++ // leave it in the connection pool for a little while. ++ // ++ // This avoids a situation where new connections are constantly created, ++ // added to the pool, fail, and are removed from the pool, without any error ++ // being surfaced to the user. ++ const unusedWaitTime = 5 * time.Second ++ idleTime := cc.t.now().Sub(cc.lastActive) ++ if atomic.LoadUint32(&cc.atomicReused) == 0 && idleTime < unusedWaitTime { ++ cc.idleTimer = cc.t.afterFunc(unusedWaitTime-idleTime, func() { ++ cc.t.connPool().MarkDead(cc) ++ }) ++ } else { ++ cc.mu.Unlock() // avoid any deadlocks in MarkDead ++ cc.t.connPool().MarkDead(cc) ++ cc.mu.Lock() ++ } ++ + for _, cs := range cc.streams { + select { + case <-cs.peerClosed: +@@ -2345,7 +2489,7 @@ func (cc *ClientConn) countReadFrameError(err error) { + func (rl *clientConnReadLoop) run() error { + cc := rl.cc + gotSettings := false +- readIdleTimeout := cc.t.ReadIdleTimeout ++ readIdleTimeout := cc.readIdleTimeout + var t timer + if readIdleTimeout != 0 { + t = cc.t.afterFunc(readIdleTimeout, cc.healthCheck) +@@ -2359,7 +2503,7 @@ func (rl *clientConnReadLoop) run() error { + cc.vlogf("http2: Transport readFrame error on conn %p: (%T) %v", cc, err, err) + } + if se, ok := err.(StreamError); ok { +- if cs := rl.streamByID(se.StreamID); cs != nil { ++ if cs := rl.streamByID(se.StreamID, notHeaderOrDataFrame); cs != nil { + if se.Cause == nil { + se.Cause = cc.fr.errDetail + } +@@ -2405,13 +2549,16 @@ func (rl *clientConnReadLoop) run() error { + if VerboseLogs { + cc.vlogf("http2: Transport conn %p received error from processing frame %v: %v", cc, summarizeFrame(f), err) + } ++ if !cc.seenSettings { ++ close(cc.seenSettingsChan) ++ } + return err + } + } + } + + func (rl *clientConnReadLoop) processHeaders(f *MetaHeadersFrame) error { +- cs := rl.streamByID(f.StreamID) ++ cs := rl.streamByID(f.StreamID, headerOrDataFrame) + if cs == nil { + // We'd get here if we canceled a request while the + // server had its response still in flight. So if this +@@ -2529,15 +2676,34 @@ func (rl *clientConnReadLoop) handleResponse(cs *clientStream, f *MetaHeadersFra + if f.StreamEnded() { + return nil, errors.New("1xx informational response with END_STREAM flag") + } +- cs.num1xx++ +- const max1xxResponses = 5 // arbitrary bound on number of informational responses, same as net/http +- if cs.num1xx > max1xxResponses { +- return nil, errors.New("http2: too many 1xx informational responses") +- } + if fn := cs.get1xxTraceFunc(); fn != nil { ++ // If the 1xx response is being delivered to the user, ++ // then they're responsible for limiting the number ++ // of responses. + if err := fn(statusCode, textproto.MIMEHeader(header)); err != nil { + return nil, err + } ++ } else { ++ // If the user didn't examine the 1xx response, then we ++ // limit the size of all 1xx headers. ++ // ++ // This differs a bit from the HTTP/1 implementation, which ++ // limits the size of all 1xx headers plus the final response. ++ // Use the larger limit of MaxHeaderListSize and ++ // net/http.Transport.MaxResponseHeaderBytes. ++ limit := int64(cs.cc.t.maxHeaderListSize()) ++ if t1 := cs.cc.t.t1; t1 != nil && t1.MaxResponseHeaderBytes > limit { ++ limit = t1.MaxResponseHeaderBytes ++ } ++ for _, h := range f.Fields { ++ cs.totalHeaderSize += int64(h.Size()) ++ } ++ if cs.totalHeaderSize > limit { ++ if VerboseLogs { ++ log.Printf("http2: 1xx informational responses too large") ++ } ++ return nil, errors.New("header list too large") ++ } + } + if statusCode == 100 { + traceGot100Continue(cs.trace) +@@ -2721,7 +2887,7 @@ func (b transportResponseBody) Close() error { + + func (rl *clientConnReadLoop) processData(f *DataFrame) error { + cc := rl.cc +- cs := rl.streamByID(f.StreamID) ++ cs := rl.streamByID(f.StreamID, headerOrDataFrame) + data := f.Data() + if cs == nil { + cc.mu.Lock() +@@ -2856,9 +3022,22 @@ func (rl *clientConnReadLoop) endStreamError(cs *clientStream, err error) { + cs.abortStream(err) + } + +-func (rl *clientConnReadLoop) streamByID(id uint32) *clientStream { ++// Constants passed to streamByID for documentation purposes. ++const ( ++ headerOrDataFrame = true ++ notHeaderOrDataFrame = false ++) ++ ++// streamByID returns the stream with the given id, or nil if no stream has that id. ++// If headerOrData is true, it clears rst.StreamPingsBlocked. ++func (rl *clientConnReadLoop) streamByID(id uint32, headerOrData bool) *clientStream { + rl.cc.mu.Lock() + defer rl.cc.mu.Unlock() ++ if headerOrData { ++ // Work around an unfortunate gRPC behavior. ++ // See comment on ClientConn.rstStreamPingsBlocked for details. ++ rl.cc.rstStreamPingsBlocked = false ++ } + cs := rl.cc.streams[id] + if cs != nil && !cs.readAborted { + return cs +@@ -2952,6 +3131,21 @@ func (rl *clientConnReadLoop) processSettingsNoWrite(f *SettingsFrame) error { + case SettingHeaderTableSize: + cc.henc.SetMaxDynamicTableSize(s.Val) + cc.peerMaxHeaderTableSize = s.Val ++ case SettingEnableConnectProtocol: ++ if err := s.Valid(); err != nil { ++ return err ++ } ++ // If the peer wants to send us SETTINGS_ENABLE_CONNECT_PROTOCOL, ++ // we require that it do so in the first SETTINGS frame. ++ // ++ // When we attempt to use extended CONNECT, we wait for the first ++ // SETTINGS frame to see if the server supports it. If we let the ++ // server enable the feature with a later SETTINGS frame, then ++ // users will see inconsistent results depending on whether we've ++ // seen that frame or not. ++ if !cc.seenSettings { ++ cc.extendedConnectAllowed = s.Val == 1 ++ } + default: + cc.vlogf("Unhandled Setting: %v", s) + } +@@ -2969,6 +3163,7 @@ func (rl *clientConnReadLoop) processSettingsNoWrite(f *SettingsFrame) error { + // connection can establish to our default. + cc.maxConcurrentStreams = defaultMaxConcurrentStreams + } ++ close(cc.seenSettingsChan) + cc.seenSettings = true + } + +@@ -2977,7 +3172,7 @@ func (rl *clientConnReadLoop) processSettingsNoWrite(f *SettingsFrame) error { + + func (rl *clientConnReadLoop) processWindowUpdate(f *WindowUpdateFrame) error { + cc := rl.cc +- cs := rl.streamByID(f.StreamID) ++ cs := rl.streamByID(f.StreamID, notHeaderOrDataFrame) + if f.StreamID != 0 && cs == nil { + return nil + } +@@ -3006,7 +3201,7 @@ func (rl *clientConnReadLoop) processWindowUpdate(f *WindowUpdateFrame) error { + } + + func (rl *clientConnReadLoop) processResetStream(f *RSTStreamFrame) error { +- cs := rl.streamByID(f.StreamID) ++ cs := rl.streamByID(f.StreamID, notHeaderOrDataFrame) + if cs == nil { + // TODO: return error if server tries to RST_STREAM an idle stream + return nil +@@ -3081,6 +3276,12 @@ func (rl *clientConnReadLoop) processPing(f *PingFrame) error { + close(c) + delete(cc.pings, f.Data) + } ++ if cc.pendingResets > 0 { ++ // See clientStream.cleanupWriteRequest. ++ cc.pendingResets = 0 ++ cc.rstStreamPingsBlocked = true ++ cc.cond.Broadcast() ++ } + return nil + } + cc := rl.cc +@@ -3103,13 +3304,20 @@ func (rl *clientConnReadLoop) processPushPromise(f *PushPromiseFrame) error { + return ConnectionError(ErrCodeProtocol) + } + +-func (cc *ClientConn) writeStreamReset(streamID uint32, code ErrCode, err error) { ++// writeStreamReset sends a RST_STREAM frame. ++// When ping is true, it also sends a PING frame with a random payload. ++func (cc *ClientConn) writeStreamReset(streamID uint32, code ErrCode, ping bool, err error) { + // TODO: map err to more interesting error codes, once the + // HTTP community comes up with some. But currently for + // RST_STREAM there's no equivalent to GOAWAY frame's debug + // data, and the error codes are all pretty vague ("cancel"). + cc.wmu.Lock() + cc.fr.WriteRSTStream(streamID, code) ++ if ping { ++ var payload [8]byte ++ rand.Read(payload[:]) ++ cc.fr.WritePing(false, payload) ++ } + cc.bw.Flush() + cc.wmu.Unlock() + } +@@ -3263,7 +3471,7 @@ func traceGotConn(req *http.Request, cc *ClientConn, reused bool) { + cc.mu.Lock() + ci.WasIdle = len(cc.streams) == 0 && reused + if ci.WasIdle && !cc.lastActive.IsZero() { +- ci.IdleTime = time.Since(cc.lastActive) ++ ci.IdleTime = cc.t.timeSince(cc.lastActive) + } + cc.mu.Unlock() + +diff --git a/vendor/golang.org/x/net/http2/unencrypted.go b/vendor/golang.org/x/net/http2/unencrypted.go +new file mode 100644 +index 0000000..b2de211 +--- /dev/null ++++ b/vendor/golang.org/x/net/http2/unencrypted.go +@@ -0,0 +1,32 @@ ++// Copyright 2024 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 http2 ++ ++import ( ++ "crypto/tls" ++ "errors" ++ "net" ++) ++ ++const nextProtoUnencryptedHTTP2 = "unencrypted_http2" ++ ++// unencryptedNetConnFromTLSConn retrieves a net.Conn wrapped in a *tls.Conn. ++// ++// TLSNextProto functions accept a *tls.Conn. ++// ++// When passing an unencrypted HTTP/2 connection to a TLSNextProto function, ++// we pass a *tls.Conn with an underlying net.Conn containing the unencrypted connection. ++// To be extra careful about mistakes (accidentally dropping TLS encryption in a place ++// where we want it), the tls.Conn contains a net.Conn with an UnencryptedNetConn method ++// that returns the actual connection we want to use. ++func unencryptedNetConnFromTLSConn(tc *tls.Conn) (net.Conn, error) { ++ conner, ok := tc.NetConn().(interface { ++ UnencryptedNetConn() net.Conn ++ }) ++ if !ok { ++ return nil, errors.New("http2: TLS conn unexpectedly found in unencrypted handoff") ++ } ++ return conner.UnencryptedNetConn(), nil ++} +diff --git a/vendor/golang.org/x/net/http2/write.go b/vendor/golang.org/x/net/http2/write.go +index 33f6139..6ff6bee 100644 +--- a/vendor/golang.org/x/net/http2/write.go ++++ b/vendor/golang.org/x/net/http2/write.go +@@ -131,6 +131,16 @@ func (se StreamError) writeFrame(ctx writeContext) error { + + func (se StreamError) staysWithinBuffer(max int) bool { return frameHeaderLen+4 <= max } + ++type writePing struct { ++ data [8]byte ++} ++ ++func (w writePing) writeFrame(ctx writeContext) error { ++ return ctx.Framer().WritePing(false, w.data) ++} ++ ++func (w writePing) staysWithinBuffer(max int) bool { return frameHeaderLen+len(w.data) <= max } ++ + type writePingAck struct{ pf *PingFrame } + + func (w writePingAck) writeFrame(ctx writeContext) error { +diff --git a/vendor/golang.org/x/sys/unix/README.md b/vendor/golang.org/x/sys/unix/README.md +index 7d3c060..6e08a76 100644 +--- a/vendor/golang.org/x/sys/unix/README.md ++++ b/vendor/golang.org/x/sys/unix/README.md +@@ -156,7 +156,7 @@ from the generated architecture-specific files listed below, and merge these + into a common file for each OS. + + The merge is performed in the following steps: +-1. Construct the set of common code that is idential in all architecture-specific files. ++1. Construct the set of common code that is identical in all architecture-specific files. + 2. Write this common code to the merged file. + 3. Remove the common code from all architecture-specific files. + +diff --git a/vendor/golang.org/x/sys/unix/ioctl_linux.go b/vendor/golang.org/x/sys/unix/ioctl_linux.go +index dbe680e..7ca4fa1 100644 +--- a/vendor/golang.org/x/sys/unix/ioctl_linux.go ++++ b/vendor/golang.org/x/sys/unix/ioctl_linux.go +@@ -58,6 +58,102 @@ func IoctlGetEthtoolDrvinfo(fd int, ifname string) (*EthtoolDrvinfo, error) { + return &value, err + } + ++// IoctlGetEthtoolTsInfo fetches ethtool timestamping and PHC ++// association for the network device specified by ifname. ++func IoctlGetEthtoolTsInfo(fd int, ifname string) (*EthtoolTsInfo, error) { ++ ifr, err := NewIfreq(ifname) ++ if err != nil { ++ return nil, err ++ } ++ ++ value := EthtoolTsInfo{Cmd: ETHTOOL_GET_TS_INFO} ++ ifrd := ifr.withData(unsafe.Pointer(&value)) ++ ++ err = ioctlIfreqData(fd, SIOCETHTOOL, &ifrd) ++ return &value, err ++} ++ ++// IoctlGetHwTstamp retrieves the hardware timestamping configuration ++// for the network device specified by ifname. ++func IoctlGetHwTstamp(fd int, ifname string) (*HwTstampConfig, error) { ++ ifr, err := NewIfreq(ifname) ++ if err != nil { ++ return nil, err ++ } ++ ++ value := HwTstampConfig{} ++ ifrd := ifr.withData(unsafe.Pointer(&value)) ++ ++ err = ioctlIfreqData(fd, SIOCGHWTSTAMP, &ifrd) ++ return &value, err ++} ++ ++// IoctlSetHwTstamp updates the hardware timestamping configuration for ++// the network device specified by ifname. ++func IoctlSetHwTstamp(fd int, ifname string, cfg *HwTstampConfig) error { ++ ifr, err := NewIfreq(ifname) ++ if err != nil { ++ return err ++ } ++ ifrd := ifr.withData(unsafe.Pointer(cfg)) ++ return ioctlIfreqData(fd, SIOCSHWTSTAMP, &ifrd) ++} ++ ++// FdToClockID derives the clock ID from the file descriptor number ++// - see clock_gettime(3), FD_TO_CLOCKID macros. The resulting ID is ++// suitable for system calls like ClockGettime. ++func FdToClockID(fd int) int32 { return int32((int(^fd) << 3) | 3) } ++ ++// IoctlPtpClockGetcaps returns the description of a given PTP device. ++func IoctlPtpClockGetcaps(fd int) (*PtpClockCaps, error) { ++ var value PtpClockCaps ++ err := ioctlPtr(fd, PTP_CLOCK_GETCAPS2, unsafe.Pointer(&value)) ++ return &value, err ++} ++ ++// IoctlPtpSysOffsetPrecise returns a description of the clock ++// offset compared to the system clock. ++func IoctlPtpSysOffsetPrecise(fd int) (*PtpSysOffsetPrecise, error) { ++ var value PtpSysOffsetPrecise ++ err := ioctlPtr(fd, PTP_SYS_OFFSET_PRECISE2, unsafe.Pointer(&value)) ++ return &value, err ++} ++ ++// IoctlPtpSysOffsetExtended returns an extended description of the ++// clock offset compared to the system clock. The samples parameter ++// specifies the desired number of measurements. ++func IoctlPtpSysOffsetExtended(fd int, samples uint) (*PtpSysOffsetExtended, error) { ++ value := PtpSysOffsetExtended{Samples: uint32(samples)} ++ err := ioctlPtr(fd, PTP_SYS_OFFSET_EXTENDED2, unsafe.Pointer(&value)) ++ return &value, err ++} ++ ++// IoctlPtpPinGetfunc returns the configuration of the specified ++// I/O pin on given PTP device. ++func IoctlPtpPinGetfunc(fd int, index uint) (*PtpPinDesc, error) { ++ value := PtpPinDesc{Index: uint32(index)} ++ err := ioctlPtr(fd, PTP_PIN_GETFUNC2, unsafe.Pointer(&value)) ++ return &value, err ++} ++ ++// IoctlPtpPinSetfunc updates configuration of the specified PTP ++// I/O pin. ++func IoctlPtpPinSetfunc(fd int, pd *PtpPinDesc) error { ++ return ioctlPtr(fd, PTP_PIN_SETFUNC2, unsafe.Pointer(pd)) ++} ++ ++// IoctlPtpPeroutRequest configures the periodic output mode of the ++// PTP I/O pins. ++func IoctlPtpPeroutRequest(fd int, r *PtpPeroutRequest) error { ++ return ioctlPtr(fd, PTP_PEROUT_REQUEST2, unsafe.Pointer(r)) ++} ++ ++// IoctlPtpExttsRequest configures the external timestamping mode ++// of the PTP I/O pins. ++func IoctlPtpExttsRequest(fd int, r *PtpExttsRequest) error { ++ return ioctlPtr(fd, PTP_EXTTS_REQUEST2, unsafe.Pointer(r)) ++} ++ + // IoctlGetWatchdogInfo fetches information about a watchdog device from the + // Linux watchdog API. For more information, see: + // https://www.kernel.org/doc/html/latest/watchdog/watchdog-api.html. +diff --git a/vendor/golang.org/x/sys/unix/mkerrors.sh b/vendor/golang.org/x/sys/unix/mkerrors.sh +index d07dd09..6ab02b6 100644 +--- a/vendor/golang.org/x/sys/unix/mkerrors.sh ++++ b/vendor/golang.org/x/sys/unix/mkerrors.sh +@@ -158,6 +158,16 @@ includes_Linux=' + #endif + #define _GNU_SOURCE + ++// See the description in unix/linux/types.go ++#if defined(__ARM_EABI__) || \ ++ (defined(__mips__) && (_MIPS_SIM == _ABIO32)) || \ ++ (defined(__powerpc__) && (!defined(__powerpc64__))) ++# ifdef _TIME_BITS ++# undef _TIME_BITS ++# endif ++# define _TIME_BITS 32 ++#endif ++ + // is broken on powerpc64, as it fails to include definitions of + // these structures. We just include them copied from . + #if defined(__powerpc__) +@@ -256,6 +266,7 @@ struct ltchars { + #include + #include + #include ++#include + #include + #include + #include +@@ -527,6 +538,7 @@ ccflags="$@" + $2 ~ /^(AF|SOCK|SO|SOL|IPPROTO|IP|IPV6|TCP|MCAST|EVFILT|NOTE|SHUT|PROT|MAP|MREMAP|MFD|T?PACKET|MSG|SCM|MCL|DT|MADV|PR|LOCAL|TCPOPT|UDP)_/ || + $2 ~ /^NFC_(GENL|PROTO|COMM|RF|SE|DIRECTION|LLCP|SOCKPROTO)_/ || + $2 ~ /^NFC_.*_(MAX)?SIZE$/ || ++ $2 ~ /^PTP_/ || + $2 ~ /^RAW_PAYLOAD_/ || + $2 ~ /^[US]F_/ || + $2 ~ /^TP_STATUS_/ || +@@ -552,6 +564,7 @@ ccflags="$@" + $2 !~ /^RTC_VL_(ACCURACY|BACKUP|DATA)/ && + $2 ~ /^(NETLINK|NLM|NLMSG|NLA|IFA|IFAN|RT|RTC|RTCF|RTN|RTPROT|RTNH|ARPHRD|ETH_P|NETNSA)_/ || + $2 ~ /^SOCK_|SK_DIAG_|SKNLGRP_$/ || ++ $2 ~ /^(CONNECT|SAE)_/ || + $2 ~ /^FIORDCHK$/ || + $2 ~ /^SIOC/ || + $2 ~ /^TIOC/ || +@@ -655,7 +668,7 @@ errors=$( + signals=$( + echo '#include ' | $CC -x c - -E -dM $ccflags | + awk '$1=="#define" && $2 ~ /^SIG[A-Z0-9]+$/ { print $2 }' | +- grep -v 'SIGSTKSIZE\|SIGSTKSZ\|SIGRT\|SIGMAX64' | ++ grep -E -v '(SIGSTKSIZE|SIGSTKSZ|SIGRT|SIGMAX64)' | + sort + ) + +@@ -665,7 +678,7 @@ echo '#include ' | $CC -x c - -E -dM $ccflags | + sort >_error.grep + echo '#include ' | $CC -x c - -E -dM $ccflags | + awk '$1=="#define" && $2 ~ /^SIG[A-Z0-9]+$/ { print "^\t" $2 "[ \t]*=" }' | +- grep -v 'SIGSTKSIZE\|SIGSTKSZ\|SIGRT\|SIGMAX64' | ++ grep -E -v '(SIGSTKSIZE|SIGSTKSZ|SIGRT|SIGMAX64)' | + sort >_signal.grep + + echo '// mkerrors.sh' "$@" +diff --git a/vendor/golang.org/x/sys/unix/syscall_aix.go b/vendor/golang.org/x/sys/unix/syscall_aix.go +index 67ce6ce..6f15ba1 100644 +--- a/vendor/golang.org/x/sys/unix/syscall_aix.go ++++ b/vendor/golang.org/x/sys/unix/syscall_aix.go +@@ -360,7 +360,7 @@ func Wait4(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (wpid int, + var status _C_int + var r Pid_t + err = ERESTART +- // AIX wait4 may return with ERESTART errno, while the processus is still ++ // AIX wait4 may return with ERESTART errno, while the process is still + // active. + for err == ERESTART { + r, err = wait4(Pid_t(pid), &status, options, rusage) +diff --git a/vendor/golang.org/x/sys/unix/syscall_darwin.go b/vendor/golang.org/x/sys/unix/syscall_darwin.go +index 2d15200..099867d 100644 +--- a/vendor/golang.org/x/sys/unix/syscall_darwin.go ++++ b/vendor/golang.org/x/sys/unix/syscall_darwin.go +@@ -566,6 +566,43 @@ func PthreadFchdir(fd int) (err error) { + return pthread_fchdir_np(fd) + } + ++// Connectx calls connectx(2) to initiate a connection on a socket. ++// ++// srcIf, srcAddr, and dstAddr are filled into a [SaEndpoints] struct and passed as the endpoints argument. ++// ++// - srcIf is the optional source interface index. 0 means unspecified. ++// - srcAddr is the optional source address. nil means unspecified. ++// - dstAddr is the destination address. ++// ++// On success, Connectx returns the number of bytes enqueued for transmission. ++func Connectx(fd int, srcIf uint32, srcAddr, dstAddr Sockaddr, associd SaeAssocID, flags uint32, iov []Iovec, connid *SaeConnID) (n uintptr, err error) { ++ endpoints := SaEndpoints{ ++ Srcif: srcIf, ++ } ++ ++ if srcAddr != nil { ++ addrp, addrlen, err := srcAddr.sockaddr() ++ if err != nil { ++ return 0, err ++ } ++ endpoints.Srcaddr = (*RawSockaddr)(addrp) ++ endpoints.Srcaddrlen = uint32(addrlen) ++ } ++ ++ if dstAddr != nil { ++ addrp, addrlen, err := dstAddr.sockaddr() ++ if err != nil { ++ return 0, err ++ } ++ endpoints.Dstaddr = (*RawSockaddr)(addrp) ++ endpoints.Dstaddrlen = uint32(addrlen) ++ } ++ ++ err = connectx(fd, &endpoints, associd, flags, iov, &n, connid) ++ return ++} ++ ++//sys connectx(fd int, endpoints *SaEndpoints, associd SaeAssocID, flags uint32, iov []Iovec, n *uintptr, connid *SaeConnID) (err error) + //sys sendfile(infd int, outfd int, offset int64, len *int64, hdtr unsafe.Pointer, flags int) (err error) + + //sys shmat(id int, addr uintptr, flag int) (ret uintptr, err error) +diff --git a/vendor/golang.org/x/sys/unix/syscall_hurd.go b/vendor/golang.org/x/sys/unix/syscall_hurd.go +index ba46651..a6a2d2f 100644 +--- a/vendor/golang.org/x/sys/unix/syscall_hurd.go ++++ b/vendor/golang.org/x/sys/unix/syscall_hurd.go +@@ -11,6 +11,7 @@ package unix + int ioctl(int, unsigned long int, uintptr_t); + */ + import "C" ++import "unsafe" + + func ioctl(fd int, req uint, arg uintptr) (err error) { + r0, er := C.ioctl(C.int(fd), C.ulong(req), C.uintptr_t(arg)) +diff --git a/vendor/golang.org/x/sys/unix/syscall_linux.go b/vendor/golang.org/x/sys/unix/syscall_linux.go +index 3f1d3d4..230a945 100644 +--- a/vendor/golang.org/x/sys/unix/syscall_linux.go ++++ b/vendor/golang.org/x/sys/unix/syscall_linux.go +@@ -1295,6 +1295,48 @@ func GetsockoptTCPInfo(fd, level, opt int) (*TCPInfo, error) { + return &value, err + } + ++// GetsockoptTCPCCVegasInfo returns algorithm specific congestion control information for a socket using the "vegas" ++// algorithm. ++// ++// The socket's congestion control algorighm can be retrieved via [GetsockoptString] with the [TCP_CONGESTION] option: ++// ++// algo, err := unix.GetsockoptString(fd, unix.IPPROTO_TCP, unix.TCP_CONGESTION) ++func GetsockoptTCPCCVegasInfo(fd, level, opt int) (*TCPVegasInfo, error) { ++ var value [SizeofTCPCCInfo / 4]uint32 // ensure proper alignment ++ vallen := _Socklen(SizeofTCPCCInfo) ++ err := getsockopt(fd, level, opt, unsafe.Pointer(&value[0]), &vallen) ++ out := (*TCPVegasInfo)(unsafe.Pointer(&value[0])) ++ return out, err ++} ++ ++// GetsockoptTCPCCDCTCPInfo returns algorithm specific congestion control information for a socket using the "dctp" ++// algorithm. ++// ++// The socket's congestion control algorighm can be retrieved via [GetsockoptString] with the [TCP_CONGESTION] option: ++// ++// algo, err := unix.GetsockoptString(fd, unix.IPPROTO_TCP, unix.TCP_CONGESTION) ++func GetsockoptTCPCCDCTCPInfo(fd, level, opt int) (*TCPDCTCPInfo, error) { ++ var value [SizeofTCPCCInfo / 4]uint32 // ensure proper alignment ++ vallen := _Socklen(SizeofTCPCCInfo) ++ err := getsockopt(fd, level, opt, unsafe.Pointer(&value[0]), &vallen) ++ out := (*TCPDCTCPInfo)(unsafe.Pointer(&value[0])) ++ return out, err ++} ++ ++// GetsockoptTCPCCBBRInfo returns algorithm specific congestion control information for a socket using the "bbr" ++// algorithm. ++// ++// The socket's congestion control algorighm can be retrieved via [GetsockoptString] with the [TCP_CONGESTION] option: ++// ++// algo, err := unix.GetsockoptString(fd, unix.IPPROTO_TCP, unix.TCP_CONGESTION) ++func GetsockoptTCPCCBBRInfo(fd, level, opt int) (*TCPBBRInfo, error) { ++ var value [SizeofTCPCCInfo / 4]uint32 // ensure proper alignment ++ vallen := _Socklen(SizeofTCPCCInfo) ++ err := getsockopt(fd, level, opt, unsafe.Pointer(&value[0]), &vallen) ++ out := (*TCPBBRInfo)(unsafe.Pointer(&value[0])) ++ return out, err ++} ++ + // GetsockoptString returns the string value of the socket option opt for the + // socket associated with fd at the given socket level. + func GetsockoptString(fd, level, opt int) (string, error) { +@@ -1818,6 +1860,7 @@ func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err e + //sys ClockAdjtime(clockid int32, buf *Timex) (state int, err error) + //sys ClockGetres(clockid int32, res *Timespec) (err error) + //sys ClockGettime(clockid int32, time *Timespec) (err error) ++//sys ClockSettime(clockid int32, time *Timespec) (err error) + //sys ClockNanosleep(clockid int32, flags int, request *Timespec, remain *Timespec) (err error) + //sys Close(fd int) (err error) + //sys CloseRange(first uint, last uint, flags uint) (err error) +@@ -1959,7 +2002,26 @@ func Getpgrp() (pid int) { + //sysnb Getpid() (pid int) + //sysnb Getppid() (ppid int) + //sys Getpriority(which int, who int) (prio int, err error) +-//sys Getrandom(buf []byte, flags int) (n int, err error) ++ ++func Getrandom(buf []byte, flags int) (n int, err error) { ++ vdsoRet, supported := vgetrandom(buf, uint32(flags)) ++ if supported { ++ if vdsoRet < 0 { ++ return 0, errnoErr(syscall.Errno(-vdsoRet)) ++ } ++ return vdsoRet, nil ++ } ++ var p *byte ++ if len(buf) > 0 { ++ p = &buf[0] ++ } ++ r, _, e := Syscall(SYS_GETRANDOM, uintptr(unsafe.Pointer(p)), uintptr(len(buf)), uintptr(flags)) ++ if e != 0 { ++ return 0, errnoErr(e) ++ } ++ return int(r), nil ++} ++ + //sysnb Getrusage(who int, rusage *Rusage) (err error) + //sysnb Getsid(pid int) (sid int, err error) + //sysnb Gettid() (tid int) +diff --git a/vendor/golang.org/x/sys/unix/syscall_linux_arm64.go b/vendor/golang.org/x/sys/unix/syscall_linux_arm64.go +index cf2ee6c..745e5c7 100644 +--- a/vendor/golang.org/x/sys/unix/syscall_linux_arm64.go ++++ b/vendor/golang.org/x/sys/unix/syscall_linux_arm64.go +@@ -182,3 +182,5 @@ func KexecFileLoad(kernelFd int, initrdFd int, cmdline string, flags int) error + } + return kexecFileLoad(kernelFd, initrdFd, cmdlineLen, cmdline, flags) + } ++ ++const SYS_FSTATAT = SYS_NEWFSTATAT +diff --git a/vendor/golang.org/x/sys/unix/syscall_linux_loong64.go b/vendor/golang.org/x/sys/unix/syscall_linux_loong64.go +index 3d0e984..dd2262a 100644 +--- a/vendor/golang.org/x/sys/unix/syscall_linux_loong64.go ++++ b/vendor/golang.org/x/sys/unix/syscall_linux_loong64.go +@@ -214,3 +214,5 @@ func KexecFileLoad(kernelFd int, initrdFd int, cmdline string, flags int) error + } + return kexecFileLoad(kernelFd, initrdFd, cmdlineLen, cmdline, flags) + } ++ ++const SYS_FSTATAT = SYS_NEWFSTATAT +diff --git a/vendor/golang.org/x/sys/unix/syscall_linux_riscv64.go b/vendor/golang.org/x/sys/unix/syscall_linux_riscv64.go +index 6f5a288..8cf3670 100644 +--- a/vendor/golang.org/x/sys/unix/syscall_linux_riscv64.go ++++ b/vendor/golang.org/x/sys/unix/syscall_linux_riscv64.go +@@ -187,3 +187,5 @@ func RISCVHWProbe(pairs []RISCVHWProbePairs, set *CPUSet, flags uint) (err error + } + return riscvHWProbe(pairs, setSize, set, flags) + } ++ ++const SYS_FSTATAT = SYS_NEWFSTATAT +diff --git a/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go b/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go +index 312ae6a..7bf5c04 100644 +--- a/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go ++++ b/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go +@@ -768,6 +768,15 @@ func Munmap(b []byte) (err error) { + return mapper.Munmap(b) + } + ++func MmapPtr(fd int, offset int64, addr unsafe.Pointer, length uintptr, prot int, flags int) (ret unsafe.Pointer, err error) { ++ xaddr, err := mapper.mmap(uintptr(addr), length, prot, flags, fd, offset) ++ return unsafe.Pointer(xaddr), err ++} ++ ++func MunmapPtr(addr unsafe.Pointer, length uintptr) (err error) { ++ return mapper.munmap(uintptr(addr), length) ++} ++ + //sys Gethostname(buf []byte) (err error) = SYS___GETHOSTNAME_A + //sysnb Getgid() (gid int) + //sysnb Getpid() (pid int) +@@ -816,10 +825,10 @@ func Lstat(path string, stat *Stat_t) (err error) { + // for checking symlinks begins with $VERSION/ $SYSNAME/ $SYSSYMR/ $SYSSYMA/ + func isSpecialPath(path []byte) (v bool) { + var special = [4][8]byte{ +- [8]byte{'V', 'E', 'R', 'S', 'I', 'O', 'N', '/'}, +- [8]byte{'S', 'Y', 'S', 'N', 'A', 'M', 'E', '/'}, +- [8]byte{'S', 'Y', 'S', 'S', 'Y', 'M', 'R', '/'}, +- [8]byte{'S', 'Y', 'S', 'S', 'Y', 'M', 'A', '/'}} ++ {'V', 'E', 'R', 'S', 'I', 'O', 'N', '/'}, ++ {'S', 'Y', 'S', 'N', 'A', 'M', 'E', '/'}, ++ {'S', 'Y', 'S', 'S', 'Y', 'M', 'R', '/'}, ++ {'S', 'Y', 'S', 'S', 'Y', 'M', 'A', '/'}} + + var i, j int + for i = 0; i < len(special); i++ { +@@ -3115,3 +3124,90 @@ func legacy_Mkfifoat(dirfd int, path string, mode uint32) (err error) { + //sys Posix_openpt(oflag int) (fd int, err error) = SYS_POSIX_OPENPT + //sys Grantpt(fildes int) (rc int, err error) = SYS_GRANTPT + //sys Unlockpt(fildes int) (rc int, err error) = SYS_UNLOCKPT ++ ++func fcntlAsIs(fd uintptr, cmd int, arg uintptr) (val int, err error) { ++ runtime.EnterSyscall() ++ r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_FCNTL<<4, uintptr(fd), uintptr(cmd), arg) ++ runtime.ExitSyscall() ++ val = int(r0) ++ if int64(r0) == -1 { ++ err = errnoErr2(e1, e2) ++ } ++ return ++} ++ ++func Fcntl(fd uintptr, cmd int, op interface{}) (ret int, err error) { ++ switch op.(type) { ++ case *Flock_t: ++ err = FcntlFlock(fd, cmd, op.(*Flock_t)) ++ if err != nil { ++ ret = -1 ++ } ++ return ++ case int: ++ return FcntlInt(fd, cmd, op.(int)) ++ case *F_cnvrt: ++ return fcntlAsIs(fd, cmd, uintptr(unsafe.Pointer(op.(*F_cnvrt)))) ++ case unsafe.Pointer: ++ return fcntlAsIs(fd, cmd, uintptr(op.(unsafe.Pointer))) ++ default: ++ return -1, EINVAL ++ } ++ return ++} ++ ++func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) { ++ if raceenabled { ++ raceReleaseMerge(unsafe.Pointer(&ioSync)) ++ } ++ return sendfile(outfd, infd, offset, count) ++} ++ ++func sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) { ++ // TODO: use LE call instead if the call is implemented ++ originalOffset, err := Seek(infd, 0, SEEK_CUR) ++ if err != nil { ++ return -1, err ++ } ++ //start reading data from in_fd ++ if offset != nil { ++ _, err := Seek(infd, *offset, SEEK_SET) ++ if err != nil { ++ return -1, err ++ } ++ } ++ ++ buf := make([]byte, count) ++ readBuf := make([]byte, 0) ++ var n int = 0 ++ for i := 0; i < count; i += n { ++ n, err := Read(infd, buf) ++ if n == 0 { ++ if err != nil { ++ return -1, err ++ } else { // EOF ++ break ++ } ++ } ++ readBuf = append(readBuf, buf...) ++ buf = buf[0:0] ++ } ++ ++ n2, err := Write(outfd, readBuf) ++ if err != nil { ++ return -1, err ++ } ++ ++ //When sendfile() returns, this variable will be set to the ++ // offset of the byte following the last byte that was read. ++ if offset != nil { ++ *offset = *offset + int64(n) ++ // If offset is not NULL, then sendfile() does not modify the file ++ // offset of in_fd ++ _, err := Seek(infd, originalOffset, SEEK_SET) ++ if err != nil { ++ return -1, err ++ } ++ } ++ return n2, nil ++} +diff --git a/vendor/golang.org/x/sys/unix/vgetrandom_linux.go b/vendor/golang.org/x/sys/unix/vgetrandom_linux.go +new file mode 100644 +index 0000000..07ac8e0 +--- /dev/null ++++ b/vendor/golang.org/x/sys/unix/vgetrandom_linux.go +@@ -0,0 +1,13 @@ ++// Copyright 2024 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. ++ ++//go:build linux && go1.24 ++ ++package unix ++ ++import _ "unsafe" ++ ++//go:linkname vgetrandom runtime.vgetrandom ++//go:noescape ++func vgetrandom(p []byte, flags uint32) (ret int, supported bool) +diff --git a/vendor/golang.org/x/sys/unix/vgetrandom_unsupported.go b/vendor/golang.org/x/sys/unix/vgetrandom_unsupported.go +new file mode 100644 +index 0000000..297e97b +--- /dev/null ++++ b/vendor/golang.org/x/sys/unix/vgetrandom_unsupported.go +@@ -0,0 +1,11 @@ ++// Copyright 2024 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. ++ ++//go:build !linux || !go1.24 ++ ++package unix ++ ++func vgetrandom(p []byte, flags uint32) (ret int, supported bool) { ++ return -1, false ++} +diff --git a/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go b/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go +index 4308ac1..d73c465 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go +@@ -237,6 +237,9 @@ const ( + CLOCK_UPTIME_RAW_APPROX = 0x9 + CLONE_NOFOLLOW = 0x1 + CLONE_NOOWNERCOPY = 0x2 ++ CONNECT_DATA_AUTHENTICATED = 0x4 ++ CONNECT_DATA_IDEMPOTENT = 0x2 ++ CONNECT_RESUME_ON_READ_WRITE = 0x1 + CR0 = 0x0 + CR1 = 0x1000 + CR2 = 0x2000 +@@ -1265,6 +1268,10 @@ const ( + RTV_SSTHRESH = 0x20 + RUSAGE_CHILDREN = -0x1 + RUSAGE_SELF = 0x0 ++ SAE_ASSOCID_ALL = 0xffffffff ++ SAE_ASSOCID_ANY = 0x0 ++ SAE_CONNID_ALL = 0xffffffff ++ SAE_CONNID_ANY = 0x0 + SCM_CREDS = 0x3 + SCM_RIGHTS = 0x1 + SCM_TIMESTAMP = 0x2 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go b/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go +index c8068a7..4a55a40 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go +@@ -237,6 +237,9 @@ const ( + CLOCK_UPTIME_RAW_APPROX = 0x9 + CLONE_NOFOLLOW = 0x1 + CLONE_NOOWNERCOPY = 0x2 ++ CONNECT_DATA_AUTHENTICATED = 0x4 ++ CONNECT_DATA_IDEMPOTENT = 0x2 ++ CONNECT_RESUME_ON_READ_WRITE = 0x1 + CR0 = 0x0 + CR1 = 0x1000 + CR2 = 0x2000 +@@ -1265,6 +1268,10 @@ const ( + RTV_SSTHRESH = 0x20 + RUSAGE_CHILDREN = -0x1 + RUSAGE_SELF = 0x0 ++ SAE_ASSOCID_ALL = 0xffffffff ++ SAE_ASSOCID_ANY = 0x0 ++ SAE_CONNID_ALL = 0xffffffff ++ SAE_CONNID_ANY = 0x0 + SCM_CREDS = 0x3 + SCM_RIGHTS = 0x1 + SCM_TIMESTAMP = 0x2 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux.go b/vendor/golang.org/x/sys/unix/zerrors_linux.go +index 01a70b2..6ebc48b 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux.go +@@ -321,6 +321,9 @@ const ( + AUDIT_INTEGRITY_STATUS = 0x70a + AUDIT_IPC = 0x517 + AUDIT_IPC_SET_PERM = 0x51f ++ AUDIT_IPE_ACCESS = 0x58c ++ AUDIT_IPE_CONFIG_CHANGE = 0x58d ++ AUDIT_IPE_POLICY_LOAD = 0x58e + AUDIT_KERNEL = 0x7d0 + AUDIT_KERNEL_OTHER = 0x524 + AUDIT_KERN_MODULE = 0x532 +@@ -489,12 +492,14 @@ const ( + BPF_F_ID = 0x20 + BPF_F_NETFILTER_IP_DEFRAG = 0x1 + BPF_F_QUERY_EFFECTIVE = 0x1 ++ BPF_F_REDIRECT_FLAGS = 0x19 + BPF_F_REPLACE = 0x4 + BPF_F_SLEEPABLE = 0x10 + BPF_F_STRICT_ALIGNMENT = 0x1 + BPF_F_TEST_REG_INVARIANTS = 0x80 + BPF_F_TEST_RND_HI32 = 0x4 + BPF_F_TEST_RUN_ON_CPU = 0x1 ++ BPF_F_TEST_SKB_CHECKSUM_COMPLETE = 0x4 + BPF_F_TEST_STATE_FREQ = 0x8 + BPF_F_TEST_XDP_LIVE_FRAMES = 0x2 + BPF_F_XDP_DEV_BOUND_ONLY = 0x40 +@@ -1165,6 +1170,7 @@ const ( + EXTA = 0xe + EXTB = 0xf + F2FS_SUPER_MAGIC = 0xf2f52010 ++ FALLOC_FL_ALLOCATE_RANGE = 0x0 + FALLOC_FL_COLLAPSE_RANGE = 0x8 + FALLOC_FL_INSERT_RANGE = 0x20 + FALLOC_FL_KEEP_SIZE = 0x1 +@@ -1798,6 +1804,8 @@ const ( + LANDLOCK_ACCESS_NET_BIND_TCP = 0x1 + LANDLOCK_ACCESS_NET_CONNECT_TCP = 0x2 + LANDLOCK_CREATE_RULESET_VERSION = 0x1 ++ LANDLOCK_SCOPE_ABSTRACT_UNIX_SOCKET = 0x1 ++ LANDLOCK_SCOPE_SIGNAL = 0x2 + LINUX_REBOOT_CMD_CAD_OFF = 0x0 + LINUX_REBOOT_CMD_CAD_ON = 0x89abcdef + LINUX_REBOOT_CMD_HALT = 0xcdef0123 +@@ -1922,6 +1930,8 @@ const ( + MNT_EXPIRE = 0x4 + MNT_FORCE = 0x1 + MNT_ID_REQ_SIZE_VER0 = 0x18 ++ MNT_ID_REQ_SIZE_VER1 = 0x20 ++ MNT_NS_INFO_SIZE_VER0 = 0x10 + MODULE_INIT_COMPRESSED_FILE = 0x4 + MODULE_INIT_IGNORE_MODVERSIONS = 0x1 + MODULE_INIT_IGNORE_VERMAGIC = 0x2 +@@ -2187,7 +2197,7 @@ const ( + NFT_REG_SIZE = 0x10 + NFT_REJECT_ICMPX_MAX = 0x3 + NFT_RT_MAX = 0x4 +- NFT_SECMARK_CTX_MAXLEN = 0x100 ++ NFT_SECMARK_CTX_MAXLEN = 0x1000 + NFT_SET_MAXNAMELEN = 0x100 + NFT_SOCKET_MAX = 0x3 + NFT_TABLE_F_MASK = 0x7 +@@ -2356,9 +2366,11 @@ const ( + PERF_MEM_LVLNUM_IO = 0xa + PERF_MEM_LVLNUM_L1 = 0x1 + PERF_MEM_LVLNUM_L2 = 0x2 ++ PERF_MEM_LVLNUM_L2_MHB = 0x5 + PERF_MEM_LVLNUM_L3 = 0x3 + PERF_MEM_LVLNUM_L4 = 0x4 + PERF_MEM_LVLNUM_LFB = 0xc ++ PERF_MEM_LVLNUM_MSC = 0x6 + PERF_MEM_LVLNUM_NA = 0xf + PERF_MEM_LVLNUM_PMEM = 0xe + PERF_MEM_LVLNUM_RAM = 0xd +@@ -2431,6 +2443,7 @@ const ( + PRIO_PGRP = 0x1 + PRIO_PROCESS = 0x0 + PRIO_USER = 0x2 ++ PROCFS_IOCTL_MAGIC = 'f' + PROC_SUPER_MAGIC = 0x9fa0 + PROT_EXEC = 0x4 + PROT_GROWSDOWN = 0x1000000 +@@ -2620,6 +2633,28 @@ const ( + PR_UNALIGN_NOPRINT = 0x1 + PR_UNALIGN_SIGBUS = 0x2 + PSTOREFS_MAGIC = 0x6165676c ++ PTP_CLK_MAGIC = '=' ++ PTP_ENABLE_FEATURE = 0x1 ++ PTP_EXTTS_EDGES = 0x6 ++ PTP_EXTTS_EVENT_VALID = 0x1 ++ PTP_EXTTS_V1_VALID_FLAGS = 0x7 ++ PTP_EXTTS_VALID_FLAGS = 0x1f ++ PTP_EXT_OFFSET = 0x10 ++ PTP_FALLING_EDGE = 0x4 ++ PTP_MAX_SAMPLES = 0x19 ++ PTP_PEROUT_DUTY_CYCLE = 0x2 ++ PTP_PEROUT_ONE_SHOT = 0x1 ++ PTP_PEROUT_PHASE = 0x4 ++ PTP_PEROUT_V1_VALID_FLAGS = 0x0 ++ PTP_PEROUT_VALID_FLAGS = 0x7 ++ PTP_PIN_GETFUNC = 0xc0603d06 ++ PTP_PIN_GETFUNC2 = 0xc0603d0f ++ PTP_RISING_EDGE = 0x2 ++ PTP_STRICT_FLAGS = 0x8 ++ PTP_SYS_OFFSET_EXTENDED = 0xc4c03d09 ++ PTP_SYS_OFFSET_EXTENDED2 = 0xc4c03d12 ++ PTP_SYS_OFFSET_PRECISE = 0xc0403d08 ++ PTP_SYS_OFFSET_PRECISE2 = 0xc0403d11 + PTRACE_ATTACH = 0x10 + PTRACE_CONT = 0x7 + PTRACE_DETACH = 0x11 +@@ -2933,15 +2968,17 @@ const ( + RUSAGE_SELF = 0x0 + RUSAGE_THREAD = 0x1 + RWF_APPEND = 0x10 ++ RWF_ATOMIC = 0x40 + RWF_DSYNC = 0x2 + RWF_HIPRI = 0x1 + RWF_NOAPPEND = 0x20 + RWF_NOWAIT = 0x8 +- RWF_SUPPORTED = 0x3f ++ RWF_SUPPORTED = 0x7f + RWF_SYNC = 0x4 + RWF_WRITE_LIFE_NOT_SET = 0x0 + SCHED_BATCH = 0x3 + SCHED_DEADLINE = 0x6 ++ SCHED_EXT = 0x7 + SCHED_FIFO = 0x1 + SCHED_FLAG_ALL = 0x7f + SCHED_FLAG_DL_OVERRUN = 0x4 +@@ -3210,6 +3247,7 @@ const ( + STATX_ATTR_MOUNT_ROOT = 0x2000 + STATX_ATTR_NODUMP = 0x40 + STATX_ATTR_VERITY = 0x100000 ++ STATX_ATTR_WRITE_ATOMIC = 0x400000 + STATX_BASIC_STATS = 0x7ff + STATX_BLOCKS = 0x400 + STATX_BTIME = 0x800 +@@ -3226,6 +3264,7 @@ const ( + STATX_SUBVOL = 0x8000 + STATX_TYPE = 0x1 + STATX_UID = 0x8 ++ STATX_WRITE_ATOMIC = 0x10000 + STATX__RESERVED = 0x80000000 + SYNC_FILE_RANGE_WAIT_AFTER = 0x4 + SYNC_FILE_RANGE_WAIT_BEFORE = 0x1 +@@ -3624,6 +3663,7 @@ const ( + XDP_UMEM_PGOFF_COMPLETION_RING = 0x180000000 + XDP_UMEM_PGOFF_FILL_RING = 0x100000000 + XDP_UMEM_REG = 0x4 ++ XDP_UMEM_TX_METADATA_LEN = 0x4 + XDP_UMEM_TX_SW_CSUM = 0x2 + XDP_UMEM_UNALIGNED_CHUNK_FLAG = 0x1 + XDP_USE_NEED_WAKEUP = 0x8 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_386.go b/vendor/golang.org/x/sys/unix/zerrors_linux_386.go +index 684a516..c0d45e3 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_386.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_386.go +@@ -109,6 +109,7 @@ const ( + HIDIOCGRAWINFO = 0x80084803 + HIDIOCGRDESC = 0x90044802 + HIDIOCGRDESCSIZE = 0x80044801 ++ HIDIOCREVOKE = 0x4004480d + HUPCL = 0x400 + ICANON = 0x2 + IEXTEN = 0x8000 +@@ -153,9 +154,14 @@ const ( + NFDBITS = 0x20 + NLDLY = 0x100 + NOFLSH = 0x80 ++ NS_GET_MNTNS_ID = 0x8008b705 + NS_GET_NSTYPE = 0xb703 + NS_GET_OWNER_UID = 0xb704 + NS_GET_PARENT = 0xb702 ++ NS_GET_PID_FROM_PIDNS = 0x8004b706 ++ NS_GET_PID_IN_PIDNS = 0x8004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x8004b707 ++ NS_GET_TGID_IN_PIDNS = 0x8004b709 + NS_GET_USERNS = 0xb701 + OLCUC = 0x2 + ONLCR = 0x4 +@@ -232,6 +238,20 @@ const ( + PPPIOCUNBRIDGECHAN = 0x7434 + PPPIOCXFERUNIT = 0x744e + PR_SET_PTRACER_ANY = 0xffffffff ++ PTP_CLOCK_GETCAPS = 0x80503d01 ++ PTP_CLOCK_GETCAPS2 = 0x80503d0a ++ PTP_ENABLE_PPS = 0x40043d04 ++ PTP_ENABLE_PPS2 = 0x40043d0d ++ PTP_EXTTS_REQUEST = 0x40103d02 ++ PTP_EXTTS_REQUEST2 = 0x40103d0b ++ PTP_MASK_CLEAR_ALL = 0x3d13 ++ PTP_MASK_EN_SINGLE = 0x40043d14 ++ PTP_PEROUT_REQUEST = 0x40383d03 ++ PTP_PEROUT_REQUEST2 = 0x40383d0c ++ PTP_PIN_SETFUNC = 0x40603d07 ++ PTP_PIN_SETFUNC2 = 0x40603d10 ++ PTP_SYS_OFFSET = 0x43403d05 ++ PTP_SYS_OFFSET2 = 0x43403d0e + PTRACE_GETFPREGS = 0xe + PTRACE_GETFPXREGS = 0x12 + PTRACE_GET_THREAD_AREA = 0x19 +@@ -278,6 +298,8 @@ const ( + RTC_WIE_ON = 0x700f + RTC_WKALM_RD = 0x80287010 + RTC_WKALM_SET = 0x4028700f ++ SCM_DEVMEM_DMABUF = 0x4f ++ SCM_DEVMEM_LINEAR = 0x4e + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a +@@ -316,6 +338,9 @@ const ( + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DEVMEM_DMABUF = 0x4f ++ SO_DEVMEM_DONTNEED = 0x50 ++ SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x27 + SO_DONTROUTE = 0x5 + SO_ERROR = 0x4 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go +index 61d74b5..c731d24 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go +@@ -109,6 +109,7 @@ const ( + HIDIOCGRAWINFO = 0x80084803 + HIDIOCGRDESC = 0x90044802 + HIDIOCGRDESCSIZE = 0x80044801 ++ HIDIOCREVOKE = 0x4004480d + HUPCL = 0x400 + ICANON = 0x2 + IEXTEN = 0x8000 +@@ -153,9 +154,14 @@ const ( + NFDBITS = 0x40 + NLDLY = 0x100 + NOFLSH = 0x80 ++ NS_GET_MNTNS_ID = 0x8008b705 + NS_GET_NSTYPE = 0xb703 + NS_GET_OWNER_UID = 0xb704 + NS_GET_PARENT = 0xb702 ++ NS_GET_PID_FROM_PIDNS = 0x8004b706 ++ NS_GET_PID_IN_PIDNS = 0x8004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x8004b707 ++ NS_GET_TGID_IN_PIDNS = 0x8004b709 + NS_GET_USERNS = 0xb701 + OLCUC = 0x2 + ONLCR = 0x4 +@@ -232,6 +238,20 @@ const ( + PPPIOCUNBRIDGECHAN = 0x7434 + PPPIOCXFERUNIT = 0x744e + PR_SET_PTRACER_ANY = 0xffffffffffffffff ++ PTP_CLOCK_GETCAPS = 0x80503d01 ++ PTP_CLOCK_GETCAPS2 = 0x80503d0a ++ PTP_ENABLE_PPS = 0x40043d04 ++ PTP_ENABLE_PPS2 = 0x40043d0d ++ PTP_EXTTS_REQUEST = 0x40103d02 ++ PTP_EXTTS_REQUEST2 = 0x40103d0b ++ PTP_MASK_CLEAR_ALL = 0x3d13 ++ PTP_MASK_EN_SINGLE = 0x40043d14 ++ PTP_PEROUT_REQUEST = 0x40383d03 ++ PTP_PEROUT_REQUEST2 = 0x40383d0c ++ PTP_PIN_SETFUNC = 0x40603d07 ++ PTP_PIN_SETFUNC2 = 0x40603d10 ++ PTP_SYS_OFFSET = 0x43403d05 ++ PTP_SYS_OFFSET2 = 0x43403d0e + PTRACE_ARCH_PRCTL = 0x1e + PTRACE_GETFPREGS = 0xe + PTRACE_GETFPXREGS = 0x12 +@@ -279,6 +299,8 @@ const ( + RTC_WIE_ON = 0x700f + RTC_WKALM_RD = 0x80287010 + RTC_WKALM_SET = 0x4028700f ++ SCM_DEVMEM_DMABUF = 0x4f ++ SCM_DEVMEM_LINEAR = 0x4e + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a +@@ -317,6 +339,9 @@ const ( + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DEVMEM_DMABUF = 0x4f ++ SO_DEVMEM_DONTNEED = 0x50 ++ SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x27 + SO_DONTROUTE = 0x5 + SO_ERROR = 0x4 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go b/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go +index a28c9e3..680018a 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go +@@ -108,6 +108,7 @@ const ( + HIDIOCGRAWINFO = 0x80084803 + HIDIOCGRDESC = 0x90044802 + HIDIOCGRDESCSIZE = 0x80044801 ++ HIDIOCREVOKE = 0x4004480d + HUPCL = 0x400 + ICANON = 0x2 + IEXTEN = 0x8000 +@@ -150,9 +151,14 @@ const ( + NFDBITS = 0x20 + NLDLY = 0x100 + NOFLSH = 0x80 ++ NS_GET_MNTNS_ID = 0x8008b705 + NS_GET_NSTYPE = 0xb703 + NS_GET_OWNER_UID = 0xb704 + NS_GET_PARENT = 0xb702 ++ NS_GET_PID_FROM_PIDNS = 0x8004b706 ++ NS_GET_PID_IN_PIDNS = 0x8004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x8004b707 ++ NS_GET_TGID_IN_PIDNS = 0x8004b709 + NS_GET_USERNS = 0xb701 + OLCUC = 0x2 + ONLCR = 0x4 +@@ -229,6 +235,20 @@ const ( + PPPIOCUNBRIDGECHAN = 0x7434 + PPPIOCXFERUNIT = 0x744e + PR_SET_PTRACER_ANY = 0xffffffff ++ PTP_CLOCK_GETCAPS = 0x80503d01 ++ PTP_CLOCK_GETCAPS2 = 0x80503d0a ++ PTP_ENABLE_PPS = 0x40043d04 ++ PTP_ENABLE_PPS2 = 0x40043d0d ++ PTP_EXTTS_REQUEST = 0x40103d02 ++ PTP_EXTTS_REQUEST2 = 0x40103d0b ++ PTP_MASK_CLEAR_ALL = 0x3d13 ++ PTP_MASK_EN_SINGLE = 0x40043d14 ++ PTP_PEROUT_REQUEST = 0x40383d03 ++ PTP_PEROUT_REQUEST2 = 0x40383d0c ++ PTP_PIN_SETFUNC = 0x40603d07 ++ PTP_PIN_SETFUNC2 = 0x40603d10 ++ PTP_SYS_OFFSET = 0x43403d05 ++ PTP_SYS_OFFSET2 = 0x43403d0e + PTRACE_GETCRUNCHREGS = 0x19 + PTRACE_GETFDPIC = 0x1f + PTRACE_GETFDPIC_EXEC = 0x0 +@@ -284,6 +304,8 @@ const ( + RTC_WIE_ON = 0x700f + RTC_WKALM_RD = 0x80287010 + RTC_WKALM_SET = 0x4028700f ++ SCM_DEVMEM_DMABUF = 0x4f ++ SCM_DEVMEM_LINEAR = 0x4e + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a +@@ -322,6 +344,9 @@ const ( + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DEVMEM_DMABUF = 0x4f ++ SO_DEVMEM_DONTNEED = 0x50 ++ SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x27 + SO_DONTROUTE = 0x5 + SO_ERROR = 0x4 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go +index ab5d1fe..a63909f 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go +@@ -112,6 +112,7 @@ const ( + HIDIOCGRAWINFO = 0x80084803 + HIDIOCGRDESC = 0x90044802 + HIDIOCGRDESCSIZE = 0x80044801 ++ HIDIOCREVOKE = 0x4004480d + HUPCL = 0x400 + ICANON = 0x2 + IEXTEN = 0x8000 +@@ -154,9 +155,14 @@ const ( + NFDBITS = 0x40 + NLDLY = 0x100 + NOFLSH = 0x80 ++ NS_GET_MNTNS_ID = 0x8008b705 + NS_GET_NSTYPE = 0xb703 + NS_GET_OWNER_UID = 0xb704 + NS_GET_PARENT = 0xb702 ++ NS_GET_PID_FROM_PIDNS = 0x8004b706 ++ NS_GET_PID_IN_PIDNS = 0x8004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x8004b707 ++ NS_GET_TGID_IN_PIDNS = 0x8004b709 + NS_GET_USERNS = 0xb701 + OLCUC = 0x2 + ONLCR = 0x4 +@@ -200,6 +206,7 @@ const ( + PERF_EVENT_IOC_SET_BPF = 0x40042408 + PERF_EVENT_IOC_SET_FILTER = 0x40082406 + PERF_EVENT_IOC_SET_OUTPUT = 0x2405 ++ POE_MAGIC = 0x504f4530 + PPPIOCATTACH = 0x4004743d + PPPIOCATTCHAN = 0x40047438 + PPPIOCBRIDGECHAN = 0x40047435 +@@ -235,6 +242,20 @@ const ( + PROT_BTI = 0x10 + PROT_MTE = 0x20 + PR_SET_PTRACER_ANY = 0xffffffffffffffff ++ PTP_CLOCK_GETCAPS = 0x80503d01 ++ PTP_CLOCK_GETCAPS2 = 0x80503d0a ++ PTP_ENABLE_PPS = 0x40043d04 ++ PTP_ENABLE_PPS2 = 0x40043d0d ++ PTP_EXTTS_REQUEST = 0x40103d02 ++ PTP_EXTTS_REQUEST2 = 0x40103d0b ++ PTP_MASK_CLEAR_ALL = 0x3d13 ++ PTP_MASK_EN_SINGLE = 0x40043d14 ++ PTP_PEROUT_REQUEST = 0x40383d03 ++ PTP_PEROUT_REQUEST2 = 0x40383d0c ++ PTP_PIN_SETFUNC = 0x40603d07 ++ PTP_PIN_SETFUNC2 = 0x40603d10 ++ PTP_SYS_OFFSET = 0x43403d05 ++ PTP_SYS_OFFSET2 = 0x43403d0e + PTRACE_PEEKMTETAGS = 0x21 + PTRACE_POKEMTETAGS = 0x22 + PTRACE_SYSEMU = 0x1f +@@ -275,6 +296,8 @@ const ( + RTC_WIE_ON = 0x700f + RTC_WKALM_RD = 0x80287010 + RTC_WKALM_SET = 0x4028700f ++ SCM_DEVMEM_DMABUF = 0x4f ++ SCM_DEVMEM_LINEAR = 0x4e + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a +@@ -313,6 +336,9 @@ const ( + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DEVMEM_DMABUF = 0x4f ++ SO_DEVMEM_DONTNEED = 0x50 ++ SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x27 + SO_DONTROUTE = 0x5 + SO_ERROR = 0x4 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go +index c523090..9b0a257 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go +@@ -109,6 +109,7 @@ const ( + HIDIOCGRAWINFO = 0x80084803 + HIDIOCGRDESC = 0x90044802 + HIDIOCGRDESCSIZE = 0x80044801 ++ HIDIOCREVOKE = 0x4004480d + HUPCL = 0x400 + ICANON = 0x2 + IEXTEN = 0x8000 +@@ -154,9 +155,14 @@ const ( + NFDBITS = 0x40 + NLDLY = 0x100 + NOFLSH = 0x80 ++ NS_GET_MNTNS_ID = 0x8008b705 + NS_GET_NSTYPE = 0xb703 + NS_GET_OWNER_UID = 0xb704 + NS_GET_PARENT = 0xb702 ++ NS_GET_PID_FROM_PIDNS = 0x8004b706 ++ NS_GET_PID_IN_PIDNS = 0x8004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x8004b707 ++ NS_GET_TGID_IN_PIDNS = 0x8004b709 + NS_GET_USERNS = 0xb701 + OLCUC = 0x2 + ONLCR = 0x4 +@@ -233,6 +239,20 @@ const ( + PPPIOCUNBRIDGECHAN = 0x7434 + PPPIOCXFERUNIT = 0x744e + PR_SET_PTRACER_ANY = 0xffffffffffffffff ++ PTP_CLOCK_GETCAPS = 0x80503d01 ++ PTP_CLOCK_GETCAPS2 = 0x80503d0a ++ PTP_ENABLE_PPS = 0x40043d04 ++ PTP_ENABLE_PPS2 = 0x40043d0d ++ PTP_EXTTS_REQUEST = 0x40103d02 ++ PTP_EXTTS_REQUEST2 = 0x40103d0b ++ PTP_MASK_CLEAR_ALL = 0x3d13 ++ PTP_MASK_EN_SINGLE = 0x40043d14 ++ PTP_PEROUT_REQUEST = 0x40383d03 ++ PTP_PEROUT_REQUEST2 = 0x40383d0c ++ PTP_PIN_SETFUNC = 0x40603d07 ++ PTP_PIN_SETFUNC2 = 0x40603d10 ++ PTP_SYS_OFFSET = 0x43403d05 ++ PTP_SYS_OFFSET2 = 0x43403d0e + PTRACE_SYSEMU = 0x1f + PTRACE_SYSEMU_SINGLESTEP = 0x20 + RLIMIT_AS = 0x9 +@@ -271,6 +291,8 @@ const ( + RTC_WIE_ON = 0x700f + RTC_WKALM_RD = 0x80287010 + RTC_WKALM_SET = 0x4028700f ++ SCM_DEVMEM_DMABUF = 0x4f ++ SCM_DEVMEM_LINEAR = 0x4e + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a +@@ -309,6 +331,9 @@ const ( + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DEVMEM_DMABUF = 0x4f ++ SO_DEVMEM_DONTNEED = 0x50 ++ SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x27 + SO_DONTROUTE = 0x5 + SO_ERROR = 0x4 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go b/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go +index 01e6ea7..958e6e0 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go +@@ -108,6 +108,7 @@ const ( + HIDIOCGRAWINFO = 0x40084803 + HIDIOCGRDESC = 0x50044802 + HIDIOCGRDESCSIZE = 0x40044801 ++ HIDIOCREVOKE = 0x8004480d + HUPCL = 0x400 + ICANON = 0x2 + IEXTEN = 0x100 +@@ -150,9 +151,14 @@ const ( + NFDBITS = 0x20 + NLDLY = 0x100 + NOFLSH = 0x80 ++ NS_GET_MNTNS_ID = 0x4008b705 + NS_GET_NSTYPE = 0x2000b703 + NS_GET_OWNER_UID = 0x2000b704 + NS_GET_PARENT = 0x2000b702 ++ NS_GET_PID_FROM_PIDNS = 0x4004b706 ++ NS_GET_PID_IN_PIDNS = 0x4004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x4004b707 ++ NS_GET_TGID_IN_PIDNS = 0x4004b709 + NS_GET_USERNS = 0x2000b701 + OLCUC = 0x2 + ONLCR = 0x4 +@@ -229,6 +235,20 @@ const ( + PPPIOCUNBRIDGECHAN = 0x20007434 + PPPIOCXFERUNIT = 0x2000744e + PR_SET_PTRACER_ANY = 0xffffffff ++ PTP_CLOCK_GETCAPS = 0x40503d01 ++ PTP_CLOCK_GETCAPS2 = 0x40503d0a ++ PTP_ENABLE_PPS = 0x80043d04 ++ PTP_ENABLE_PPS2 = 0x80043d0d ++ PTP_EXTTS_REQUEST = 0x80103d02 ++ PTP_EXTTS_REQUEST2 = 0x80103d0b ++ PTP_MASK_CLEAR_ALL = 0x20003d13 ++ PTP_MASK_EN_SINGLE = 0x80043d14 ++ PTP_PEROUT_REQUEST = 0x80383d03 ++ PTP_PEROUT_REQUEST2 = 0x80383d0c ++ PTP_PIN_SETFUNC = 0x80603d07 ++ PTP_PIN_SETFUNC2 = 0x80603d10 ++ PTP_SYS_OFFSET = 0x83403d05 ++ PTP_SYS_OFFSET2 = 0x83403d0e + PTRACE_GETFPREGS = 0xe + PTRACE_GET_THREAD_AREA = 0x19 + PTRACE_GET_THREAD_AREA_3264 = 0xc4 +@@ -277,6 +297,8 @@ const ( + RTC_WIE_ON = 0x2000700f + RTC_WKALM_RD = 0x40287010 + RTC_WKALM_SET = 0x8028700f ++ SCM_DEVMEM_DMABUF = 0x4f ++ SCM_DEVMEM_LINEAR = 0x4e + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a +@@ -315,6 +337,9 @@ const ( + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DEVMEM_DMABUF = 0x4f ++ SO_DEVMEM_DONTNEED = 0x50 ++ SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x1029 + SO_DONTROUTE = 0x10 + SO_ERROR = 0x1007 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go +index 7aa610b..50c7f25 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go +@@ -108,6 +108,7 @@ const ( + HIDIOCGRAWINFO = 0x40084803 + HIDIOCGRDESC = 0x50044802 + HIDIOCGRDESCSIZE = 0x40044801 ++ HIDIOCREVOKE = 0x8004480d + HUPCL = 0x400 + ICANON = 0x2 + IEXTEN = 0x100 +@@ -150,9 +151,14 @@ const ( + NFDBITS = 0x40 + NLDLY = 0x100 + NOFLSH = 0x80 ++ NS_GET_MNTNS_ID = 0x4008b705 + NS_GET_NSTYPE = 0x2000b703 + NS_GET_OWNER_UID = 0x2000b704 + NS_GET_PARENT = 0x2000b702 ++ NS_GET_PID_FROM_PIDNS = 0x4004b706 ++ NS_GET_PID_IN_PIDNS = 0x4004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x4004b707 ++ NS_GET_TGID_IN_PIDNS = 0x4004b709 + NS_GET_USERNS = 0x2000b701 + OLCUC = 0x2 + ONLCR = 0x4 +@@ -229,6 +235,20 @@ const ( + PPPIOCUNBRIDGECHAN = 0x20007434 + PPPIOCXFERUNIT = 0x2000744e + PR_SET_PTRACER_ANY = 0xffffffffffffffff ++ PTP_CLOCK_GETCAPS = 0x40503d01 ++ PTP_CLOCK_GETCAPS2 = 0x40503d0a ++ PTP_ENABLE_PPS = 0x80043d04 ++ PTP_ENABLE_PPS2 = 0x80043d0d ++ PTP_EXTTS_REQUEST = 0x80103d02 ++ PTP_EXTTS_REQUEST2 = 0x80103d0b ++ PTP_MASK_CLEAR_ALL = 0x20003d13 ++ PTP_MASK_EN_SINGLE = 0x80043d14 ++ PTP_PEROUT_REQUEST = 0x80383d03 ++ PTP_PEROUT_REQUEST2 = 0x80383d0c ++ PTP_PIN_SETFUNC = 0x80603d07 ++ PTP_PIN_SETFUNC2 = 0x80603d10 ++ PTP_SYS_OFFSET = 0x83403d05 ++ PTP_SYS_OFFSET2 = 0x83403d0e + PTRACE_GETFPREGS = 0xe + PTRACE_GET_THREAD_AREA = 0x19 + PTRACE_GET_THREAD_AREA_3264 = 0xc4 +@@ -277,6 +297,8 @@ const ( + RTC_WIE_ON = 0x2000700f + RTC_WKALM_RD = 0x40287010 + RTC_WKALM_SET = 0x8028700f ++ SCM_DEVMEM_DMABUF = 0x4f ++ SCM_DEVMEM_LINEAR = 0x4e + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a +@@ -315,6 +337,9 @@ const ( + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DEVMEM_DMABUF = 0x4f ++ SO_DEVMEM_DONTNEED = 0x50 ++ SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x1029 + SO_DONTROUTE = 0x10 + SO_ERROR = 0x1007 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go b/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go +index 92af771..ced21d6 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go +@@ -108,6 +108,7 @@ const ( + HIDIOCGRAWINFO = 0x40084803 + HIDIOCGRDESC = 0x50044802 + HIDIOCGRDESCSIZE = 0x40044801 ++ HIDIOCREVOKE = 0x8004480d + HUPCL = 0x400 + ICANON = 0x2 + IEXTEN = 0x100 +@@ -150,9 +151,14 @@ const ( + NFDBITS = 0x40 + NLDLY = 0x100 + NOFLSH = 0x80 ++ NS_GET_MNTNS_ID = 0x4008b705 + NS_GET_NSTYPE = 0x2000b703 + NS_GET_OWNER_UID = 0x2000b704 + NS_GET_PARENT = 0x2000b702 ++ NS_GET_PID_FROM_PIDNS = 0x4004b706 ++ NS_GET_PID_IN_PIDNS = 0x4004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x4004b707 ++ NS_GET_TGID_IN_PIDNS = 0x4004b709 + NS_GET_USERNS = 0x2000b701 + OLCUC = 0x2 + ONLCR = 0x4 +@@ -229,6 +235,20 @@ const ( + PPPIOCUNBRIDGECHAN = 0x20007434 + PPPIOCXFERUNIT = 0x2000744e + PR_SET_PTRACER_ANY = 0xffffffffffffffff ++ PTP_CLOCK_GETCAPS = 0x40503d01 ++ PTP_CLOCK_GETCAPS2 = 0x40503d0a ++ PTP_ENABLE_PPS = 0x80043d04 ++ PTP_ENABLE_PPS2 = 0x80043d0d ++ PTP_EXTTS_REQUEST = 0x80103d02 ++ PTP_EXTTS_REQUEST2 = 0x80103d0b ++ PTP_MASK_CLEAR_ALL = 0x20003d13 ++ PTP_MASK_EN_SINGLE = 0x80043d14 ++ PTP_PEROUT_REQUEST = 0x80383d03 ++ PTP_PEROUT_REQUEST2 = 0x80383d0c ++ PTP_PIN_SETFUNC = 0x80603d07 ++ PTP_PIN_SETFUNC2 = 0x80603d10 ++ PTP_SYS_OFFSET = 0x83403d05 ++ PTP_SYS_OFFSET2 = 0x83403d0e + PTRACE_GETFPREGS = 0xe + PTRACE_GET_THREAD_AREA = 0x19 + PTRACE_GET_THREAD_AREA_3264 = 0xc4 +@@ -277,6 +297,8 @@ const ( + RTC_WIE_ON = 0x2000700f + RTC_WKALM_RD = 0x40287010 + RTC_WKALM_SET = 0x8028700f ++ SCM_DEVMEM_DMABUF = 0x4f ++ SCM_DEVMEM_LINEAR = 0x4e + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a +@@ -315,6 +337,9 @@ const ( + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DEVMEM_DMABUF = 0x4f ++ SO_DEVMEM_DONTNEED = 0x50 ++ SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x1029 + SO_DONTROUTE = 0x10 + SO_ERROR = 0x1007 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go b/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go +index b27ef5e..226c044 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go +@@ -108,6 +108,7 @@ const ( + HIDIOCGRAWINFO = 0x40084803 + HIDIOCGRDESC = 0x50044802 + HIDIOCGRDESCSIZE = 0x40044801 ++ HIDIOCREVOKE = 0x8004480d + HUPCL = 0x400 + ICANON = 0x2 + IEXTEN = 0x100 +@@ -150,9 +151,14 @@ const ( + NFDBITS = 0x20 + NLDLY = 0x100 + NOFLSH = 0x80 ++ NS_GET_MNTNS_ID = 0x4008b705 + NS_GET_NSTYPE = 0x2000b703 + NS_GET_OWNER_UID = 0x2000b704 + NS_GET_PARENT = 0x2000b702 ++ NS_GET_PID_FROM_PIDNS = 0x4004b706 ++ NS_GET_PID_IN_PIDNS = 0x4004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x4004b707 ++ NS_GET_TGID_IN_PIDNS = 0x4004b709 + NS_GET_USERNS = 0x2000b701 + OLCUC = 0x2 + ONLCR = 0x4 +@@ -229,6 +235,20 @@ const ( + PPPIOCUNBRIDGECHAN = 0x20007434 + PPPIOCXFERUNIT = 0x2000744e + PR_SET_PTRACER_ANY = 0xffffffff ++ PTP_CLOCK_GETCAPS = 0x40503d01 ++ PTP_CLOCK_GETCAPS2 = 0x40503d0a ++ PTP_ENABLE_PPS = 0x80043d04 ++ PTP_ENABLE_PPS2 = 0x80043d0d ++ PTP_EXTTS_REQUEST = 0x80103d02 ++ PTP_EXTTS_REQUEST2 = 0x80103d0b ++ PTP_MASK_CLEAR_ALL = 0x20003d13 ++ PTP_MASK_EN_SINGLE = 0x80043d14 ++ PTP_PEROUT_REQUEST = 0x80383d03 ++ PTP_PEROUT_REQUEST2 = 0x80383d0c ++ PTP_PIN_SETFUNC = 0x80603d07 ++ PTP_PIN_SETFUNC2 = 0x80603d10 ++ PTP_SYS_OFFSET = 0x83403d05 ++ PTP_SYS_OFFSET2 = 0x83403d0e + PTRACE_GETFPREGS = 0xe + PTRACE_GET_THREAD_AREA = 0x19 + PTRACE_GET_THREAD_AREA_3264 = 0xc4 +@@ -277,6 +297,8 @@ const ( + RTC_WIE_ON = 0x2000700f + RTC_WKALM_RD = 0x40287010 + RTC_WKALM_SET = 0x8028700f ++ SCM_DEVMEM_DMABUF = 0x4f ++ SCM_DEVMEM_LINEAR = 0x4e + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a +@@ -315,6 +337,9 @@ const ( + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DEVMEM_DMABUF = 0x4f ++ SO_DEVMEM_DONTNEED = 0x50 ++ SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x1029 + SO_DONTROUTE = 0x10 + SO_ERROR = 0x1007 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go +index 237a2ce..3122737 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go +@@ -108,6 +108,7 @@ const ( + HIDIOCGRAWINFO = 0x40084803 + HIDIOCGRDESC = 0x50044802 + HIDIOCGRDESCSIZE = 0x40044801 ++ HIDIOCREVOKE = 0x8004480d + HUPCL = 0x4000 + ICANON = 0x100 + IEXTEN = 0x400 +@@ -152,9 +153,14 @@ const ( + NL3 = 0x300 + NLDLY = 0x300 + NOFLSH = 0x80000000 ++ NS_GET_MNTNS_ID = 0x4008b705 + NS_GET_NSTYPE = 0x2000b703 + NS_GET_OWNER_UID = 0x2000b704 + NS_GET_PARENT = 0x2000b702 ++ NS_GET_PID_FROM_PIDNS = 0x4004b706 ++ NS_GET_PID_IN_PIDNS = 0x4004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x4004b707 ++ NS_GET_TGID_IN_PIDNS = 0x4004b709 + NS_GET_USERNS = 0x2000b701 + OLCUC = 0x4 + ONLCR = 0x2 +@@ -232,6 +238,20 @@ const ( + PPPIOCXFERUNIT = 0x2000744e + PROT_SAO = 0x10 + PR_SET_PTRACER_ANY = 0xffffffff ++ PTP_CLOCK_GETCAPS = 0x40503d01 ++ PTP_CLOCK_GETCAPS2 = 0x40503d0a ++ PTP_ENABLE_PPS = 0x80043d04 ++ PTP_ENABLE_PPS2 = 0x80043d0d ++ PTP_EXTTS_REQUEST = 0x80103d02 ++ PTP_EXTTS_REQUEST2 = 0x80103d0b ++ PTP_MASK_CLEAR_ALL = 0x20003d13 ++ PTP_MASK_EN_SINGLE = 0x80043d14 ++ PTP_PEROUT_REQUEST = 0x80383d03 ++ PTP_PEROUT_REQUEST2 = 0x80383d0c ++ PTP_PIN_SETFUNC = 0x80603d07 ++ PTP_PIN_SETFUNC2 = 0x80603d10 ++ PTP_SYS_OFFSET = 0x83403d05 ++ PTP_SYS_OFFSET2 = 0x83403d0e + PTRACE_GETEVRREGS = 0x14 + PTRACE_GETFPREGS = 0xe + PTRACE_GETREGS64 = 0x16 +@@ -332,6 +352,8 @@ const ( + RTC_WIE_ON = 0x2000700f + RTC_WKALM_RD = 0x40287010 + RTC_WKALM_SET = 0x8028700f ++ SCM_DEVMEM_DMABUF = 0x4f ++ SCM_DEVMEM_LINEAR = 0x4e + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a +@@ -370,6 +392,9 @@ const ( + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DEVMEM_DMABUF = 0x4f ++ SO_DEVMEM_DONTNEED = 0x50 ++ SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x27 + SO_DONTROUTE = 0x5 + SO_ERROR = 0x4 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go +index 4a5c555..eb5d346 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go +@@ -108,6 +108,7 @@ const ( + HIDIOCGRAWINFO = 0x40084803 + HIDIOCGRDESC = 0x50044802 + HIDIOCGRDESCSIZE = 0x40044801 ++ HIDIOCREVOKE = 0x8004480d + HUPCL = 0x4000 + ICANON = 0x100 + IEXTEN = 0x400 +@@ -152,9 +153,14 @@ const ( + NL3 = 0x300 + NLDLY = 0x300 + NOFLSH = 0x80000000 ++ NS_GET_MNTNS_ID = 0x4008b705 + NS_GET_NSTYPE = 0x2000b703 + NS_GET_OWNER_UID = 0x2000b704 + NS_GET_PARENT = 0x2000b702 ++ NS_GET_PID_FROM_PIDNS = 0x4004b706 ++ NS_GET_PID_IN_PIDNS = 0x4004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x4004b707 ++ NS_GET_TGID_IN_PIDNS = 0x4004b709 + NS_GET_USERNS = 0x2000b701 + OLCUC = 0x4 + ONLCR = 0x2 +@@ -232,6 +238,20 @@ const ( + PPPIOCXFERUNIT = 0x2000744e + PROT_SAO = 0x10 + PR_SET_PTRACER_ANY = 0xffffffffffffffff ++ PTP_CLOCK_GETCAPS = 0x40503d01 ++ PTP_CLOCK_GETCAPS2 = 0x40503d0a ++ PTP_ENABLE_PPS = 0x80043d04 ++ PTP_ENABLE_PPS2 = 0x80043d0d ++ PTP_EXTTS_REQUEST = 0x80103d02 ++ PTP_EXTTS_REQUEST2 = 0x80103d0b ++ PTP_MASK_CLEAR_ALL = 0x20003d13 ++ PTP_MASK_EN_SINGLE = 0x80043d14 ++ PTP_PEROUT_REQUEST = 0x80383d03 ++ PTP_PEROUT_REQUEST2 = 0x80383d0c ++ PTP_PIN_SETFUNC = 0x80603d07 ++ PTP_PIN_SETFUNC2 = 0x80603d10 ++ PTP_SYS_OFFSET = 0x83403d05 ++ PTP_SYS_OFFSET2 = 0x83403d0e + PTRACE_GETEVRREGS = 0x14 + PTRACE_GETFPREGS = 0xe + PTRACE_GETREGS64 = 0x16 +@@ -336,6 +356,8 @@ const ( + RTC_WIE_ON = 0x2000700f + RTC_WKALM_RD = 0x40287010 + RTC_WKALM_SET = 0x8028700f ++ SCM_DEVMEM_DMABUF = 0x4f ++ SCM_DEVMEM_LINEAR = 0x4e + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a +@@ -374,6 +396,9 @@ const ( + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DEVMEM_DMABUF = 0x4f ++ SO_DEVMEM_DONTNEED = 0x50 ++ SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x27 + SO_DONTROUTE = 0x5 + SO_ERROR = 0x4 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go +index a02fb49..e921ebc 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go +@@ -108,6 +108,7 @@ const ( + HIDIOCGRAWINFO = 0x40084803 + HIDIOCGRDESC = 0x50044802 + HIDIOCGRDESCSIZE = 0x40044801 ++ HIDIOCREVOKE = 0x8004480d + HUPCL = 0x4000 + ICANON = 0x100 + IEXTEN = 0x400 +@@ -152,9 +153,14 @@ const ( + NL3 = 0x300 + NLDLY = 0x300 + NOFLSH = 0x80000000 ++ NS_GET_MNTNS_ID = 0x4008b705 + NS_GET_NSTYPE = 0x2000b703 + NS_GET_OWNER_UID = 0x2000b704 + NS_GET_PARENT = 0x2000b702 ++ NS_GET_PID_FROM_PIDNS = 0x4004b706 ++ NS_GET_PID_IN_PIDNS = 0x4004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x4004b707 ++ NS_GET_TGID_IN_PIDNS = 0x4004b709 + NS_GET_USERNS = 0x2000b701 + OLCUC = 0x4 + ONLCR = 0x2 +@@ -232,6 +238,20 @@ const ( + PPPIOCXFERUNIT = 0x2000744e + PROT_SAO = 0x10 + PR_SET_PTRACER_ANY = 0xffffffffffffffff ++ PTP_CLOCK_GETCAPS = 0x40503d01 ++ PTP_CLOCK_GETCAPS2 = 0x40503d0a ++ PTP_ENABLE_PPS = 0x80043d04 ++ PTP_ENABLE_PPS2 = 0x80043d0d ++ PTP_EXTTS_REQUEST = 0x80103d02 ++ PTP_EXTTS_REQUEST2 = 0x80103d0b ++ PTP_MASK_CLEAR_ALL = 0x20003d13 ++ PTP_MASK_EN_SINGLE = 0x80043d14 ++ PTP_PEROUT_REQUEST = 0x80383d03 ++ PTP_PEROUT_REQUEST2 = 0x80383d0c ++ PTP_PIN_SETFUNC = 0x80603d07 ++ PTP_PIN_SETFUNC2 = 0x80603d10 ++ PTP_SYS_OFFSET = 0x83403d05 ++ PTP_SYS_OFFSET2 = 0x83403d0e + PTRACE_GETEVRREGS = 0x14 + PTRACE_GETFPREGS = 0xe + PTRACE_GETREGS64 = 0x16 +@@ -336,6 +356,8 @@ const ( + RTC_WIE_ON = 0x2000700f + RTC_WKALM_RD = 0x40287010 + RTC_WKALM_SET = 0x8028700f ++ SCM_DEVMEM_DMABUF = 0x4f ++ SCM_DEVMEM_LINEAR = 0x4e + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a +@@ -374,6 +396,9 @@ const ( + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DEVMEM_DMABUF = 0x4f ++ SO_DEVMEM_DONTNEED = 0x50 ++ SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x27 + SO_DONTROUTE = 0x5 + SO_ERROR = 0x4 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go +index e26a7c6..38ba81c 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go +@@ -108,6 +108,7 @@ const ( + HIDIOCGRAWINFO = 0x80084803 + HIDIOCGRDESC = 0x90044802 + HIDIOCGRDESCSIZE = 0x80044801 ++ HIDIOCREVOKE = 0x4004480d + HUPCL = 0x400 + ICANON = 0x2 + IEXTEN = 0x8000 +@@ -150,9 +151,14 @@ const ( + NFDBITS = 0x40 + NLDLY = 0x100 + NOFLSH = 0x80 ++ NS_GET_MNTNS_ID = 0x8008b705 + NS_GET_NSTYPE = 0xb703 + NS_GET_OWNER_UID = 0xb704 + NS_GET_PARENT = 0xb702 ++ NS_GET_PID_FROM_PIDNS = 0x8004b706 ++ NS_GET_PID_IN_PIDNS = 0x8004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x8004b707 ++ NS_GET_TGID_IN_PIDNS = 0x8004b709 + NS_GET_USERNS = 0xb701 + OLCUC = 0x2 + ONLCR = 0x4 +@@ -229,6 +235,20 @@ const ( + PPPIOCUNBRIDGECHAN = 0x7434 + PPPIOCXFERUNIT = 0x744e + PR_SET_PTRACER_ANY = 0xffffffffffffffff ++ PTP_CLOCK_GETCAPS = 0x80503d01 ++ PTP_CLOCK_GETCAPS2 = 0x80503d0a ++ PTP_ENABLE_PPS = 0x40043d04 ++ PTP_ENABLE_PPS2 = 0x40043d0d ++ PTP_EXTTS_REQUEST = 0x40103d02 ++ PTP_EXTTS_REQUEST2 = 0x40103d0b ++ PTP_MASK_CLEAR_ALL = 0x3d13 ++ PTP_MASK_EN_SINGLE = 0x40043d14 ++ PTP_PEROUT_REQUEST = 0x40383d03 ++ PTP_PEROUT_REQUEST2 = 0x40383d0c ++ PTP_PIN_SETFUNC = 0x40603d07 ++ PTP_PIN_SETFUNC2 = 0x40603d10 ++ PTP_SYS_OFFSET = 0x43403d05 ++ PTP_SYS_OFFSET2 = 0x43403d0e + PTRACE_GETFDPIC = 0x21 + PTRACE_GETFDPIC_EXEC = 0x0 + PTRACE_GETFDPIC_INTERP = 0x1 +@@ -268,6 +288,8 @@ const ( + RTC_WIE_ON = 0x700f + RTC_WKALM_RD = 0x80287010 + RTC_WKALM_SET = 0x4028700f ++ SCM_DEVMEM_DMABUF = 0x4f ++ SCM_DEVMEM_LINEAR = 0x4e + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a +@@ -306,6 +328,9 @@ const ( + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DEVMEM_DMABUF = 0x4f ++ SO_DEVMEM_DONTNEED = 0x50 ++ SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x27 + SO_DONTROUTE = 0x5 + SO_ERROR = 0x4 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go b/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go +index c48f7c2..71f0400 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go +@@ -108,6 +108,7 @@ const ( + HIDIOCGRAWINFO = 0x80084803 + HIDIOCGRDESC = 0x90044802 + HIDIOCGRDESCSIZE = 0x80044801 ++ HIDIOCREVOKE = 0x4004480d + HUPCL = 0x400 + ICANON = 0x2 + IEXTEN = 0x8000 +@@ -150,9 +151,14 @@ const ( + NFDBITS = 0x40 + NLDLY = 0x100 + NOFLSH = 0x80 ++ NS_GET_MNTNS_ID = 0x8008b705 + NS_GET_NSTYPE = 0xb703 + NS_GET_OWNER_UID = 0xb704 + NS_GET_PARENT = 0xb702 ++ NS_GET_PID_FROM_PIDNS = 0x8004b706 ++ NS_GET_PID_IN_PIDNS = 0x8004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x8004b707 ++ NS_GET_TGID_IN_PIDNS = 0x8004b709 + NS_GET_USERNS = 0xb701 + OLCUC = 0x2 + ONLCR = 0x4 +@@ -229,6 +235,20 @@ const ( + PPPIOCUNBRIDGECHAN = 0x7434 + PPPIOCXFERUNIT = 0x744e + PR_SET_PTRACER_ANY = 0xffffffffffffffff ++ PTP_CLOCK_GETCAPS = 0x80503d01 ++ PTP_CLOCK_GETCAPS2 = 0x80503d0a ++ PTP_ENABLE_PPS = 0x40043d04 ++ PTP_ENABLE_PPS2 = 0x40043d0d ++ PTP_EXTTS_REQUEST = 0x40103d02 ++ PTP_EXTTS_REQUEST2 = 0x40103d0b ++ PTP_MASK_CLEAR_ALL = 0x3d13 ++ PTP_MASK_EN_SINGLE = 0x40043d14 ++ PTP_PEROUT_REQUEST = 0x40383d03 ++ PTP_PEROUT_REQUEST2 = 0x40383d0c ++ PTP_PIN_SETFUNC = 0x40603d07 ++ PTP_PIN_SETFUNC2 = 0x40603d10 ++ PTP_SYS_OFFSET = 0x43403d05 ++ PTP_SYS_OFFSET2 = 0x43403d0e + PTRACE_DISABLE_TE = 0x5010 + PTRACE_ENABLE_TE = 0x5009 + PTRACE_GET_LAST_BREAK = 0x5006 +@@ -340,6 +360,8 @@ const ( + RTC_WIE_ON = 0x700f + RTC_WKALM_RD = 0x80287010 + RTC_WKALM_SET = 0x4028700f ++ SCM_DEVMEM_DMABUF = 0x4f ++ SCM_DEVMEM_LINEAR = 0x4e + SCM_TIMESTAMPING = 0x25 + SCM_TIMESTAMPING_OPT_STATS = 0x36 + SCM_TIMESTAMPING_PKTINFO = 0x3a +@@ -378,6 +400,9 @@ const ( + SO_CNX_ADVICE = 0x35 + SO_COOKIE = 0x39 + SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DEVMEM_DMABUF = 0x4f ++ SO_DEVMEM_DONTNEED = 0x50 ++ SO_DEVMEM_LINEAR = 0x4e + SO_DOMAIN = 0x27 + SO_DONTROUTE = 0x5 + SO_ERROR = 0x4 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go +index ad4b9aa..c44a313 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go +@@ -112,6 +112,7 @@ const ( + HIDIOCGRAWINFO = 0x40084803 + HIDIOCGRDESC = 0x50044802 + HIDIOCGRDESCSIZE = 0x40044801 ++ HIDIOCREVOKE = 0x8004480d + HUPCL = 0x400 + ICANON = 0x2 + IEXTEN = 0x8000 +@@ -155,9 +156,14 @@ const ( + NFDBITS = 0x40 + NLDLY = 0x100 + NOFLSH = 0x80 ++ NS_GET_MNTNS_ID = 0x4008b705 + NS_GET_NSTYPE = 0x2000b703 + NS_GET_OWNER_UID = 0x2000b704 + NS_GET_PARENT = 0x2000b702 ++ NS_GET_PID_FROM_PIDNS = 0x4004b706 ++ NS_GET_PID_IN_PIDNS = 0x4004b708 ++ NS_GET_TGID_FROM_PIDNS = 0x4004b707 ++ NS_GET_TGID_IN_PIDNS = 0x4004b709 + NS_GET_USERNS = 0x2000b701 + OLCUC = 0x2 + ONLCR = 0x4 +@@ -234,6 +240,20 @@ const ( + PPPIOCUNBRIDGECHAN = 0x20007434 + PPPIOCXFERUNIT = 0x2000744e + PR_SET_PTRACER_ANY = 0xffffffffffffffff ++ PTP_CLOCK_GETCAPS = 0x40503d01 ++ PTP_CLOCK_GETCAPS2 = 0x40503d0a ++ PTP_ENABLE_PPS = 0x80043d04 ++ PTP_ENABLE_PPS2 = 0x80043d0d ++ PTP_EXTTS_REQUEST = 0x80103d02 ++ PTP_EXTTS_REQUEST2 = 0x80103d0b ++ PTP_MASK_CLEAR_ALL = 0x20003d13 ++ PTP_MASK_EN_SINGLE = 0x80043d14 ++ PTP_PEROUT_REQUEST = 0x80383d03 ++ PTP_PEROUT_REQUEST2 = 0x80383d0c ++ PTP_PIN_SETFUNC = 0x80603d07 ++ PTP_PIN_SETFUNC2 = 0x80603d10 ++ PTP_SYS_OFFSET = 0x83403d05 ++ PTP_SYS_OFFSET2 = 0x83403d0e + PTRACE_GETFPAREGS = 0x14 + PTRACE_GETFPREGS = 0xe + PTRACE_GETFPREGS64 = 0x19 +@@ -331,6 +351,8 @@ const ( + RTC_WIE_ON = 0x2000700f + RTC_WKALM_RD = 0x40287010 + RTC_WKALM_SET = 0x8028700f ++ SCM_DEVMEM_DMABUF = 0x58 ++ SCM_DEVMEM_LINEAR = 0x57 + SCM_TIMESTAMPING = 0x23 + SCM_TIMESTAMPING_OPT_STATS = 0x38 + SCM_TIMESTAMPING_PKTINFO = 0x3c +@@ -417,6 +439,9 @@ const ( + SO_CNX_ADVICE = 0x37 + SO_COOKIE = 0x3b + SO_DETACH_REUSEPORT_BPF = 0x47 ++ SO_DEVMEM_DMABUF = 0x58 ++ SO_DEVMEM_DONTNEED = 0x59 ++ SO_DEVMEM_LINEAR = 0x57 + SO_DOMAIN = 0x1029 + SO_DONTROUTE = 0x10 + SO_ERROR = 0x1007 +diff --git a/vendor/golang.org/x/sys/unix/zerrors_zos_s390x.go b/vendor/golang.org/x/sys/unix/zerrors_zos_s390x.go +index da08b2a..1ec2b14 100644 +--- a/vendor/golang.org/x/sys/unix/zerrors_zos_s390x.go ++++ b/vendor/golang.org/x/sys/unix/zerrors_zos_s390x.go +@@ -581,6 +581,8 @@ const ( + AT_EMPTY_PATH = 0x1000 + AT_REMOVEDIR = 0x200 + RENAME_NOREPLACE = 1 << 0 ++ ST_RDONLY = 1 ++ ST_NOSUID = 2 + ) + + const ( +diff --git a/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go b/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go +index b622533..24b346e 100644 +--- a/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go ++++ b/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go +@@ -841,6 +841,26 @@ var libc_pthread_fchdir_np_trampoline_addr uintptr + + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + ++func connectx(fd int, endpoints *SaEndpoints, associd SaeAssocID, flags uint32, iov []Iovec, n *uintptr, connid *SaeConnID) (err error) { ++ var _p0 unsafe.Pointer ++ if len(iov) > 0 { ++ _p0 = unsafe.Pointer(&iov[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ _, _, e1 := syscall_syscall9(libc_connectx_trampoline_addr, uintptr(fd), uintptr(unsafe.Pointer(endpoints)), uintptr(associd), uintptr(flags), uintptr(_p0), uintptr(len(iov)), uintptr(unsafe.Pointer(n)), uintptr(unsafe.Pointer(connid)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++var libc_connectx_trampoline_addr uintptr ++ ++//go:cgo_import_dynamic libc_connectx connectx "/usr/lib/libSystem.B.dylib" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ + func sendfile(infd int, outfd int, offset int64, len *int64, hdtr unsafe.Pointer, flags int) (err error) { + _, _, e1 := syscall_syscall6(libc_sendfile_trampoline_addr, uintptr(infd), uintptr(outfd), uintptr(offset), uintptr(unsafe.Pointer(len)), uintptr(hdtr), uintptr(flags)) + if e1 != 0 { +diff --git a/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.s b/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.s +index cfe6646..ebd2131 100644 +--- a/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.s ++++ b/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.s +@@ -248,6 +248,11 @@ TEXT libc_pthread_fchdir_np_trampoline<>(SB),NOSPLIT,$0-0 + GLOBL ·libc_pthread_fchdir_np_trampoline_addr(SB), RODATA, $8 + DATA ·libc_pthread_fchdir_np_trampoline_addr(SB)/8, $libc_pthread_fchdir_np_trampoline<>(SB) + ++TEXT libc_connectx_trampoline<>(SB),NOSPLIT,$0-0 ++ JMP libc_connectx(SB) ++GLOBL ·libc_connectx_trampoline_addr(SB), RODATA, $8 ++DATA ·libc_connectx_trampoline_addr(SB)/8, $libc_connectx_trampoline<>(SB) ++ + TEXT libc_sendfile_trampoline<>(SB),NOSPLIT,$0-0 + JMP libc_sendfile(SB) + GLOBL ·libc_sendfile_trampoline_addr(SB), RODATA, $8 +diff --git a/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go b/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go +index 13f624f..824b9c2 100644 +--- a/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go ++++ b/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go +@@ -841,6 +841,26 @@ var libc_pthread_fchdir_np_trampoline_addr uintptr + + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + ++func connectx(fd int, endpoints *SaEndpoints, associd SaeAssocID, flags uint32, iov []Iovec, n *uintptr, connid *SaeConnID) (err error) { ++ var _p0 unsafe.Pointer ++ if len(iov) > 0 { ++ _p0 = unsafe.Pointer(&iov[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ _, _, e1 := syscall_syscall9(libc_connectx_trampoline_addr, uintptr(fd), uintptr(unsafe.Pointer(endpoints)), uintptr(associd), uintptr(flags), uintptr(_p0), uintptr(len(iov)), uintptr(unsafe.Pointer(n)), uintptr(unsafe.Pointer(connid)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++var libc_connectx_trampoline_addr uintptr ++ ++//go:cgo_import_dynamic libc_connectx connectx "/usr/lib/libSystem.B.dylib" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ + func sendfile(infd int, outfd int, offset int64, len *int64, hdtr unsafe.Pointer, flags int) (err error) { + _, _, e1 := syscall_syscall6(libc_sendfile_trampoline_addr, uintptr(infd), uintptr(outfd), uintptr(offset), uintptr(unsafe.Pointer(len)), uintptr(hdtr), uintptr(flags)) + if e1 != 0 { +diff --git a/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.s b/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.s +index fe222b7..4f178a2 100644 +--- a/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.s ++++ b/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.s +@@ -248,6 +248,11 @@ TEXT libc_pthread_fchdir_np_trampoline<>(SB),NOSPLIT,$0-0 + GLOBL ·libc_pthread_fchdir_np_trampoline_addr(SB), RODATA, $8 + DATA ·libc_pthread_fchdir_np_trampoline_addr(SB)/8, $libc_pthread_fchdir_np_trampoline<>(SB) + ++TEXT libc_connectx_trampoline<>(SB),NOSPLIT,$0-0 ++ JMP libc_connectx(SB) ++GLOBL ·libc_connectx_trampoline_addr(SB), RODATA, $8 ++DATA ·libc_connectx_trampoline_addr(SB)/8, $libc_connectx_trampoline<>(SB) ++ + TEXT libc_sendfile_trampoline<>(SB),NOSPLIT,$0-0 + JMP libc_sendfile(SB) + GLOBL ·libc_sendfile_trampoline_addr(SB), RODATA, $8 +diff --git a/vendor/golang.org/x/sys/unix/zsyscall_linux.go b/vendor/golang.org/x/sys/unix/zsyscall_linux.go +index 1bc1a5a..5cc1e8e 100644 +--- a/vendor/golang.org/x/sys/unix/zsyscall_linux.go ++++ b/vendor/golang.org/x/sys/unix/zsyscall_linux.go +@@ -592,6 +592,16 @@ func ClockGettime(clockid int32, time *Timespec) (err error) { + + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + ++func ClockSettime(clockid int32, time *Timespec) (err error) { ++ _, _, e1 := Syscall(SYS_CLOCK_SETTIME, uintptr(clockid), uintptr(unsafe.Pointer(time)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ + func ClockNanosleep(clockid int32, flags int, request *Timespec, remain *Timespec) (err error) { + _, _, e1 := Syscall6(SYS_CLOCK_NANOSLEEP, uintptr(clockid), uintptr(flags), uintptr(unsafe.Pointer(request)), uintptr(unsafe.Pointer(remain)), 0, 0) + if e1 != 0 { +@@ -971,23 +981,6 @@ func Getpriority(which int, who int) (prio int, err error) { + + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +-func Getrandom(buf []byte, flags int) (n int, err error) { +- var _p0 unsafe.Pointer +- if len(buf) > 0 { +- _p0 = unsafe.Pointer(&buf[0]) +- } else { +- _p0 = unsafe.Pointer(&_zero) +- } +- r0, _, e1 := Syscall(SYS_GETRANDOM, uintptr(_p0), uintptr(len(buf)), uintptr(flags)) +- n = int(r0) +- if e1 != 0 { +- err = errnoErr(e1) +- } +- return +-} +- +-// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT +- + func Getrusage(who int, rusage *Rusage) (err error) { + _, _, e1 := RawSyscall(SYS_GETRUSAGE, uintptr(who), uintptr(unsafe.Pointer(rusage)), 0) + if e1 != 0 { +diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go +index d3e38f6..f485dbf 100644 +--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go ++++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go +@@ -341,6 +341,7 @@ const ( + SYS_STATX = 332 + SYS_IO_PGETEVENTS = 333 + SYS_RSEQ = 334 ++ SYS_URETPROBE = 335 + SYS_PIDFD_SEND_SIGNAL = 424 + SYS_IO_URING_SETUP = 425 + SYS_IO_URING_ENTER = 426 +diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go +index 6c778c2..1893e2f 100644 +--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go ++++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go +@@ -85,7 +85,7 @@ const ( + SYS_SPLICE = 76 + SYS_TEE = 77 + SYS_READLINKAT = 78 +- SYS_FSTATAT = 79 ++ SYS_NEWFSTATAT = 79 + SYS_FSTAT = 80 + SYS_SYNC = 81 + SYS_FSYNC = 82 +diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_loong64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_loong64.go +index 37281cf..16a4017 100644 +--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_loong64.go ++++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_loong64.go +@@ -84,6 +84,8 @@ const ( + SYS_SPLICE = 76 + SYS_TEE = 77 + SYS_READLINKAT = 78 ++ SYS_NEWFSTATAT = 79 ++ SYS_FSTAT = 80 + SYS_SYNC = 81 + SYS_FSYNC = 82 + SYS_FDATASYNC = 83 +diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go +index 9889f6a..a5459e7 100644 +--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go ++++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go +@@ -84,7 +84,7 @@ const ( + SYS_SPLICE = 76 + SYS_TEE = 77 + SYS_READLINKAT = 78 +- SYS_FSTATAT = 79 ++ SYS_NEWFSTATAT = 79 + SYS_FSTAT = 80 + SYS_SYNC = 81 + SYS_FSYNC = 82 +diff --git a/vendor/golang.org/x/sys/unix/ztypes_darwin_amd64.go b/vendor/golang.org/x/sys/unix/ztypes_darwin_amd64.go +index 091d107..17c53bd 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_darwin_amd64.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_darwin_amd64.go +@@ -306,6 +306,19 @@ type XVSockPgen struct { + + type _Socklen uint32 + ++type SaeAssocID uint32 ++ ++type SaeConnID uint32 ++ ++type SaEndpoints struct { ++ Srcif uint32 ++ Srcaddr *RawSockaddr ++ Srcaddrlen uint32 ++ Dstaddr *RawSockaddr ++ Dstaddrlen uint32 ++ _ [4]byte ++} ++ + type Xucred struct { + Version uint32 + Uid uint32 +@@ -449,11 +462,14 @@ type FdSet struct { + + const ( + SizeofIfMsghdr = 0x70 ++ SizeofIfMsghdr2 = 0xa0 + SizeofIfData = 0x60 ++ SizeofIfData64 = 0x80 + SizeofIfaMsghdr = 0x14 + SizeofIfmaMsghdr = 0x10 + SizeofIfmaMsghdr2 = 0x14 + SizeofRtMsghdr = 0x5c ++ SizeofRtMsghdr2 = 0x5c + SizeofRtMetrics = 0x38 + ) + +@@ -467,6 +483,20 @@ type IfMsghdr struct { + Data IfData + } + ++type IfMsghdr2 struct { ++ Msglen uint16 ++ Version uint8 ++ Type uint8 ++ Addrs int32 ++ Flags int32 ++ Index uint16 ++ Snd_len int32 ++ Snd_maxlen int32 ++ Snd_drops int32 ++ Timer int32 ++ Data IfData64 ++} ++ + type IfData struct { + Type uint8 + Typelen uint8 +@@ -499,6 +529,34 @@ type IfData struct { + Reserved2 uint32 + } + ++type IfData64 struct { ++ Type uint8 ++ Typelen uint8 ++ Physical uint8 ++ Addrlen uint8 ++ Hdrlen uint8 ++ Recvquota uint8 ++ Xmitquota uint8 ++ Unused1 uint8 ++ Mtu uint32 ++ Metric uint32 ++ Baudrate uint64 ++ Ipackets uint64 ++ Ierrors uint64 ++ Opackets uint64 ++ Oerrors uint64 ++ Collisions uint64 ++ Ibytes uint64 ++ Obytes uint64 ++ Imcasts uint64 ++ Omcasts uint64 ++ Iqdrops uint64 ++ Noproto uint64 ++ Recvtiming uint32 ++ Xmittiming uint32 ++ Lastchange Timeval32 ++} ++ + type IfaMsghdr struct { + Msglen uint16 + Version uint8 +@@ -544,6 +602,21 @@ type RtMsghdr struct { + Rmx RtMetrics + } + ++type RtMsghdr2 struct { ++ Msglen uint16 ++ Version uint8 ++ Type uint8 ++ Index uint16 ++ Flags int32 ++ Addrs int32 ++ Refcnt int32 ++ Parentflags int32 ++ Reserved int32 ++ Use int32 ++ Inits uint32 ++ Rmx RtMetrics ++} ++ + type RtMetrics struct { + Locks uint32 + Mtu uint32 +diff --git a/vendor/golang.org/x/sys/unix/ztypes_darwin_arm64.go b/vendor/golang.org/x/sys/unix/ztypes_darwin_arm64.go +index 28ff4ef..2392226 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_darwin_arm64.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_darwin_arm64.go +@@ -306,6 +306,19 @@ type XVSockPgen struct { + + type _Socklen uint32 + ++type SaeAssocID uint32 ++ ++type SaeConnID uint32 ++ ++type SaEndpoints struct { ++ Srcif uint32 ++ Srcaddr *RawSockaddr ++ Srcaddrlen uint32 ++ Dstaddr *RawSockaddr ++ Dstaddrlen uint32 ++ _ [4]byte ++} ++ + type Xucred struct { + Version uint32 + Uid uint32 +@@ -449,11 +462,14 @@ type FdSet struct { + + const ( + SizeofIfMsghdr = 0x70 ++ SizeofIfMsghdr2 = 0xa0 + SizeofIfData = 0x60 ++ SizeofIfData64 = 0x80 + SizeofIfaMsghdr = 0x14 + SizeofIfmaMsghdr = 0x10 + SizeofIfmaMsghdr2 = 0x14 + SizeofRtMsghdr = 0x5c ++ SizeofRtMsghdr2 = 0x5c + SizeofRtMetrics = 0x38 + ) + +@@ -467,6 +483,20 @@ type IfMsghdr struct { + Data IfData + } + ++type IfMsghdr2 struct { ++ Msglen uint16 ++ Version uint8 ++ Type uint8 ++ Addrs int32 ++ Flags int32 ++ Index uint16 ++ Snd_len int32 ++ Snd_maxlen int32 ++ Snd_drops int32 ++ Timer int32 ++ Data IfData64 ++} ++ + type IfData struct { + Type uint8 + Typelen uint8 +@@ -499,6 +529,34 @@ type IfData struct { + Reserved2 uint32 + } + ++type IfData64 struct { ++ Type uint8 ++ Typelen uint8 ++ Physical uint8 ++ Addrlen uint8 ++ Hdrlen uint8 ++ Recvquota uint8 ++ Xmitquota uint8 ++ Unused1 uint8 ++ Mtu uint32 ++ Metric uint32 ++ Baudrate uint64 ++ Ipackets uint64 ++ Ierrors uint64 ++ Opackets uint64 ++ Oerrors uint64 ++ Collisions uint64 ++ Ibytes uint64 ++ Obytes uint64 ++ Imcasts uint64 ++ Omcasts uint64 ++ Iqdrops uint64 ++ Noproto uint64 ++ Recvtiming uint32 ++ Xmittiming uint32 ++ Lastchange Timeval32 ++} ++ + type IfaMsghdr struct { + Msglen uint16 + Version uint8 +@@ -544,6 +602,21 @@ type RtMsghdr struct { + Rmx RtMetrics + } + ++type RtMsghdr2 struct { ++ Msglen uint16 ++ Version uint8 ++ Type uint8 ++ Index uint16 ++ Flags int32 ++ Addrs int32 ++ Refcnt int32 ++ Parentflags int32 ++ Reserved int32 ++ Use int32 ++ Inits uint32 ++ Rmx RtMetrics ++} ++ + type RtMetrics struct { + Locks uint32 + Mtu uint32 +diff --git a/vendor/golang.org/x/sys/unix/ztypes_freebsd_386.go b/vendor/golang.org/x/sys/unix/ztypes_freebsd_386.go +index 6cbd094..51e13eb 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_freebsd_386.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_freebsd_386.go +@@ -625,6 +625,7 @@ const ( + POLLRDNORM = 0x40 + POLLWRBAND = 0x100 + POLLWRNORM = 0x4 ++ POLLRDHUP = 0x4000 + ) + + type CapRights struct { +diff --git a/vendor/golang.org/x/sys/unix/ztypes_freebsd_amd64.go b/vendor/golang.org/x/sys/unix/ztypes_freebsd_amd64.go +index 7c03b6e..d002d8e 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_freebsd_amd64.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_freebsd_amd64.go +@@ -630,6 +630,7 @@ const ( + POLLRDNORM = 0x40 + POLLWRBAND = 0x100 + POLLWRNORM = 0x4 ++ POLLRDHUP = 0x4000 + ) + + type CapRights struct { +diff --git a/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm.go b/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm.go +index 422107e..3f863d8 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm.go +@@ -616,6 +616,7 @@ const ( + POLLRDNORM = 0x40 + POLLWRBAND = 0x100 + POLLWRNORM = 0x4 ++ POLLRDHUP = 0x4000 + ) + + type CapRights struct { +diff --git a/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm64.go b/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm64.go +index 505a12a..61c7293 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm64.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_freebsd_arm64.go +@@ -610,6 +610,7 @@ const ( + POLLRDNORM = 0x40 + POLLWRBAND = 0x100 + POLLWRNORM = 0x4 ++ POLLRDHUP = 0x4000 + ) + + type CapRights struct { +diff --git a/vendor/golang.org/x/sys/unix/ztypes_freebsd_riscv64.go b/vendor/golang.org/x/sys/unix/ztypes_freebsd_riscv64.go +index cc986c7..b5d1741 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_freebsd_riscv64.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_freebsd_riscv64.go +@@ -612,6 +612,7 @@ const ( + POLLRDNORM = 0x40 + POLLWRBAND = 0x100 + POLLWRNORM = 0x4 ++ POLLRDHUP = 0x4000 + ) + + type CapRights struct { +diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux.go b/vendor/golang.org/x/sys/unix/ztypes_linux.go +index b102b95..5537148 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_linux.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_linux.go +@@ -87,31 +87,35 @@ type StatxTimestamp struct { + } + + type Statx_t struct { +- Mask uint32 +- Blksize uint32 +- Attributes uint64 +- Nlink uint32 +- Uid uint32 +- Gid uint32 +- Mode uint16 +- _ [1]uint16 +- Ino uint64 +- Size uint64 +- Blocks uint64 +- Attributes_mask uint64 +- Atime StatxTimestamp +- Btime StatxTimestamp +- Ctime StatxTimestamp +- Mtime StatxTimestamp +- Rdev_major uint32 +- Rdev_minor uint32 +- Dev_major uint32 +- Dev_minor uint32 +- Mnt_id uint64 +- Dio_mem_align uint32 +- Dio_offset_align uint32 +- Subvol uint64 +- _ [11]uint64 ++ Mask uint32 ++ Blksize uint32 ++ Attributes uint64 ++ Nlink uint32 ++ Uid uint32 ++ Gid uint32 ++ Mode uint16 ++ _ [1]uint16 ++ Ino uint64 ++ Size uint64 ++ Blocks uint64 ++ Attributes_mask uint64 ++ Atime StatxTimestamp ++ Btime StatxTimestamp ++ Ctime StatxTimestamp ++ Mtime StatxTimestamp ++ Rdev_major uint32 ++ Rdev_minor uint32 ++ Dev_major uint32 ++ Dev_minor uint32 ++ Mnt_id uint64 ++ Dio_mem_align uint32 ++ Dio_offset_align uint32 ++ Subvol uint64 ++ Atomic_write_unit_min uint32 ++ Atomic_write_unit_max uint32 ++ Atomic_write_segments_max uint32 ++ _ [1]uint32 ++ _ [9]uint64 + } + + type Fsid struct { +@@ -516,6 +520,29 @@ type TCPInfo struct { + Total_rto_time uint32 + } + ++type TCPVegasInfo struct { ++ Enabled uint32 ++ Rttcnt uint32 ++ Rtt uint32 ++ Minrtt uint32 ++} ++ ++type TCPDCTCPInfo struct { ++ Enabled uint16 ++ Ce_state uint16 ++ Alpha uint32 ++ Ab_ecn uint32 ++ Ab_tot uint32 ++} ++ ++type TCPBBRInfo struct { ++ Bw_lo uint32 ++ Bw_hi uint32 ++ Min_rtt uint32 ++ Pacing_gain uint32 ++ Cwnd_gain uint32 ++} ++ + type CanFilter struct { + Id uint32 + Mask uint32 +@@ -557,6 +584,7 @@ const ( + SizeofICMPv6Filter = 0x20 + SizeofUcred = 0xc + SizeofTCPInfo = 0xf8 ++ SizeofTCPCCInfo = 0x14 + SizeofCanFilter = 0x8 + SizeofTCPRepairOpt = 0x8 + ) +@@ -1724,12 +1752,6 @@ const ( + IFLA_IPVLAN_UNSPEC = 0x0 + IFLA_IPVLAN_MODE = 0x1 + IFLA_IPVLAN_FLAGS = 0x2 +- NETKIT_NEXT = -0x1 +- NETKIT_PASS = 0x0 +- NETKIT_DROP = 0x2 +- NETKIT_REDIRECT = 0x7 +- NETKIT_L2 = 0x0 +- NETKIT_L3 = 0x1 + IFLA_NETKIT_UNSPEC = 0x0 + IFLA_NETKIT_PEER_INFO = 0x1 + IFLA_NETKIT_PRIMARY = 0x2 +@@ -1768,6 +1790,7 @@ const ( + IFLA_VXLAN_DF = 0x1d + IFLA_VXLAN_VNIFILTER = 0x1e + IFLA_VXLAN_LOCALBYPASS = 0x1f ++ IFLA_VXLAN_LABEL_POLICY = 0x20 + IFLA_GENEVE_UNSPEC = 0x0 + IFLA_GENEVE_ID = 0x1 + IFLA_GENEVE_REMOTE = 0x2 +@@ -1797,6 +1820,8 @@ const ( + IFLA_GTP_ROLE = 0x4 + IFLA_GTP_CREATE_SOCKETS = 0x5 + IFLA_GTP_RESTART_COUNT = 0x6 ++ IFLA_GTP_LOCAL = 0x7 ++ IFLA_GTP_LOCAL6 = 0x8 + IFLA_BOND_UNSPEC = 0x0 + IFLA_BOND_MODE = 0x1 + IFLA_BOND_ACTIVE_SLAVE = 0x2 +@@ -1829,6 +1854,7 @@ const ( + IFLA_BOND_AD_LACP_ACTIVE = 0x1d + IFLA_BOND_MISSED_MAX = 0x1e + IFLA_BOND_NS_IP6_TARGET = 0x1f ++ IFLA_BOND_COUPLED_CONTROL = 0x20 + IFLA_BOND_AD_INFO_UNSPEC = 0x0 + IFLA_BOND_AD_INFO_AGGREGATOR = 0x1 + IFLA_BOND_AD_INFO_NUM_PORTS = 0x2 +@@ -1897,6 +1923,7 @@ const ( + IFLA_HSR_SEQ_NR = 0x5 + IFLA_HSR_VERSION = 0x6 + IFLA_HSR_PROTOCOL = 0x7 ++ IFLA_HSR_INTERLINK = 0x8 + IFLA_STATS_UNSPEC = 0x0 + IFLA_STATS_LINK_64 = 0x1 + IFLA_STATS_LINK_XSTATS = 0x2 +@@ -1949,6 +1976,15 @@ const ( + IFLA_DSA_MASTER = 0x1 + ) + ++const ( ++ NETKIT_NEXT = -0x1 ++ NETKIT_PASS = 0x0 ++ NETKIT_DROP = 0x2 ++ NETKIT_REDIRECT = 0x7 ++ NETKIT_L2 = 0x0 ++ NETKIT_L3 = 0x1 ++) ++ + const ( + NF_INET_PRE_ROUTING = 0x0 + NF_INET_LOCAL_IN = 0x1 +@@ -2486,7 +2522,7 @@ type XDPMmapOffsets struct { + type XDPUmemReg struct { + Addr uint64 + Len uint64 +- Chunk_size uint32 ++ Size uint32 + Headroom uint32 + Flags uint32 + Tx_metadata_len uint32 +@@ -2558,8 +2594,8 @@ const ( + SOF_TIMESTAMPING_BIND_PHC = 0x8000 + SOF_TIMESTAMPING_OPT_ID_TCP = 0x10000 + +- SOF_TIMESTAMPING_LAST = 0x10000 +- SOF_TIMESTAMPING_MASK = 0x1ffff ++ SOF_TIMESTAMPING_LAST = 0x20000 ++ SOF_TIMESTAMPING_MASK = 0x3ffff + + SCM_TSTAMP_SND = 0x0 + SCM_TSTAMP_SCHED = 0x1 +@@ -3505,7 +3541,7 @@ type Nhmsg struct { + type NexthopGrp struct { + Id uint32 + Weight uint8 +- Resvd1 uint8 ++ High uint8 + Resvd2 uint16 + } + +@@ -3766,7 +3802,7 @@ const ( + ETHTOOL_MSG_PSE_GET = 0x24 + ETHTOOL_MSG_PSE_SET = 0x25 + ETHTOOL_MSG_RSS_GET = 0x26 +- ETHTOOL_MSG_USER_MAX = 0x2b ++ ETHTOOL_MSG_USER_MAX = 0x2d + ETHTOOL_MSG_KERNEL_NONE = 0x0 + ETHTOOL_MSG_STRSET_GET_REPLY = 0x1 + ETHTOOL_MSG_LINKINFO_GET_REPLY = 0x2 +@@ -3806,12 +3842,15 @@ const ( + ETHTOOL_MSG_MODULE_NTF = 0x24 + ETHTOOL_MSG_PSE_GET_REPLY = 0x25 + ETHTOOL_MSG_RSS_GET_REPLY = 0x26 +- ETHTOOL_MSG_KERNEL_MAX = 0x2b ++ ETHTOOL_MSG_KERNEL_MAX = 0x2e ++ ETHTOOL_FLAG_COMPACT_BITSETS = 0x1 ++ ETHTOOL_FLAG_OMIT_REPLY = 0x2 ++ ETHTOOL_FLAG_STATS = 0x4 + ETHTOOL_A_HEADER_UNSPEC = 0x0 + ETHTOOL_A_HEADER_DEV_INDEX = 0x1 + ETHTOOL_A_HEADER_DEV_NAME = 0x2 + ETHTOOL_A_HEADER_FLAGS = 0x3 +- ETHTOOL_A_HEADER_MAX = 0x3 ++ ETHTOOL_A_HEADER_MAX = 0x4 + ETHTOOL_A_BITSET_BIT_UNSPEC = 0x0 + ETHTOOL_A_BITSET_BIT_INDEX = 0x1 + ETHTOOL_A_BITSET_BIT_NAME = 0x2 +@@ -3948,7 +3987,7 @@ const ( + ETHTOOL_A_COALESCE_RATE_SAMPLE_INTERVAL = 0x17 + ETHTOOL_A_COALESCE_USE_CQE_MODE_TX = 0x18 + ETHTOOL_A_COALESCE_USE_CQE_MODE_RX = 0x19 +- ETHTOOL_A_COALESCE_MAX = 0x1c ++ ETHTOOL_A_COALESCE_MAX = 0x1e + ETHTOOL_A_PAUSE_UNSPEC = 0x0 + ETHTOOL_A_PAUSE_HEADER = 0x1 + ETHTOOL_A_PAUSE_AUTONEG = 0x2 +@@ -3992,11 +4031,11 @@ const ( + ETHTOOL_A_CABLE_RESULT_UNSPEC = 0x0 + ETHTOOL_A_CABLE_RESULT_PAIR = 0x1 + ETHTOOL_A_CABLE_RESULT_CODE = 0x2 +- ETHTOOL_A_CABLE_RESULT_MAX = 0x2 ++ ETHTOOL_A_CABLE_RESULT_MAX = 0x3 + ETHTOOL_A_CABLE_FAULT_LENGTH_UNSPEC = 0x0 + ETHTOOL_A_CABLE_FAULT_LENGTH_PAIR = 0x1 + ETHTOOL_A_CABLE_FAULT_LENGTH_CM = 0x2 +- ETHTOOL_A_CABLE_FAULT_LENGTH_MAX = 0x2 ++ ETHTOOL_A_CABLE_FAULT_LENGTH_MAX = 0x3 + ETHTOOL_A_CABLE_TEST_NTF_STATUS_UNSPEC = 0x0 + ETHTOOL_A_CABLE_TEST_NTF_STATUS_STARTED = 0x1 + ETHTOOL_A_CABLE_TEST_NTF_STATUS_COMPLETED = 0x2 +@@ -4079,6 +4118,107 @@ type EthtoolDrvinfo struct { + Regdump_len uint32 + } + ++type EthtoolTsInfo struct { ++ Cmd uint32 ++ So_timestamping uint32 ++ Phc_index int32 ++ Tx_types uint32 ++ Tx_reserved [3]uint32 ++ Rx_filters uint32 ++ Rx_reserved [3]uint32 ++} ++ ++type HwTstampConfig struct { ++ Flags int32 ++ Tx_type int32 ++ Rx_filter int32 ++} ++ ++const ( ++ HWTSTAMP_FILTER_NONE = 0x0 ++ HWTSTAMP_FILTER_ALL = 0x1 ++ HWTSTAMP_FILTER_SOME = 0x2 ++ HWTSTAMP_FILTER_PTP_V1_L4_EVENT = 0x3 ++ HWTSTAMP_FILTER_PTP_V2_L4_EVENT = 0x6 ++ HWTSTAMP_FILTER_PTP_V2_L2_EVENT = 0x9 ++ HWTSTAMP_FILTER_PTP_V2_EVENT = 0xc ++) ++ ++const ( ++ HWTSTAMP_TX_OFF = 0x0 ++ HWTSTAMP_TX_ON = 0x1 ++ HWTSTAMP_TX_ONESTEP_SYNC = 0x2 ++) ++ ++type ( ++ PtpClockCaps struct { ++ Max_adj int32 ++ N_alarm int32 ++ N_ext_ts int32 ++ N_per_out int32 ++ Pps int32 ++ N_pins int32 ++ Cross_timestamping int32 ++ Adjust_phase int32 ++ Max_phase_adj int32 ++ Rsv [11]int32 ++ } ++ PtpClockTime struct { ++ Sec int64 ++ Nsec uint32 ++ Reserved uint32 ++ } ++ PtpExttsEvent struct { ++ T PtpClockTime ++ Index uint32 ++ Flags uint32 ++ Rsv [2]uint32 ++ } ++ PtpExttsRequest struct { ++ Index uint32 ++ Flags uint32 ++ Rsv [2]uint32 ++ } ++ PtpPeroutRequest struct { ++ StartOrPhase PtpClockTime ++ Period PtpClockTime ++ Index uint32 ++ Flags uint32 ++ On PtpClockTime ++ } ++ PtpPinDesc struct { ++ Name [64]byte ++ Index uint32 ++ Func uint32 ++ Chan uint32 ++ Rsv [5]uint32 ++ } ++ PtpSysOffset struct { ++ Samples uint32 ++ Rsv [3]uint32 ++ Ts [51]PtpClockTime ++ } ++ PtpSysOffsetExtended struct { ++ Samples uint32 ++ Clockid int32 ++ Rsv [2]uint32 ++ Ts [25][3]PtpClockTime ++ } ++ PtpSysOffsetPrecise struct { ++ Device PtpClockTime ++ Realtime PtpClockTime ++ Monoraw PtpClockTime ++ Rsv [4]uint32 ++ } ++) ++ ++const ( ++ PTP_PF_NONE = 0x0 ++ PTP_PF_EXTTS = 0x1 ++ PTP_PF_PEROUT = 0x2 ++ PTP_PF_PHYSYNC = 0x3 ++) ++ + type ( + HIDRawReportDescriptor struct { + Size uint32 +@@ -4260,6 +4400,7 @@ const ( + type LandlockRulesetAttr struct { + Access_fs uint64 + Access_net uint64 ++ Scoped uint64 + } + + type LandlockPathBeneathAttr struct { +@@ -4606,7 +4747,7 @@ const ( + NL80211_ATTR_MAC_HINT = 0xc8 + NL80211_ATTR_MAC_MASK = 0xd7 + NL80211_ATTR_MAX_AP_ASSOC_STA = 0xca +- NL80211_ATTR_MAX = 0x14a ++ NL80211_ATTR_MAX = 0x14c + NL80211_ATTR_MAX_CRIT_PROT_DURATION = 0xb4 + NL80211_ATTR_MAX_CSA_COUNTERS = 0xce + NL80211_ATTR_MAX_MATCH_SETS = 0x85 +@@ -5210,7 +5351,7 @@ const ( + NL80211_FREQUENCY_ATTR_GO_CONCURRENT = 0xf + NL80211_FREQUENCY_ATTR_INDOOR_ONLY = 0xe + NL80211_FREQUENCY_ATTR_IR_CONCURRENT = 0xf +- NL80211_FREQUENCY_ATTR_MAX = 0x20 ++ NL80211_FREQUENCY_ATTR_MAX = 0x21 + NL80211_FREQUENCY_ATTR_MAX_TX_POWER = 0x6 + NL80211_FREQUENCY_ATTR_NO_10MHZ = 0x11 + NL80211_FREQUENCY_ATTR_NO_160MHZ = 0xc +diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go b/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go +index 15adc04..ad05b51 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go +@@ -727,6 +727,37 @@ const ( + RISCV_HWPROBE_EXT_ZBA = 0x8 + RISCV_HWPROBE_EXT_ZBB = 0x10 + RISCV_HWPROBE_EXT_ZBS = 0x20 ++ RISCV_HWPROBE_EXT_ZICBOZ = 0x40 ++ RISCV_HWPROBE_EXT_ZBC = 0x80 ++ RISCV_HWPROBE_EXT_ZBKB = 0x100 ++ RISCV_HWPROBE_EXT_ZBKC = 0x200 ++ RISCV_HWPROBE_EXT_ZBKX = 0x400 ++ RISCV_HWPROBE_EXT_ZKND = 0x800 ++ RISCV_HWPROBE_EXT_ZKNE = 0x1000 ++ RISCV_HWPROBE_EXT_ZKNH = 0x2000 ++ RISCV_HWPROBE_EXT_ZKSED = 0x4000 ++ RISCV_HWPROBE_EXT_ZKSH = 0x8000 ++ RISCV_HWPROBE_EXT_ZKT = 0x10000 ++ RISCV_HWPROBE_EXT_ZVBB = 0x20000 ++ RISCV_HWPROBE_EXT_ZVBC = 0x40000 ++ RISCV_HWPROBE_EXT_ZVKB = 0x80000 ++ RISCV_HWPROBE_EXT_ZVKG = 0x100000 ++ RISCV_HWPROBE_EXT_ZVKNED = 0x200000 ++ RISCV_HWPROBE_EXT_ZVKNHA = 0x400000 ++ RISCV_HWPROBE_EXT_ZVKNHB = 0x800000 ++ RISCV_HWPROBE_EXT_ZVKSED = 0x1000000 ++ RISCV_HWPROBE_EXT_ZVKSH = 0x2000000 ++ RISCV_HWPROBE_EXT_ZVKT = 0x4000000 ++ RISCV_HWPROBE_EXT_ZFH = 0x8000000 ++ RISCV_HWPROBE_EXT_ZFHMIN = 0x10000000 ++ RISCV_HWPROBE_EXT_ZIHINTNTL = 0x20000000 ++ RISCV_HWPROBE_EXT_ZVFH = 0x40000000 ++ RISCV_HWPROBE_EXT_ZVFHMIN = 0x80000000 ++ RISCV_HWPROBE_EXT_ZFA = 0x100000000 ++ RISCV_HWPROBE_EXT_ZTSO = 0x200000000 ++ RISCV_HWPROBE_EXT_ZACAS = 0x400000000 ++ RISCV_HWPROBE_EXT_ZICOND = 0x800000000 ++ RISCV_HWPROBE_EXT_ZIHINTPAUSE = 0x1000000000 + RISCV_HWPROBE_KEY_CPUPERF_0 = 0x5 + RISCV_HWPROBE_MISALIGNED_UNKNOWN = 0x0 + RISCV_HWPROBE_MISALIGNED_EMULATED = 0x1 +@@ -734,4 +765,6 @@ const ( + RISCV_HWPROBE_MISALIGNED_FAST = 0x3 + RISCV_HWPROBE_MISALIGNED_UNSUPPORTED = 0x4 + RISCV_HWPROBE_MISALIGNED_MASK = 0x7 ++ RISCV_HWPROBE_KEY_ZICBOZ_BLOCK_SIZE = 0x6 ++ RISCV_HWPROBE_WHICH_CPUS = 0x1 + ) +diff --git a/vendor/golang.org/x/sys/unix/ztypes_zos_s390x.go b/vendor/golang.org/x/sys/unix/ztypes_zos_s390x.go +index d9a13af..2e5d5a4 100644 +--- a/vendor/golang.org/x/sys/unix/ztypes_zos_s390x.go ++++ b/vendor/golang.org/x/sys/unix/ztypes_zos_s390x.go +@@ -377,6 +377,12 @@ type Flock_t struct { + Pid int32 + } + ++type F_cnvrt struct { ++ Cvtcmd int32 ++ Pccsid int16 ++ Fccsid int16 ++} ++ + type Termios struct { + Cflag uint32 + Iflag uint32 +diff --git a/vendor/golang.org/x/sys/windows/dll_windows.go b/vendor/golang.org/x/sys/windows/dll_windows.go +index 115341f..4e613cf 100644 +--- a/vendor/golang.org/x/sys/windows/dll_windows.go ++++ b/vendor/golang.org/x/sys/windows/dll_windows.go +@@ -65,7 +65,7 @@ func LoadDLL(name string) (dll *DLL, err error) { + return d, nil + } + +-// MustLoadDLL is like LoadDLL but panics if load operation failes. ++// MustLoadDLL is like LoadDLL but panics if load operation fails. + func MustLoadDLL(name string) *DLL { + d, e := LoadDLL(name) + if e != nil { +diff --git a/vendor/golang.org/x/sys/windows/syscall_windows.go b/vendor/golang.org/x/sys/windows/syscall_windows.go +index 1fa34fd..4a32543 100644 +--- a/vendor/golang.org/x/sys/windows/syscall_windows.go ++++ b/vendor/golang.org/x/sys/windows/syscall_windows.go +@@ -168,6 +168,8 @@ func NewCallbackCDecl(fn interface{}) uintptr { + //sys CreateNamedPipe(name *uint16, flags uint32, pipeMode uint32, maxInstances uint32, outSize uint32, inSize uint32, defaultTimeout uint32, sa *SecurityAttributes) (handle Handle, err error) [failretval==InvalidHandle] = CreateNamedPipeW + //sys ConnectNamedPipe(pipe Handle, overlapped *Overlapped) (err error) + //sys DisconnectNamedPipe(pipe Handle) (err error) ++//sys GetNamedPipeClientProcessId(pipe Handle, clientProcessID *uint32) (err error) ++//sys GetNamedPipeServerProcessId(pipe Handle, serverProcessID *uint32) (err error) + //sys GetNamedPipeInfo(pipe Handle, flags *uint32, outSize *uint32, inSize *uint32, maxInstances *uint32) (err error) + //sys GetNamedPipeHandleState(pipe Handle, state *uint32, curInstances *uint32, maxCollectionCount *uint32, collectDataTimeout *uint32, userName *uint16, maxUserNameSize uint32) (err error) = GetNamedPipeHandleStateW + //sys SetNamedPipeHandleState(pipe Handle, state *uint32, maxCollectionCount *uint32, collectDataTimeout *uint32) (err error) = SetNamedPipeHandleState +@@ -313,6 +315,10 @@ func NewCallbackCDecl(fn interface{}) uintptr { + //sys SetConsoleMode(console Handle, mode uint32) (err error) = kernel32.SetConsoleMode + //sys GetConsoleScreenBufferInfo(console Handle, info *ConsoleScreenBufferInfo) (err error) = kernel32.GetConsoleScreenBufferInfo + //sys setConsoleCursorPosition(console Handle, position uint32) (err error) = kernel32.SetConsoleCursorPosition ++//sys GetConsoleCP() (cp uint32, err error) = kernel32.GetConsoleCP ++//sys GetConsoleOutputCP() (cp uint32, err error) = kernel32.GetConsoleOutputCP ++//sys SetConsoleCP(cp uint32) (err error) = kernel32.SetConsoleCP ++//sys SetConsoleOutputCP(cp uint32) (err error) = kernel32.SetConsoleOutputCP + //sys WriteConsole(console Handle, buf *uint16, towrite uint32, written *uint32, reserved *byte) (err error) = kernel32.WriteConsoleW + //sys ReadConsole(console Handle, buf *uint16, toread uint32, read *uint32, inputControl *byte) (err error) = kernel32.ReadConsoleW + //sys resizePseudoConsole(pconsole Handle, size uint32) (hr error) = kernel32.ResizePseudoConsole +@@ -721,20 +727,12 @@ func DurationSinceBoot() time.Duration { + } + + func Ftruncate(fd Handle, length int64) (err error) { +- curoffset, e := Seek(fd, 0, 1) +- if e != nil { +- return e +- } +- defer Seek(fd, curoffset, 0) +- _, e = Seek(fd, length, 0) +- if e != nil { +- return e ++ type _FILE_END_OF_FILE_INFO struct { ++ EndOfFile int64 + } +- e = SetEndOfFile(fd) +- if e != nil { +- return e +- } +- return nil ++ var info _FILE_END_OF_FILE_INFO ++ info.EndOfFile = length ++ return SetFileInformationByHandle(fd, FileEndOfFileInfo, (*byte)(unsafe.Pointer(&info)), uint32(unsafe.Sizeof(info))) + } + + func Gettimeofday(tv *Timeval) (err error) { +@@ -890,6 +888,11 @@ const socket_error = uintptr(^uint32(0)) + //sys GetACP() (acp uint32) = kernel32.GetACP + //sys MultiByteToWideChar(codePage uint32, dwFlags uint32, str *byte, nstr int32, wchar *uint16, nwchar int32) (nwrite int32, err error) = kernel32.MultiByteToWideChar + //sys getBestInterfaceEx(sockaddr unsafe.Pointer, pdwBestIfIndex *uint32) (errcode error) = iphlpapi.GetBestInterfaceEx ++//sys GetIfEntry2Ex(level uint32, row *MibIfRow2) (errcode error) = iphlpapi.GetIfEntry2Ex ++//sys GetUnicastIpAddressEntry(row *MibUnicastIpAddressRow) (errcode error) = iphlpapi.GetUnicastIpAddressEntry ++//sys NotifyIpInterfaceChange(family uint16, callback uintptr, callerContext unsafe.Pointer, initialNotification bool, notificationHandle *Handle) (errcode error) = iphlpapi.NotifyIpInterfaceChange ++//sys NotifyUnicastIpAddressChange(family uint16, callback uintptr, callerContext unsafe.Pointer, initialNotification bool, notificationHandle *Handle) (errcode error) = iphlpapi.NotifyUnicastIpAddressChange ++//sys CancelMibChangeNotify2(notificationHandle Handle) (errcode error) = iphlpapi.CancelMibChangeNotify2 + + // For testing: clients can set this flag to force + // creation of IPv6 sockets to return EAFNOSUPPORT. +@@ -1681,13 +1684,16 @@ func (s NTStatus) Error() string { + // do not use NTUnicodeString, and instead UTF16PtrFromString should be used for + // the more common *uint16 string type. + func NewNTUnicodeString(s string) (*NTUnicodeString, error) { +- var u NTUnicodeString +- s16, err := UTF16PtrFromString(s) ++ s16, err := UTF16FromString(s) + if err != nil { + return nil, err + } +- RtlInitUnicodeString(&u, s16) +- return &u, nil ++ n := uint16(len(s16) * 2) ++ return &NTUnicodeString{ ++ Length: n - 2, // subtract 2 bytes for the NULL terminator ++ MaximumLength: n, ++ Buffer: &s16[0], ++ }, nil + } + + // Slice returns a uint16 slice that aliases the data in the NTUnicodeString. +diff --git a/vendor/golang.org/x/sys/windows/types_windows.go b/vendor/golang.org/x/sys/windows/types_windows.go +index 4d0c157..9d138de 100644 +--- a/vendor/golang.org/x/sys/windows/types_windows.go ++++ b/vendor/golang.org/x/sys/windows/types_windows.go +@@ -176,6 +176,7 @@ const ( + WAIT_FAILED = 0xFFFFFFFF + + // Access rights for process. ++ PROCESS_ALL_ACCESS = 0xFFFF + PROCESS_CREATE_PROCESS = 0x0080 + PROCESS_CREATE_THREAD = 0x0002 + PROCESS_DUP_HANDLE = 0x0040 +@@ -1060,6 +1061,7 @@ const ( + SIO_GET_EXTENSION_FUNCTION_POINTER = IOC_INOUT | IOC_WS2 | 6 + SIO_KEEPALIVE_VALS = IOC_IN | IOC_VENDOR | 4 + SIO_UDP_CONNRESET = IOC_IN | IOC_VENDOR | 12 ++ SIO_UDP_NETRESET = IOC_IN | IOC_VENDOR | 15 + + // cf. http://support.microsoft.com/default.aspx?scid=kb;en-us;257460 + +@@ -2031,6 +2033,50 @@ const ( + IF_TYPE_IEEE1394 = 144 + ) + ++// Enum NL_PREFIX_ORIGIN for [IpAdapterUnicastAddress], see ++// https://learn.microsoft.com/en-us/windows/win32/api/nldef/ne-nldef-nl_prefix_origin ++const ( ++ IpPrefixOriginOther = 0 ++ IpPrefixOriginManual = 1 ++ IpPrefixOriginWellKnown = 2 ++ IpPrefixOriginDhcp = 3 ++ IpPrefixOriginRouterAdvertisement = 4 ++ IpPrefixOriginUnchanged = 1 << 4 ++) ++ ++// Enum NL_SUFFIX_ORIGIN for [IpAdapterUnicastAddress], see ++// https://learn.microsoft.com/en-us/windows/win32/api/nldef/ne-nldef-nl_suffix_origin ++const ( ++ NlsoOther = 0 ++ NlsoManual = 1 ++ NlsoWellKnown = 2 ++ NlsoDhcp = 3 ++ NlsoLinkLayerAddress = 4 ++ NlsoRandom = 5 ++ IpSuffixOriginOther = 0 ++ IpSuffixOriginManual = 1 ++ IpSuffixOriginWellKnown = 2 ++ IpSuffixOriginDhcp = 3 ++ IpSuffixOriginLinkLayerAddress = 4 ++ IpSuffixOriginRandom = 5 ++ IpSuffixOriginUnchanged = 1 << 4 ++) ++ ++// Enum NL_DAD_STATE for [IpAdapterUnicastAddress], see ++// https://learn.microsoft.com/en-us/windows/win32/api/nldef/ne-nldef-nl_dad_state ++const ( ++ NldsInvalid = 0 ++ NldsTentative = 1 ++ NldsDuplicate = 2 ++ NldsDeprecated = 3 ++ NldsPreferred = 4 ++ IpDadStateInvalid = 0 ++ IpDadStateTentative = 1 ++ IpDadStateDuplicate = 2 ++ IpDadStateDeprecated = 3 ++ IpDadStatePreferred = 4 ++) ++ + type SocketAddress struct { + Sockaddr *syscall.RawSockaddrAny + SockaddrLength int32 +@@ -2158,6 +2204,132 @@ const ( + IfOperStatusLowerLayerDown = 7 + ) + ++const ( ++ IF_MAX_PHYS_ADDRESS_LENGTH = 32 ++ IF_MAX_STRING_SIZE = 256 ++) ++ ++// MIB_IF_ENTRY_LEVEL enumeration from netioapi.h or ++// https://learn.microsoft.com/en-us/windows/win32/api/netioapi/nf-netioapi-getifentry2ex. ++const ( ++ MibIfEntryNormal = 0 ++ MibIfEntryNormalWithoutStatistics = 2 ++) ++ ++// MIB_NOTIFICATION_TYPE enumeration from netioapi.h or ++// https://learn.microsoft.com/en-us/windows/win32/api/netioapi/ne-netioapi-mib_notification_type. ++const ( ++ MibParameterNotification = 0 ++ MibAddInstance = 1 ++ MibDeleteInstance = 2 ++ MibInitialNotification = 3 ++) ++ ++// MibIfRow2 stores information about a particular interface. See ++// https://learn.microsoft.com/en-us/windows/win32/api/netioapi/ns-netioapi-mib_if_row2. ++type MibIfRow2 struct { ++ InterfaceLuid uint64 ++ InterfaceIndex uint32 ++ InterfaceGuid GUID ++ Alias [IF_MAX_STRING_SIZE + 1]uint16 ++ Description [IF_MAX_STRING_SIZE + 1]uint16 ++ PhysicalAddressLength uint32 ++ PhysicalAddress [IF_MAX_PHYS_ADDRESS_LENGTH]uint8 ++ PermanentPhysicalAddress [IF_MAX_PHYS_ADDRESS_LENGTH]uint8 ++ Mtu uint32 ++ Type uint32 ++ TunnelType uint32 ++ MediaType uint32 ++ PhysicalMediumType uint32 ++ AccessType uint32 ++ DirectionType uint32 ++ InterfaceAndOperStatusFlags uint8 ++ OperStatus uint32 ++ AdminStatus uint32 ++ MediaConnectState uint32 ++ NetworkGuid GUID ++ ConnectionType uint32 ++ TransmitLinkSpeed uint64 ++ ReceiveLinkSpeed uint64 ++ InOctets uint64 ++ InUcastPkts uint64 ++ InNUcastPkts uint64 ++ InDiscards uint64 ++ InErrors uint64 ++ InUnknownProtos uint64 ++ InUcastOctets uint64 ++ InMulticastOctets uint64 ++ InBroadcastOctets uint64 ++ OutOctets uint64 ++ OutUcastPkts uint64 ++ OutNUcastPkts uint64 ++ OutDiscards uint64 ++ OutErrors uint64 ++ OutUcastOctets uint64 ++ OutMulticastOctets uint64 ++ OutBroadcastOctets uint64 ++ OutQLen uint64 ++} ++ ++// MIB_UNICASTIPADDRESS_ROW stores information about a unicast IP address. See ++// https://learn.microsoft.com/en-us/windows/win32/api/netioapi/ns-netioapi-mib_unicastipaddress_row. ++type MibUnicastIpAddressRow struct { ++ Address RawSockaddrInet6 // SOCKADDR_INET union ++ InterfaceLuid uint64 ++ InterfaceIndex uint32 ++ PrefixOrigin uint32 ++ SuffixOrigin uint32 ++ ValidLifetime uint32 ++ PreferredLifetime uint32 ++ OnLinkPrefixLength uint8 ++ SkipAsSource uint8 ++ DadState uint32 ++ ScopeId uint32 ++ CreationTimeStamp Filetime ++} ++ ++const ScopeLevelCount = 16 ++ ++// MIB_IPINTERFACE_ROW stores interface management information for a particular IP address family on a network interface. ++// See https://learn.microsoft.com/en-us/windows/win32/api/netioapi/ns-netioapi-mib_ipinterface_row. ++type MibIpInterfaceRow struct { ++ Family uint16 ++ InterfaceLuid uint64 ++ InterfaceIndex uint32 ++ MaxReassemblySize uint32 ++ InterfaceIdentifier uint64 ++ MinRouterAdvertisementInterval uint32 ++ MaxRouterAdvertisementInterval uint32 ++ AdvertisingEnabled uint8 ++ ForwardingEnabled uint8 ++ WeakHostSend uint8 ++ WeakHostReceive uint8 ++ UseAutomaticMetric uint8 ++ UseNeighborUnreachabilityDetection uint8 ++ ManagedAddressConfigurationSupported uint8 ++ OtherStatefulConfigurationSupported uint8 ++ AdvertiseDefaultRoute uint8 ++ RouterDiscoveryBehavior uint32 ++ DadTransmits uint32 ++ BaseReachableTime uint32 ++ RetransmitTime uint32 ++ PathMtuDiscoveryTimeout uint32 ++ LinkLocalAddressBehavior uint32 ++ LinkLocalAddressTimeout uint32 ++ ZoneIndices [ScopeLevelCount]uint32 ++ SitePrefixLength uint32 ++ Metric uint32 ++ NlMtu uint32 ++ Connected uint8 ++ SupportsWakeUpPatterns uint8 ++ SupportsNeighborDiscovery uint8 ++ SupportsRouterDiscovery uint8 ++ ReachableTime uint32 ++ TransmitOffload uint32 ++ ReceiveOffload uint32 ++ DisableDefaultRoutes uint8 ++} ++ + // Console related constants used for the mode parameter to SetConsoleMode. See + // https://docs.microsoft.com/en-us/windows/console/setconsolemode for details. + +diff --git a/vendor/golang.org/x/sys/windows/zsyscall_windows.go b/vendor/golang.org/x/sys/windows/zsyscall_windows.go +index 9bb979a..01c0716 100644 +--- a/vendor/golang.org/x/sys/windows/zsyscall_windows.go ++++ b/vendor/golang.org/x/sys/windows/zsyscall_windows.go +@@ -181,10 +181,15 @@ var ( + procDnsRecordListFree = moddnsapi.NewProc("DnsRecordListFree") + procDwmGetWindowAttribute = moddwmapi.NewProc("DwmGetWindowAttribute") + procDwmSetWindowAttribute = moddwmapi.NewProc("DwmSetWindowAttribute") ++ procCancelMibChangeNotify2 = modiphlpapi.NewProc("CancelMibChangeNotify2") + procGetAdaptersAddresses = modiphlpapi.NewProc("GetAdaptersAddresses") + procGetAdaptersInfo = modiphlpapi.NewProc("GetAdaptersInfo") + procGetBestInterfaceEx = modiphlpapi.NewProc("GetBestInterfaceEx") + procGetIfEntry = modiphlpapi.NewProc("GetIfEntry") ++ procGetIfEntry2Ex = modiphlpapi.NewProc("GetIfEntry2Ex") ++ procGetUnicastIpAddressEntry = modiphlpapi.NewProc("GetUnicastIpAddressEntry") ++ procNotifyIpInterfaceChange = modiphlpapi.NewProc("NotifyIpInterfaceChange") ++ procNotifyUnicastIpAddressChange = modiphlpapi.NewProc("NotifyUnicastIpAddressChange") + procAddDllDirectory = modkernel32.NewProc("AddDllDirectory") + procAssignProcessToJobObject = modkernel32.NewProc("AssignProcessToJobObject") + procCancelIo = modkernel32.NewProc("CancelIo") +@@ -247,7 +252,9 @@ var ( + procGetCommandLineW = modkernel32.NewProc("GetCommandLineW") + procGetComputerNameExW = modkernel32.NewProc("GetComputerNameExW") + procGetComputerNameW = modkernel32.NewProc("GetComputerNameW") ++ procGetConsoleCP = modkernel32.NewProc("GetConsoleCP") + procGetConsoleMode = modkernel32.NewProc("GetConsoleMode") ++ procGetConsoleOutputCP = modkernel32.NewProc("GetConsoleOutputCP") + procGetConsoleScreenBufferInfo = modkernel32.NewProc("GetConsoleScreenBufferInfo") + procGetCurrentDirectoryW = modkernel32.NewProc("GetCurrentDirectoryW") + procGetCurrentProcessId = modkernel32.NewProc("GetCurrentProcessId") +@@ -273,8 +280,10 @@ var ( + procGetMaximumProcessorCount = modkernel32.NewProc("GetMaximumProcessorCount") + procGetModuleFileNameW = modkernel32.NewProc("GetModuleFileNameW") + procGetModuleHandleExW = modkernel32.NewProc("GetModuleHandleExW") ++ procGetNamedPipeClientProcessId = modkernel32.NewProc("GetNamedPipeClientProcessId") + procGetNamedPipeHandleStateW = modkernel32.NewProc("GetNamedPipeHandleStateW") + procGetNamedPipeInfo = modkernel32.NewProc("GetNamedPipeInfo") ++ procGetNamedPipeServerProcessId = modkernel32.NewProc("GetNamedPipeServerProcessId") + procGetOverlappedResult = modkernel32.NewProc("GetOverlappedResult") + procGetPriorityClass = modkernel32.NewProc("GetPriorityClass") + procGetProcAddress = modkernel32.NewProc("GetProcAddress") +@@ -347,8 +356,10 @@ var ( + procSetCommMask = modkernel32.NewProc("SetCommMask") + procSetCommState = modkernel32.NewProc("SetCommState") + procSetCommTimeouts = modkernel32.NewProc("SetCommTimeouts") ++ procSetConsoleCP = modkernel32.NewProc("SetConsoleCP") + procSetConsoleCursorPosition = modkernel32.NewProc("SetConsoleCursorPosition") + procSetConsoleMode = modkernel32.NewProc("SetConsoleMode") ++ procSetConsoleOutputCP = modkernel32.NewProc("SetConsoleOutputCP") + procSetCurrentDirectoryW = modkernel32.NewProc("SetCurrentDirectoryW") + procSetDefaultDllDirectories = modkernel32.NewProc("SetDefaultDllDirectories") + procSetDllDirectoryW = modkernel32.NewProc("SetDllDirectoryW") +@@ -1602,6 +1613,14 @@ func DwmSetWindowAttribute(hwnd HWND, attribute uint32, value unsafe.Pointer, si + return + } + ++func CancelMibChangeNotify2(notificationHandle Handle) (errcode error) { ++ r0, _, _ := syscall.Syscall(procCancelMibChangeNotify2.Addr(), 1, uintptr(notificationHandle), 0, 0) ++ if r0 != 0 { ++ errcode = syscall.Errno(r0) ++ } ++ return ++} ++ + func GetAdaptersAddresses(family uint32, flags uint32, reserved uintptr, adapterAddresses *IpAdapterAddresses, sizePointer *uint32) (errcode error) { + r0, _, _ := syscall.Syscall6(procGetAdaptersAddresses.Addr(), 5, uintptr(family), uintptr(flags), uintptr(reserved), uintptr(unsafe.Pointer(adapterAddresses)), uintptr(unsafe.Pointer(sizePointer)), 0) + if r0 != 0 { +@@ -1634,6 +1653,46 @@ func GetIfEntry(pIfRow *MibIfRow) (errcode error) { + return + } + ++func GetIfEntry2Ex(level uint32, row *MibIfRow2) (errcode error) { ++ r0, _, _ := syscall.Syscall(procGetIfEntry2Ex.Addr(), 2, uintptr(level), uintptr(unsafe.Pointer(row)), 0) ++ if r0 != 0 { ++ errcode = syscall.Errno(r0) ++ } ++ return ++} ++ ++func GetUnicastIpAddressEntry(row *MibUnicastIpAddressRow) (errcode error) { ++ r0, _, _ := syscall.Syscall(procGetUnicastIpAddressEntry.Addr(), 1, uintptr(unsafe.Pointer(row)), 0, 0) ++ if r0 != 0 { ++ errcode = syscall.Errno(r0) ++ } ++ return ++} ++ ++func NotifyIpInterfaceChange(family uint16, callback uintptr, callerContext unsafe.Pointer, initialNotification bool, notificationHandle *Handle) (errcode error) { ++ var _p0 uint32 ++ if initialNotification { ++ _p0 = 1 ++ } ++ r0, _, _ := syscall.Syscall6(procNotifyIpInterfaceChange.Addr(), 5, uintptr(family), uintptr(callback), uintptr(callerContext), uintptr(_p0), uintptr(unsafe.Pointer(notificationHandle)), 0) ++ if r0 != 0 { ++ errcode = syscall.Errno(r0) ++ } ++ return ++} ++ ++func NotifyUnicastIpAddressChange(family uint16, callback uintptr, callerContext unsafe.Pointer, initialNotification bool, notificationHandle *Handle) (errcode error) { ++ var _p0 uint32 ++ if initialNotification { ++ _p0 = 1 ++ } ++ r0, _, _ := syscall.Syscall6(procNotifyUnicastIpAddressChange.Addr(), 5, uintptr(family), uintptr(callback), uintptr(callerContext), uintptr(_p0), uintptr(unsafe.Pointer(notificationHandle)), 0) ++ if r0 != 0 { ++ errcode = syscall.Errno(r0) ++ } ++ return ++} ++ + func AddDllDirectory(path *uint16) (cookie uintptr, err error) { + r0, _, e1 := syscall.Syscall(procAddDllDirectory.Addr(), 1, uintptr(unsafe.Pointer(path)), 0, 0) + cookie = uintptr(r0) +@@ -2162,6 +2221,15 @@ func GetComputerName(buf *uint16, n *uint32) (err error) { + return + } + ++func GetConsoleCP() (cp uint32, err error) { ++ r0, _, e1 := syscall.Syscall(procGetConsoleCP.Addr(), 0, 0, 0, 0) ++ cp = uint32(r0) ++ if cp == 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ + func GetConsoleMode(console Handle, mode *uint32) (err error) { + r1, _, e1 := syscall.Syscall(procGetConsoleMode.Addr(), 2, uintptr(console), uintptr(unsafe.Pointer(mode)), 0) + if r1 == 0 { +@@ -2170,6 +2238,15 @@ func GetConsoleMode(console Handle, mode *uint32) (err error) { + return + } + ++func GetConsoleOutputCP() (cp uint32, err error) { ++ r0, _, e1 := syscall.Syscall(procGetConsoleOutputCP.Addr(), 0, 0, 0, 0) ++ cp = uint32(r0) ++ if cp == 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ + func GetConsoleScreenBufferInfo(console Handle, info *ConsoleScreenBufferInfo) (err error) { + r1, _, e1 := syscall.Syscall(procGetConsoleScreenBufferInfo.Addr(), 2, uintptr(console), uintptr(unsafe.Pointer(info)), 0) + if r1 == 0 { +@@ -2371,6 +2448,14 @@ func GetModuleHandleEx(flags uint32, moduleName *uint16, module *Handle) (err er + return + } + ++func GetNamedPipeClientProcessId(pipe Handle, clientProcessID *uint32) (err error) { ++ r1, _, e1 := syscall.Syscall(procGetNamedPipeClientProcessId.Addr(), 2, uintptr(pipe), uintptr(unsafe.Pointer(clientProcessID)), 0) ++ if r1 == 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ + func GetNamedPipeHandleState(pipe Handle, state *uint32, curInstances *uint32, maxCollectionCount *uint32, collectDataTimeout *uint32, userName *uint16, maxUserNameSize uint32) (err error) { + r1, _, e1 := syscall.Syscall9(procGetNamedPipeHandleStateW.Addr(), 7, uintptr(pipe), uintptr(unsafe.Pointer(state)), uintptr(unsafe.Pointer(curInstances)), uintptr(unsafe.Pointer(maxCollectionCount)), uintptr(unsafe.Pointer(collectDataTimeout)), uintptr(unsafe.Pointer(userName)), uintptr(maxUserNameSize), 0, 0) + if r1 == 0 { +@@ -2387,6 +2472,14 @@ func GetNamedPipeInfo(pipe Handle, flags *uint32, outSize *uint32, inSize *uint3 + return + } + ++func GetNamedPipeServerProcessId(pipe Handle, serverProcessID *uint32) (err error) { ++ r1, _, e1 := syscall.Syscall(procGetNamedPipeServerProcessId.Addr(), 2, uintptr(pipe), uintptr(unsafe.Pointer(serverProcessID)), 0) ++ if r1 == 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ + func GetOverlappedResult(handle Handle, overlapped *Overlapped, done *uint32, wait bool) (err error) { + var _p0 uint32 + if wait { +@@ -3038,6 +3131,14 @@ func SetCommTimeouts(handle Handle, timeouts *CommTimeouts) (err error) { + return + } + ++func SetConsoleCP(cp uint32) (err error) { ++ r1, _, e1 := syscall.Syscall(procSetConsoleCP.Addr(), 1, uintptr(cp), 0, 0) ++ if r1 == 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ + func setConsoleCursorPosition(console Handle, position uint32) (err error) { + r1, _, e1 := syscall.Syscall(procSetConsoleCursorPosition.Addr(), 2, uintptr(console), uintptr(position), 0) + if r1 == 0 { +@@ -3054,6 +3155,14 @@ func SetConsoleMode(console Handle, mode uint32) (err error) { + return + } + ++func SetConsoleOutputCP(cp uint32) (err error) { ++ r1, _, e1 := syscall.Syscall(procSetConsoleOutputCP.Addr(), 1, uintptr(cp), 0, 0) ++ if r1 == 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ + func SetCurrentDirectory(path *uint16) (err error) { + r1, _, e1 := syscall.Syscall(procSetCurrentDirectoryW.Addr(), 1, uintptr(unsafe.Pointer(path)), 0, 0) + if r1 == 0 { +diff --git a/vendor/modules.txt b/vendor/modules.txt +index 6b39e77..be1b84e 100644 +--- a/vendor/modules.txt ++++ b/vendor/modules.txt +@@ -152,7 +152,7 @@ go.uber.org/zap/internal/exit + go.uber.org/zap/internal/pool + go.uber.org/zap/internal/stacktrace + go.uber.org/zap/zapcore +-# golang.org/x/net v0.28.0 ++# golang.org/x/net v0.33.0 + ## explicit; go 1.18 + golang.org/x/net/http/httpguts + golang.org/x/net/http2 +@@ -160,11 +160,11 @@ golang.org/x/net/http2/hpack + golang.org/x/net/idna + golang.org/x/net/internal/timeseries + golang.org/x/net/trace +-# golang.org/x/sys v0.23.0 ++# golang.org/x/sys v0.28.0 + ## explicit; go 1.18 + golang.org/x/sys/unix + golang.org/x/sys/windows +-# golang.org/x/text v0.17.0 ++# golang.org/x/text v0.21.0 + ## explicit; go 1.18 + golang.org/x/text/secure/bidirule + golang.org/x/text/transform +-- +2.40.1 +