diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index d8be4b05..e4136761 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -31,7 +31,7 @@ jobs: - name: Flake check run: | - nix check . + nix flake check . build-images: runs-on: ubuntu-latest diff --git a/services/go.mod b/services/go.mod index 966bcb7e..aa01869d 100644 --- a/services/go.mod +++ b/services/go.mod @@ -2,11 +2,15 @@ module github.com/cottand/selfhosted/services go 1.22.3 -require github.com/prometheus/client_golang v1.19.1 +require ( + github.com/monzo/terrors v0.0.0-20240312165114-073654f2beb9 + github.com/prometheus/client_golang v1.19.1 +) require ( github.com/beorn7/perks v1.0.1 // indirect github.com/cespare/xxhash/v2 v2.2.0 // indirect + github.com/golang/protobuf v1.5.3 // indirect github.com/prometheus/client_model v0.5.0 // indirect github.com/prometheus/common v0.48.0 // indirect github.com/prometheus/procfs v0.12.0 // indirect diff --git a/services/go.sum b/services/go.sum index 11fc1a0b..0a97bcd4 100644 --- a/services/go.sum +++ b/services/go.sum @@ -4,8 +4,16 @@ github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk= +github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg= +github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= +github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/monzo/terrors v0.0.0-20240312165114-073654f2beb9 h1:xAJ8jVUVP8YCaw0On91gvdWPolfdGurz8o/j8VP7AvM= +github.com/monzo/terrors v0.0.0-20240312165114-073654f2beb9/go.mod h1:nyaPwtZHdNA0F89nwV24ePEsxKlmV3i1dwBxajbqaM8= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/prometheus/client_golang v1.19.1 h1:wZWJDwK+NameRJuPGDhlnFgx8e8HN3XHQeLaYJFJBOE= github.com/prometheus/client_golang v1.19.1/go.mod h1:mP78NwGzrVks5S2H6ab8+ZZGJLZUq1hoULYBAYBw1Ho= github.com/prometheus/client_model v0.5.0 h1:VQw1hfvPvk3Uv6Qf29VrPF32JB6rtbgI6cYPYQjL0Qw= @@ -14,7 +22,14 @@ github.com/prometheus/common v0.48.0 h1:QO8U2CdOzSn1BBsmXJXduaaW+dY/5QLjfB8svtSz github.com/prometheus/common v0.48.0/go.mod h1:0/KsvlIEfPQCQ5I2iNSAWKPZziNCvRs5EC6ILDTlAPc= github.com/prometheus/procfs v0.12.0 h1:jluTpSng7V9hY0O2R9DzzJHYb2xULk9VTR1V1R/k6Bo= github.com/prometheus/procfs v0.12.0/go.mod h1:pcuDEFsWDnvcgNzo4EEweacyhjeA9Zk3cnaOZAZEfOo= +github.com/stretchr/testify v1.6.1 h1:hDPOHmpOpP40lSULcqw7IrRb/u7w6RpDC9399XyoNd0= +github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= golang.org/x/sys v0.17.0 h1:25cE3gD+tdBA7lp7QfhuV+rJiE9YXTcS3VG1SqssI/Y= golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw= +google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= google.golang.org/protobuf v1.33.0 h1:uNO2rsAINq/JlFpSdYEKIZ0uKD/R9cpdv0T+yoGwGmI= google.golang.org/protobuf v1.33.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos= +gopkg.in/yaml.v3 v3.0.0-20200615113413-eeeca48fe776 h1:tQIYjPdBoyREyB9XMu+nnTclpTYkz2zFM+lzLJFO4gQ= +gopkg.in/yaml.v3 v3.0.0-20200615113413-eeeca48fe776/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/services/lib/bedrock/init.go b/services/lib/bedrock/init.go index fe14e5ac..3bdee680 100644 --- a/services/lib/bedrock/init.go +++ b/services/lib/bedrock/init.go @@ -1,12 +1,53 @@ package bedrock -import "net/http" +import ( + "fmt" + "log/slog" + "net/http" + "os" + "strconv" +) import ( + "github.com/monzo/terrors" "github.com/prometheus/client_golang/prometheus/promhttp" ) func Init() { http.Handle("/metrics", promhttp.Handler()) - http.ListenAndServe(":2112", nil) + + logger := slog.New(slog.NewJSONHandler(os.Stdout, nil)) + + slog.SetDefault(logger) + + slog.Info("Bedrock initialized") +} + +func GetBaseConfig() (*BaseConfig, error) { + port, ok := os.LookupEnv("HTTP_PORT") + if !ok { + return nil, terrors.New("no_env", "missing env config for http port", nil) + } + portNum, err := strconv.Atoi(port) + if err != nil { + return nil, terrors.Augment(err, "invalid env config for http port", nil) + } + host, ok := os.LookupEnv("HTTP_HOST") + if !ok { + return nil, terrors.New("no_env", "missing env config for http host", nil) + } + + return &BaseConfig{ + HttpHost: host, + HttpPort: portNum, + }, nil +} + +type BaseConfig struct { + HttpHost string + HttpPort int +} + +func (c *BaseConfig) HttpBind() string { + return fmt.Sprint(c.HttpHost, ":", strconv.Itoa(c.HttpPort)) } diff --git a/services/s-portfolio-stats/main.go b/services/s-portfolio-stats/main.go index bd4c683d..c90fd17b 100644 --- a/services/s-portfolio-stats/main.go +++ b/services/s-portfolio-stats/main.go @@ -1,12 +1,23 @@ package main -import "time" +import ( + "github.com/monzo/terrors" + "log/slog" + "net/http" +) import "github.com/cottand/selfhosted/services/lib/bedrock" func main() { bedrock.Init() - for { - time.Sleep(3 * time.Second) - println("hello world from service!") + conf, err := bedrock.GetBaseConfig() + if err != nil { + slog.Error(err.Error()) + panic(err) + } + + err = http.ListenAndServe(conf.HttpBind(), nil) + if err != nil { + slog.Error(terrors.Augment(err, "failed to start server", nil).Error()) + panic(err) } } diff --git a/services/vendor/github.com/cespare/xxhash/v2/README.md b/services/vendor/github.com/cespare/xxhash/v2/README.md index 33c88305..8bf0e5b7 100644 --- a/services/vendor/github.com/cespare/xxhash/v2/README.md +++ b/services/vendor/github.com/cespare/xxhash/v2/README.md @@ -70,5 +70,3 @@ benchstat <(go test -benchtime 500ms -count 15 -bench 'Sum64$') - [VictoriaMetrics](https://github.com/VictoriaMetrics/VictoriaMetrics) - [FreeCache](https://github.com/coocood/freecache) - [FastCache](https://github.com/VictoriaMetrics/fastcache) -- [Ristretto](https://github.com/dgraph-io/ristretto) -- [Badger](https://github.com/dgraph-io/badger) diff --git a/services/vendor/github.com/cespare/xxhash/v2/xxhash.go b/services/vendor/github.com/cespare/xxhash/v2/xxhash.go index 78bddf1c..a9e0d45c 100644 --- a/services/vendor/github.com/cespare/xxhash/v2/xxhash.go +++ b/services/vendor/github.com/cespare/xxhash/v2/xxhash.go @@ -19,13 +19,10 @@ const ( // Store the primes in an array as well. // // The consts are used when possible in Go code to avoid MOVs but we need a -// contiguous array for the assembly code. +// contiguous array of the assembly code. var primes = [...]uint64{prime1, prime2, prime3, prime4, prime5} // Digest implements hash.Hash64. -// -// Note that a zero-valued Digest is not ready to receive writes. -// Call Reset or create a Digest using New before calling other methods. type Digest struct { v1 uint64 v2 uint64 @@ -36,31 +33,19 @@ type Digest struct { n int // how much of mem is used } -// New creates a new Digest with a zero seed. +// New creates a new Digest that computes the 64-bit xxHash algorithm. func New() *Digest { - return NewWithSeed(0) -} - -// NewWithSeed creates a new Digest with the given seed. -func NewWithSeed(seed uint64) *Digest { var d Digest - d.ResetWithSeed(seed) + d.Reset() return &d } // Reset clears the Digest's state so that it can be reused. -// It uses a seed value of zero. func (d *Digest) Reset() { - d.ResetWithSeed(0) -} - -// ResetWithSeed clears the Digest's state so that it can be reused. -// It uses the given seed to initialize the state. -func (d *Digest) ResetWithSeed(seed uint64) { - d.v1 = seed + prime1 + prime2 - d.v2 = seed + prime2 - d.v3 = seed - d.v4 = seed - prime1 + d.v1 = primes[0] + prime2 + d.v2 = prime2 + d.v3 = 0 + d.v4 = -primes[0] d.total = 0 d.n = 0 } diff --git a/services/vendor/github.com/cespare/xxhash/v2/xxhash_asm.go b/services/vendor/github.com/cespare/xxhash/v2/xxhash_asm.go index 78f95f25..9216e0a4 100644 --- a/services/vendor/github.com/cespare/xxhash/v2/xxhash_asm.go +++ b/services/vendor/github.com/cespare/xxhash/v2/xxhash_asm.go @@ -6,7 +6,7 @@ package xxhash -// Sum64 computes the 64-bit xxHash digest of b with a zero seed. +// Sum64 computes the 64-bit xxHash digest of b. // //go:noescape func Sum64(b []byte) uint64 diff --git a/services/vendor/github.com/cespare/xxhash/v2/xxhash_other.go b/services/vendor/github.com/cespare/xxhash/v2/xxhash_other.go index 118e49e8..26df13bb 100644 --- a/services/vendor/github.com/cespare/xxhash/v2/xxhash_other.go +++ b/services/vendor/github.com/cespare/xxhash/v2/xxhash_other.go @@ -3,7 +3,7 @@ package xxhash -// Sum64 computes the 64-bit xxHash digest of b with a zero seed. +// Sum64 computes the 64-bit xxHash digest of b. func Sum64(b []byte) uint64 { // A simpler version would be // d := New() diff --git a/services/vendor/github.com/cespare/xxhash/v2/xxhash_safe.go b/services/vendor/github.com/cespare/xxhash/v2/xxhash_safe.go index 05f5e7df..e86f1b5f 100644 --- a/services/vendor/github.com/cespare/xxhash/v2/xxhash_safe.go +++ b/services/vendor/github.com/cespare/xxhash/v2/xxhash_safe.go @@ -5,7 +5,7 @@ package xxhash -// Sum64String computes the 64-bit xxHash digest of s with a zero seed. +// Sum64String computes the 64-bit xxHash digest of s. func Sum64String(s string) uint64 { return Sum64([]byte(s)) } diff --git a/services/vendor/github.com/cespare/xxhash/v2/xxhash_unsafe.go b/services/vendor/github.com/cespare/xxhash/v2/xxhash_unsafe.go index cf9d42ae..1c1638fd 100644 --- a/services/vendor/github.com/cespare/xxhash/v2/xxhash_unsafe.go +++ b/services/vendor/github.com/cespare/xxhash/v2/xxhash_unsafe.go @@ -33,7 +33,7 @@ import ( // // See https://github.com/golang/go/issues/42739 for discussion. -// Sum64String computes the 64-bit xxHash digest of s with a zero seed. +// Sum64String computes the 64-bit xxHash digest of s. // It may be faster than Sum64([]byte(s)) by avoiding a copy. func Sum64String(s string) uint64 { b := *(*[]byte)(unsafe.Pointer(&sliceHeader{s, len(s)})) diff --git a/services/vendor/github.com/golang/protobuf/AUTHORS b/services/vendor/github.com/golang/protobuf/AUTHORS new file mode 100644 index 00000000..15167cd7 --- /dev/null +++ b/services/vendor/github.com/golang/protobuf/AUTHORS @@ -0,0 +1,3 @@ +# This source code refers to The Go Authors for copyright purposes. +# The master list of authors is in the main Go distribution, +# visible at http://tip.golang.org/AUTHORS. diff --git a/services/vendor/github.com/golang/protobuf/CONTRIBUTORS b/services/vendor/github.com/golang/protobuf/CONTRIBUTORS new file mode 100644 index 00000000..1c4577e9 --- /dev/null +++ b/services/vendor/github.com/golang/protobuf/CONTRIBUTORS @@ -0,0 +1,3 @@ +# This source code was written by the Go contributors. +# The master list of contributors is in the main Go distribution, +# visible at http://tip.golang.org/CONTRIBUTORS. diff --git a/services/vendor/github.com/munnerz/goautoneg/LICENSE b/services/vendor/github.com/golang/protobuf/LICENSE similarity index 53% rename from services/vendor/github.com/munnerz/goautoneg/LICENSE rename to services/vendor/github.com/golang/protobuf/LICENSE index bbc7b897..0f646931 100644 --- a/services/vendor/github.com/munnerz/goautoneg/LICENSE +++ b/services/vendor/github.com/golang/protobuf/LICENSE @@ -1,31 +1,28 @@ -Copyright (c) 2011, Open Knowledge Foundation Ltd. -All rights reserved. +Copyright 2010 The Go Authors. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: - Redistributions of source code must retain the above copyright - notice, this list of conditions and the following disclaimer. - - Redistributions in binary form must reproduce the above copyright - notice, this list of conditions and the following disclaimer in - the documentation and/or other materials provided with the - distribution. - - Neither the name of the Open Knowledge Foundation Ltd. nor the - names of its contributors may be used to endorse or promote - products derived from this software without specific prior written - permission. + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + diff --git a/services/vendor/github.com/golang/protobuf/proto/buffer.go b/services/vendor/github.com/golang/protobuf/proto/buffer.go new file mode 100644 index 00000000..e810e6fe --- /dev/null +++ b/services/vendor/github.com/golang/protobuf/proto/buffer.go @@ -0,0 +1,324 @@ +// Copyright 2019 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 proto + +import ( + "errors" + "fmt" + + "google.golang.org/protobuf/encoding/prototext" + "google.golang.org/protobuf/encoding/protowire" + "google.golang.org/protobuf/runtime/protoimpl" +) + +const ( + WireVarint = 0 + WireFixed32 = 5 + WireFixed64 = 1 + WireBytes = 2 + WireStartGroup = 3 + WireEndGroup = 4 +) + +// EncodeVarint returns the varint encoded bytes of v. +func EncodeVarint(v uint64) []byte { + return protowire.AppendVarint(nil, v) +} + +// SizeVarint returns the length of the varint encoded bytes of v. +// This is equal to len(EncodeVarint(v)). +func SizeVarint(v uint64) int { + return protowire.SizeVarint(v) +} + +// DecodeVarint parses a varint encoded integer from b, +// returning the integer value and the length of the varint. +// It returns (0, 0) if there is a parse error. +func DecodeVarint(b []byte) (uint64, int) { + v, n := protowire.ConsumeVarint(b) + if n < 0 { + return 0, 0 + } + return v, n +} + +// Buffer is a buffer for encoding and decoding the protobuf wire format. +// It may be reused between invocations to reduce memory usage. +type Buffer struct { + buf []byte + idx int + deterministic bool +} + +// NewBuffer allocates a new Buffer initialized with buf, +// where the contents of buf are considered the unread portion of the buffer. +func NewBuffer(buf []byte) *Buffer { + return &Buffer{buf: buf} +} + +// SetDeterministic specifies whether to use deterministic serialization. +// +// Deterministic serialization guarantees that for a given binary, equal +// messages will always be serialized to the same bytes. This implies: +// +// - Repeated serialization of a message will return the same bytes. +// - Different processes of the same binary (which may be executing on +// different machines) will serialize equal messages to the same bytes. +// +// Note that the deterministic serialization is NOT canonical across +// languages. It is not guaranteed to remain stable over time. It is unstable +// across different builds with schema changes due to unknown fields. +// Users who need canonical serialization (e.g., persistent storage in a +// canonical form, fingerprinting, etc.) should define their own +// canonicalization specification and implement their own serializer rather +// than relying on this API. +// +// If deterministic serialization is requested, map entries will be sorted +// by keys in lexographical order. This is an implementation detail and +// subject to change. +func (b *Buffer) SetDeterministic(deterministic bool) { + b.deterministic = deterministic +} + +// SetBuf sets buf as the internal buffer, +// where the contents of buf are considered the unread portion of the buffer. +func (b *Buffer) SetBuf(buf []byte) { + b.buf = buf + b.idx = 0 +} + +// Reset clears the internal buffer of all written and unread data. +func (b *Buffer) Reset() { + b.buf = b.buf[:0] + b.idx = 0 +} + +// Bytes returns the internal buffer. +func (b *Buffer) Bytes() []byte { + return b.buf +} + +// Unread returns the unread portion of the buffer. +func (b *Buffer) Unread() []byte { + return b.buf[b.idx:] +} + +// Marshal appends the wire-format encoding of m to the buffer. +func (b *Buffer) Marshal(m Message) error { + var err error + b.buf, err = marshalAppend(b.buf, m, b.deterministic) + return err +} + +// Unmarshal parses the wire-format message in the buffer and +// places the decoded results in m. +// It does not reset m before unmarshaling. +func (b *Buffer) Unmarshal(m Message) error { + err := UnmarshalMerge(b.Unread(), m) + b.idx = len(b.buf) + return err +} + +type unknownFields struct{ XXX_unrecognized protoimpl.UnknownFields } + +func (m *unknownFields) String() string { panic("not implemented") } +func (m *unknownFields) Reset() { panic("not implemented") } +func (m *unknownFields) ProtoMessage() { panic("not implemented") } + +// DebugPrint dumps the encoded bytes of b with a header and footer including s +// to stdout. This is only intended for debugging. +func (*Buffer) DebugPrint(s string, b []byte) { + m := MessageReflect(new(unknownFields)) + m.SetUnknown(b) + b, _ = prototext.MarshalOptions{AllowPartial: true, Indent: "\t"}.Marshal(m.Interface()) + fmt.Printf("==== %s ====\n%s==== %s ====\n", s, b, s) +} + +// EncodeVarint appends an unsigned varint encoding to the buffer. +func (b *Buffer) EncodeVarint(v uint64) error { + b.buf = protowire.AppendVarint(b.buf, v) + return nil +} + +// EncodeZigzag32 appends a 32-bit zig-zag varint encoding to the buffer. +func (b *Buffer) EncodeZigzag32(v uint64) error { + return b.EncodeVarint(uint64((uint32(v) << 1) ^ uint32((int32(v) >> 31)))) +} + +// EncodeZigzag64 appends a 64-bit zig-zag varint encoding to the buffer. +func (b *Buffer) EncodeZigzag64(v uint64) error { + return b.EncodeVarint(uint64((uint64(v) << 1) ^ uint64((int64(v) >> 63)))) +} + +// EncodeFixed32 appends a 32-bit little-endian integer to the buffer. +func (b *Buffer) EncodeFixed32(v uint64) error { + b.buf = protowire.AppendFixed32(b.buf, uint32(v)) + return nil +} + +// EncodeFixed64 appends a 64-bit little-endian integer to the buffer. +func (b *Buffer) EncodeFixed64(v uint64) error { + b.buf = protowire.AppendFixed64(b.buf, uint64(v)) + return nil +} + +// EncodeRawBytes appends a length-prefixed raw bytes to the buffer. +func (b *Buffer) EncodeRawBytes(v []byte) error { + b.buf = protowire.AppendBytes(b.buf, v) + return nil +} + +// EncodeStringBytes appends a length-prefixed raw bytes to the buffer. +// It does not validate whether v contains valid UTF-8. +func (b *Buffer) EncodeStringBytes(v string) error { + b.buf = protowire.AppendString(b.buf, v) + return nil +} + +// EncodeMessage appends a length-prefixed encoded message to the buffer. +func (b *Buffer) EncodeMessage(m Message) error { + var err error + b.buf = protowire.AppendVarint(b.buf, uint64(Size(m))) + b.buf, err = marshalAppend(b.buf, m, b.deterministic) + return err +} + +// DecodeVarint consumes an encoded unsigned varint from the buffer. +func (b *Buffer) DecodeVarint() (uint64, error) { + v, n := protowire.ConsumeVarint(b.buf[b.idx:]) + if n < 0 { + return 0, protowire.ParseError(n) + } + b.idx += n + return uint64(v), nil +} + +// DecodeZigzag32 consumes an encoded 32-bit zig-zag varint from the buffer. +func (b *Buffer) DecodeZigzag32() (uint64, error) { + v, err := b.DecodeVarint() + if err != nil { + return 0, err + } + return uint64((uint32(v) >> 1) ^ uint32((int32(v&1)<<31)>>31)), nil +} + +// DecodeZigzag64 consumes an encoded 64-bit zig-zag varint from the buffer. +func (b *Buffer) DecodeZigzag64() (uint64, error) { + v, err := b.DecodeVarint() + if err != nil { + return 0, err + } + return uint64((uint64(v) >> 1) ^ uint64((int64(v&1)<<63)>>63)), nil +} + +// DecodeFixed32 consumes a 32-bit little-endian integer from the buffer. +func (b *Buffer) DecodeFixed32() (uint64, error) { + v, n := protowire.ConsumeFixed32(b.buf[b.idx:]) + if n < 0 { + return 0, protowire.ParseError(n) + } + b.idx += n + return uint64(v), nil +} + +// DecodeFixed64 consumes a 64-bit little-endian integer from the buffer. +func (b *Buffer) DecodeFixed64() (uint64, error) { + v, n := protowire.ConsumeFixed64(b.buf[b.idx:]) + if n < 0 { + return 0, protowire.ParseError(n) + } + b.idx += n + return uint64(v), nil +} + +// DecodeRawBytes consumes a length-prefixed raw bytes from the buffer. +// If alloc is specified, it returns a copy the raw bytes +// rather than a sub-slice of the buffer. +func (b *Buffer) DecodeRawBytes(alloc bool) ([]byte, error) { + v, n := protowire.ConsumeBytes(b.buf[b.idx:]) + if n < 0 { + return nil, protowire.ParseError(n) + } + b.idx += n + if alloc { + v = append([]byte(nil), v...) + } + return v, nil +} + +// DecodeStringBytes consumes a length-prefixed raw bytes from the buffer. +// It does not validate whether the raw bytes contain valid UTF-8. +func (b *Buffer) DecodeStringBytes() (string, error) { + v, n := protowire.ConsumeString(b.buf[b.idx:]) + if n < 0 { + return "", protowire.ParseError(n) + } + b.idx += n + return v, nil +} + +// DecodeMessage consumes a length-prefixed message from the buffer. +// It does not reset m before unmarshaling. +func (b *Buffer) DecodeMessage(m Message) error { + v, err := b.DecodeRawBytes(false) + if err != nil { + return err + } + return UnmarshalMerge(v, m) +} + +// DecodeGroup consumes a message group from the buffer. +// It assumes that the start group marker has already been consumed and +// consumes all bytes until (and including the end group marker). +// It does not reset m before unmarshaling. +func (b *Buffer) DecodeGroup(m Message) error { + v, n, err := consumeGroup(b.buf[b.idx:]) + if err != nil { + return err + } + b.idx += n + return UnmarshalMerge(v, m) +} + +// consumeGroup parses b until it finds an end group marker, returning +// the raw bytes of the message (excluding the end group marker) and the +// the total length of the message (including the end group marker). +func consumeGroup(b []byte) ([]byte, int, error) { + b0 := b + depth := 1 // assume this follows a start group marker + for { + _, wtyp, tagLen := protowire.ConsumeTag(b) + if tagLen < 0 { + return nil, 0, protowire.ParseError(tagLen) + } + b = b[tagLen:] + + var valLen int + switch wtyp { + case protowire.VarintType: + _, valLen = protowire.ConsumeVarint(b) + case protowire.Fixed32Type: + _, valLen = protowire.ConsumeFixed32(b) + case protowire.Fixed64Type: + _, valLen = protowire.ConsumeFixed64(b) + case protowire.BytesType: + _, valLen = protowire.ConsumeBytes(b) + case protowire.StartGroupType: + depth++ + case protowire.EndGroupType: + depth-- + default: + return nil, 0, errors.New("proto: cannot parse reserved wire type") + } + if valLen < 0 { + return nil, 0, protowire.ParseError(valLen) + } + b = b[valLen:] + + if depth == 0 { + return b0[:len(b0)-len(b)-tagLen], len(b0) - len(b), nil + } + } +} diff --git a/services/vendor/github.com/golang/protobuf/proto/defaults.go b/services/vendor/github.com/golang/protobuf/proto/defaults.go new file mode 100644 index 00000000..d399bf06 --- /dev/null +++ b/services/vendor/github.com/golang/protobuf/proto/defaults.go @@ -0,0 +1,63 @@ +// Copyright 2019 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 proto + +import ( + "google.golang.org/protobuf/reflect/protoreflect" +) + +// SetDefaults sets unpopulated scalar fields to their default values. +// Fields within a oneof are not set even if they have a default value. +// SetDefaults is recursively called upon any populated message fields. +func SetDefaults(m Message) { + if m != nil { + setDefaults(MessageReflect(m)) + } +} + +func setDefaults(m protoreflect.Message) { + fds := m.Descriptor().Fields() + for i := 0; i < fds.Len(); i++ { + fd := fds.Get(i) + if !m.Has(fd) { + if fd.HasDefault() && fd.ContainingOneof() == nil { + v := fd.Default() + if fd.Kind() == protoreflect.BytesKind { + v = protoreflect.ValueOf(append([]byte(nil), v.Bytes()...)) // copy the default bytes + } + m.Set(fd, v) + } + continue + } + } + + m.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool { + switch { + // Handle singular message. + case fd.Cardinality() != protoreflect.Repeated: + if fd.Message() != nil { + setDefaults(m.Get(fd).Message()) + } + // Handle list of messages. + case fd.IsList(): + if fd.Message() != nil { + ls := m.Get(fd).List() + for i := 0; i < ls.Len(); i++ { + setDefaults(ls.Get(i).Message()) + } + } + // Handle map of messages. + case fd.IsMap(): + if fd.MapValue().Message() != nil { + ms := m.Get(fd).Map() + ms.Range(func(_ protoreflect.MapKey, v protoreflect.Value) bool { + setDefaults(v.Message()) + return true + }) + } + } + return true + }) +} diff --git a/services/vendor/github.com/golang/protobuf/proto/deprecated.go b/services/vendor/github.com/golang/protobuf/proto/deprecated.go new file mode 100644 index 00000000..e8db57e0 --- /dev/null +++ b/services/vendor/github.com/golang/protobuf/proto/deprecated.go @@ -0,0 +1,113 @@ +// Copyright 2018 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 proto + +import ( + "encoding/json" + "errors" + "fmt" + "strconv" + + protoV2 "google.golang.org/protobuf/proto" +) + +var ( + // Deprecated: No longer returned. + ErrNil = errors.New("proto: Marshal called with nil") + + // Deprecated: No longer returned. + ErrTooLarge = errors.New("proto: message encodes to over 2 GB") + + // Deprecated: No longer returned. + ErrInternalBadWireType = errors.New("proto: internal error: bad wiretype for oneof") +) + +// Deprecated: Do not use. +type Stats struct{ Emalloc, Dmalloc, Encode, Decode, Chit, Cmiss, Size uint64 } + +// Deprecated: Do not use. +func GetStats() Stats { return Stats{} } + +// Deprecated: Do not use. +func MarshalMessageSet(interface{}) ([]byte, error) { + return nil, errors.New("proto: not implemented") +} + +// Deprecated: Do not use. +func UnmarshalMessageSet([]byte, interface{}) error { + return errors.New("proto: not implemented") +} + +// Deprecated: Do not use. +func MarshalMessageSetJSON(interface{}) ([]byte, error) { + return nil, errors.New("proto: not implemented") +} + +// Deprecated: Do not use. +func UnmarshalMessageSetJSON([]byte, interface{}) error { + return errors.New("proto: not implemented") +} + +// Deprecated: Do not use. +func RegisterMessageSetType(Message, int32, string) {} + +// Deprecated: Do not use. +func EnumName(m map[int32]string, v int32) string { + s, ok := m[v] + if ok { + return s + } + return strconv.Itoa(int(v)) +} + +// Deprecated: Do not use. +func UnmarshalJSONEnum(m map[string]int32, data []byte, enumName string) (int32, error) { + if data[0] == '"' { + // New style: enums are strings. + var repr string + if err := json.Unmarshal(data, &repr); err != nil { + return -1, err + } + val, ok := m[repr] + if !ok { + return 0, fmt.Errorf("unrecognized enum %s value %q", enumName, repr) + } + return val, nil + } + // Old style: enums are ints. + var val int32 + if err := json.Unmarshal(data, &val); err != nil { + return 0, fmt.Errorf("cannot unmarshal %#q into enum %s", data, enumName) + } + return val, nil +} + +// Deprecated: Do not use; this type existed for intenal-use only. +type InternalMessageInfo struct{} + +// Deprecated: Do not use; this method existed for intenal-use only. +func (*InternalMessageInfo) DiscardUnknown(m Message) { + DiscardUnknown(m) +} + +// Deprecated: Do not use; this method existed for intenal-use only. +func (*InternalMessageInfo) Marshal(b []byte, m Message, deterministic bool) ([]byte, error) { + return protoV2.MarshalOptions{Deterministic: deterministic}.MarshalAppend(b, MessageV2(m)) +} + +// Deprecated: Do not use; this method existed for intenal-use only. +func (*InternalMessageInfo) Merge(dst, src Message) { + protoV2.Merge(MessageV2(dst), MessageV2(src)) +} + +// Deprecated: Do not use; this method existed for intenal-use only. +func (*InternalMessageInfo) Size(m Message) int { + return protoV2.Size(MessageV2(m)) +} + +// Deprecated: Do not use; this method existed for intenal-use only. +func (*InternalMessageInfo) Unmarshal(m Message, b []byte) error { + return protoV2.UnmarshalOptions{Merge: true}.Unmarshal(b, MessageV2(m)) +} diff --git a/services/vendor/github.com/golang/protobuf/proto/discard.go b/services/vendor/github.com/golang/protobuf/proto/discard.go new file mode 100644 index 00000000..2187e877 --- /dev/null +++ b/services/vendor/github.com/golang/protobuf/proto/discard.go @@ -0,0 +1,58 @@ +// Copyright 2019 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 proto + +import ( + "google.golang.org/protobuf/reflect/protoreflect" +) + +// DiscardUnknown recursively discards all unknown fields from this message +// and all embedded messages. +// +// When unmarshaling a message with unrecognized fields, the tags and values +// of such fields are preserved in the Message. This allows a later call to +// marshal to be able to produce a message that continues to have those +// unrecognized fields. To avoid this, DiscardUnknown is used to +// explicitly clear the unknown fields after unmarshaling. +func DiscardUnknown(m Message) { + if m != nil { + discardUnknown(MessageReflect(m)) + } +} + +func discardUnknown(m protoreflect.Message) { + m.Range(func(fd protoreflect.FieldDescriptor, val protoreflect.Value) bool { + switch { + // Handle singular message. + case fd.Cardinality() != protoreflect.Repeated: + if fd.Message() != nil { + discardUnknown(m.Get(fd).Message()) + } + // Handle list of messages. + case fd.IsList(): + if fd.Message() != nil { + ls := m.Get(fd).List() + for i := 0; i < ls.Len(); i++ { + discardUnknown(ls.Get(i).Message()) + } + } + // Handle map of messages. + case fd.IsMap(): + if fd.MapValue().Message() != nil { + ms := m.Get(fd).Map() + ms.Range(func(_ protoreflect.MapKey, v protoreflect.Value) bool { + discardUnknown(v.Message()) + return true + }) + } + } + return true + }) + + // Discard unknown fields. + if len(m.GetUnknown()) > 0 { + m.SetUnknown(nil) + } +} diff --git a/services/vendor/github.com/golang/protobuf/proto/extensions.go b/services/vendor/github.com/golang/protobuf/proto/extensions.go new file mode 100644 index 00000000..42fc120c --- /dev/null +++ b/services/vendor/github.com/golang/protobuf/proto/extensions.go @@ -0,0 +1,356 @@ +// Copyright 2010 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 proto + +import ( + "errors" + "fmt" + "reflect" + + "google.golang.org/protobuf/encoding/protowire" + "google.golang.org/protobuf/proto" + "google.golang.org/protobuf/reflect/protoreflect" + "google.golang.org/protobuf/reflect/protoregistry" + "google.golang.org/protobuf/runtime/protoiface" + "google.golang.org/protobuf/runtime/protoimpl" +) + +type ( + // ExtensionDesc represents an extension descriptor and + // is used to interact with an extension field in a message. + // + // Variables of this type are generated in code by protoc-gen-go. + ExtensionDesc = protoimpl.ExtensionInfo + + // ExtensionRange represents a range of message extensions. + // Used in code generated by protoc-gen-go. + ExtensionRange = protoiface.ExtensionRangeV1 + + // Deprecated: Do not use; this is an internal type. + Extension = protoimpl.ExtensionFieldV1 + + // Deprecated: Do not use; this is an internal type. + XXX_InternalExtensions = protoimpl.ExtensionFields +) + +// ErrMissingExtension reports whether the extension was not present. +var ErrMissingExtension = errors.New("proto: missing extension") + +var errNotExtendable = errors.New("proto: not an extendable proto.Message") + +// HasExtension reports whether the extension field is present in m +// either as an explicitly populated field or as an unknown field. +func HasExtension(m Message, xt *ExtensionDesc) (has bool) { + mr := MessageReflect(m) + if mr == nil || !mr.IsValid() { + return false + } + + // Check whether any populated known field matches the field number. + xtd := xt.TypeDescriptor() + if isValidExtension(mr.Descriptor(), xtd) { + has = mr.Has(xtd) + } else { + mr.Range(func(fd protoreflect.FieldDescriptor, _ protoreflect.Value) bool { + has = int32(fd.Number()) == xt.Field + return !has + }) + } + + // Check whether any unknown field matches the field number. + for b := mr.GetUnknown(); !has && len(b) > 0; { + num, _, n := protowire.ConsumeField(b) + has = int32(num) == xt.Field + b = b[n:] + } + return has +} + +// ClearExtension removes the extension field from m +// either as an explicitly populated field or as an unknown field. +func ClearExtension(m Message, xt *ExtensionDesc) { + mr := MessageReflect(m) + if mr == nil || !mr.IsValid() { + return + } + + xtd := xt.TypeDescriptor() + if isValidExtension(mr.Descriptor(), xtd) { + mr.Clear(xtd) + } else { + mr.Range(func(fd protoreflect.FieldDescriptor, _ protoreflect.Value) bool { + if int32(fd.Number()) == xt.Field { + mr.Clear(fd) + return false + } + return true + }) + } + clearUnknown(mr, fieldNum(xt.Field)) +} + +// ClearAllExtensions clears all extensions from m. +// This includes populated fields and unknown fields in the extension range. +func ClearAllExtensions(m Message) { + mr := MessageReflect(m) + if mr == nil || !mr.IsValid() { + return + } + + mr.Range(func(fd protoreflect.FieldDescriptor, _ protoreflect.Value) bool { + if fd.IsExtension() { + mr.Clear(fd) + } + return true + }) + clearUnknown(mr, mr.Descriptor().ExtensionRanges()) +} + +// GetExtension retrieves a proto2 extended field from m. +// +// If the descriptor is type complete (i.e., ExtensionDesc.ExtensionType is non-nil), +// then GetExtension parses the encoded field and returns a Go value of the specified type. +// If the field is not present, then the default value is returned (if one is specified), +// otherwise ErrMissingExtension is reported. +// +// If the descriptor is type incomplete (i.e., ExtensionDesc.ExtensionType is nil), +// then GetExtension returns the raw encoded bytes for the extension field. +func GetExtension(m Message, xt *ExtensionDesc) (interface{}, error) { + mr := MessageReflect(m) + if mr == nil || !mr.IsValid() || mr.Descriptor().ExtensionRanges().Len() == 0 { + return nil, errNotExtendable + } + + // Retrieve the unknown fields for this extension field. + var bo protoreflect.RawFields + for bi := mr.GetUnknown(); len(bi) > 0; { + num, _, n := protowire.ConsumeField(bi) + if int32(num) == xt.Field { + bo = append(bo, bi[:n]...) + } + bi = bi[n:] + } + + // For type incomplete descriptors, only retrieve the unknown fields. + if xt.ExtensionType == nil { + return []byte(bo), nil + } + + // If the extension field only exists as unknown fields, unmarshal it. + // This is rarely done since proto.Unmarshal eagerly unmarshals extensions. + xtd := xt.TypeDescriptor() + if !isValidExtension(mr.Descriptor(), xtd) { + return nil, fmt.Errorf("proto: bad extended type; %T does not extend %T", xt.ExtendedType, m) + } + if !mr.Has(xtd) && len(bo) > 0 { + m2 := mr.New() + if err := (proto.UnmarshalOptions{ + Resolver: extensionResolver{xt}, + }.Unmarshal(bo, m2.Interface())); err != nil { + return nil, err + } + if m2.Has(xtd) { + mr.Set(xtd, m2.Get(xtd)) + clearUnknown(mr, fieldNum(xt.Field)) + } + } + + // Check whether the message has the extension field set or a default. + var pv protoreflect.Value + switch { + case mr.Has(xtd): + pv = mr.Get(xtd) + case xtd.HasDefault(): + pv = xtd.Default() + default: + return nil, ErrMissingExtension + } + + v := xt.InterfaceOf(pv) + rv := reflect.ValueOf(v) + if isScalarKind(rv.Kind()) { + rv2 := reflect.New(rv.Type()) + rv2.Elem().Set(rv) + v = rv2.Interface() + } + return v, nil +} + +// extensionResolver is a custom extension resolver that stores a single +// extension type that takes precedence over the global registry. +type extensionResolver struct{ xt protoreflect.ExtensionType } + +func (r extensionResolver) FindExtensionByName(field protoreflect.FullName) (protoreflect.ExtensionType, error) { + if xtd := r.xt.TypeDescriptor(); xtd.FullName() == field { + return r.xt, nil + } + return protoregistry.GlobalTypes.FindExtensionByName(field) +} + +func (r extensionResolver) FindExtensionByNumber(message protoreflect.FullName, field protoreflect.FieldNumber) (protoreflect.ExtensionType, error) { + if xtd := r.xt.TypeDescriptor(); xtd.ContainingMessage().FullName() == message && xtd.Number() == field { + return r.xt, nil + } + return protoregistry.GlobalTypes.FindExtensionByNumber(message, field) +} + +// GetExtensions returns a list of the extensions values present in m, +// corresponding with the provided list of extension descriptors, xts. +// If an extension is missing in m, the corresponding value is nil. +func GetExtensions(m Message, xts []*ExtensionDesc) ([]interface{}, error) { + mr := MessageReflect(m) + if mr == nil || !mr.IsValid() { + return nil, errNotExtendable + } + + vs := make([]interface{}, len(xts)) + for i, xt := range xts { + v, err := GetExtension(m, xt) + if err != nil { + if err == ErrMissingExtension { + continue + } + return vs, err + } + vs[i] = v + } + return vs, nil +} + +// SetExtension sets an extension field in m to the provided value. +func SetExtension(m Message, xt *ExtensionDesc, v interface{}) error { + mr := MessageReflect(m) + if mr == nil || !mr.IsValid() || mr.Descriptor().ExtensionRanges().Len() == 0 { + return errNotExtendable + } + + rv := reflect.ValueOf(v) + if reflect.TypeOf(v) != reflect.TypeOf(xt.ExtensionType) { + return fmt.Errorf("proto: bad extension value type. got: %T, want: %T", v, xt.ExtensionType) + } + if rv.Kind() == reflect.Ptr { + if rv.IsNil() { + return fmt.Errorf("proto: SetExtension called with nil value of type %T", v) + } + if isScalarKind(rv.Elem().Kind()) { + v = rv.Elem().Interface() + } + } + + xtd := xt.TypeDescriptor() + if !isValidExtension(mr.Descriptor(), xtd) { + return fmt.Errorf("proto: bad extended type; %T does not extend %T", xt.ExtendedType, m) + } + mr.Set(xtd, xt.ValueOf(v)) + clearUnknown(mr, fieldNum(xt.Field)) + return nil +} + +// SetRawExtension inserts b into the unknown fields of m. +// +// Deprecated: Use Message.ProtoReflect.SetUnknown instead. +func SetRawExtension(m Message, fnum int32, b []byte) { + mr := MessageReflect(m) + if mr == nil || !mr.IsValid() { + return + } + + // Verify that the raw field is valid. + for b0 := b; len(b0) > 0; { + num, _, n := protowire.ConsumeField(b0) + if int32(num) != fnum { + panic(fmt.Sprintf("mismatching field number: got %d, want %d", num, fnum)) + } + b0 = b0[n:] + } + + ClearExtension(m, &ExtensionDesc{Field: fnum}) + mr.SetUnknown(append(mr.GetUnknown(), b...)) +} + +// ExtensionDescs returns a list of extension descriptors found in m, +// containing descriptors for both populated extension fields in m and +// also unknown fields of m that are in the extension range. +// For the later case, an type incomplete descriptor is provided where only +// the ExtensionDesc.Field field is populated. +// The order of the extension descriptors is undefined. +func ExtensionDescs(m Message) ([]*ExtensionDesc, error) { + mr := MessageReflect(m) + if mr == nil || !mr.IsValid() || mr.Descriptor().ExtensionRanges().Len() == 0 { + return nil, errNotExtendable + } + + // Collect a set of known extension descriptors. + extDescs := make(map[protoreflect.FieldNumber]*ExtensionDesc) + mr.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool { + if fd.IsExtension() { + xt := fd.(protoreflect.ExtensionTypeDescriptor) + if xd, ok := xt.Type().(*ExtensionDesc); ok { + extDescs[fd.Number()] = xd + } + } + return true + }) + + // Collect a set of unknown extension descriptors. + extRanges := mr.Descriptor().ExtensionRanges() + for b := mr.GetUnknown(); len(b) > 0; { + num, _, n := protowire.ConsumeField(b) + if extRanges.Has(num) && extDescs[num] == nil { + extDescs[num] = nil + } + b = b[n:] + } + + // Transpose the set of descriptors into a list. + var xts []*ExtensionDesc + for num, xt := range extDescs { + if xt == nil { + xt = &ExtensionDesc{Field: int32(num)} + } + xts = append(xts, xt) + } + return xts, nil +} + +// isValidExtension reports whether xtd is a valid extension descriptor for md. +func isValidExtension(md protoreflect.MessageDescriptor, xtd protoreflect.ExtensionTypeDescriptor) bool { + return xtd.ContainingMessage() == md && md.ExtensionRanges().Has(xtd.Number()) +} + +// isScalarKind reports whether k is a protobuf scalar kind (except bytes). +// This function exists for historical reasons since the representation of +// scalars differs between v1 and v2, where v1 uses *T and v2 uses T. +func isScalarKind(k reflect.Kind) bool { + switch k { + case reflect.Bool, reflect.Int32, reflect.Int64, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64, reflect.String: + return true + default: + return false + } +} + +// clearUnknown removes unknown fields from m where remover.Has reports true. +func clearUnknown(m protoreflect.Message, remover interface { + Has(protoreflect.FieldNumber) bool +}) { + var bo protoreflect.RawFields + for bi := m.GetUnknown(); len(bi) > 0; { + num, _, n := protowire.ConsumeField(bi) + if !remover.Has(num) { + bo = append(bo, bi[:n]...) + } + bi = bi[n:] + } + if bi := m.GetUnknown(); len(bi) != len(bo) { + m.SetUnknown(bo) + } +} + +type fieldNum protoreflect.FieldNumber + +func (n1 fieldNum) Has(n2 protoreflect.FieldNumber) bool { + return protoreflect.FieldNumber(n1) == n2 +} diff --git a/services/vendor/github.com/golang/protobuf/proto/properties.go b/services/vendor/github.com/golang/protobuf/proto/properties.go new file mode 100644 index 00000000..dcdc2202 --- /dev/null +++ b/services/vendor/github.com/golang/protobuf/proto/properties.go @@ -0,0 +1,306 @@ +// Copyright 2010 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 proto + +import ( + "fmt" + "reflect" + "strconv" + "strings" + "sync" + + "google.golang.org/protobuf/reflect/protoreflect" + "google.golang.org/protobuf/runtime/protoimpl" +) + +// StructProperties represents protocol buffer type information for a +// generated protobuf message in the open-struct API. +// +// Deprecated: Do not use. +type StructProperties struct { + // Prop are the properties for each field. + // + // Fields belonging to a oneof are stored in OneofTypes instead, with a + // single Properties representing the parent oneof held here. + // + // The order of Prop matches the order of fields in the Go struct. + // Struct fields that are not related to protobufs have a "XXX_" prefix + // in the Properties.Name and must be ignored by the user. + Prop []*Properties + + // OneofTypes contains information about the oneof fields in this message. + // It is keyed by the protobuf field name. + OneofTypes map[string]*OneofProperties +} + +// Properties represents the type information for a protobuf message field. +// +// Deprecated: Do not use. +type Properties struct { + // Name is a placeholder name with little meaningful semantic value. + // If the name has an "XXX_" prefix, the entire Properties must be ignored. + Name string + // OrigName is the protobuf field name or oneof name. + OrigName string + // JSONName is the JSON name for the protobuf field. + JSONName string + // Enum is a placeholder name for enums. + // For historical reasons, this is neither the Go name for the enum, + // nor the protobuf name for the enum. + Enum string // Deprecated: Do not use. + // Weak contains the full name of the weakly referenced message. + Weak string + // Wire is a string representation of the wire type. + Wire string + // WireType is the protobuf wire type for the field. + WireType int + // Tag is the protobuf field number. + Tag int + // Required reports whether this is a required field. + Required bool + // Optional reports whether this is a optional field. + Optional bool + // Repeated reports whether this is a repeated field. + Repeated bool + // Packed reports whether this is a packed repeated field of scalars. + Packed bool + // Proto3 reports whether this field operates under the proto3 syntax. + Proto3 bool + // Oneof reports whether this field belongs within a oneof. + Oneof bool + + // Default is the default value in string form. + Default string + // HasDefault reports whether the field has a default value. + HasDefault bool + + // MapKeyProp is the properties for the key field for a map field. + MapKeyProp *Properties + // MapValProp is the properties for the value field for a map field. + MapValProp *Properties +} + +// OneofProperties represents the type information for a protobuf oneof. +// +// Deprecated: Do not use. +type OneofProperties struct { + // Type is a pointer to the generated wrapper type for the field value. + // This is nil for messages that are not in the open-struct API. + Type reflect.Type + // Field is the index into StructProperties.Prop for the containing oneof. + Field int + // Prop is the properties for the field. + Prop *Properties +} + +// String formats the properties in the protobuf struct field tag style. +func (p *Properties) String() string { + s := p.Wire + s += "," + strconv.Itoa(p.Tag) + if p.Required { + s += ",req" + } + if p.Optional { + s += ",opt" + } + if p.Repeated { + s += ",rep" + } + if p.Packed { + s += ",packed" + } + s += ",name=" + p.OrigName + if p.JSONName != "" { + s += ",json=" + p.JSONName + } + if len(p.Enum) > 0 { + s += ",enum=" + p.Enum + } + if len(p.Weak) > 0 { + s += ",weak=" + p.Weak + } + if p.Proto3 { + s += ",proto3" + } + if p.Oneof { + s += ",oneof" + } + if p.HasDefault { + s += ",def=" + p.Default + } + return s +} + +// Parse populates p by parsing a string in the protobuf struct field tag style. +func (p *Properties) Parse(tag string) { + // For example: "bytes,49,opt,name=foo,def=hello!" + for len(tag) > 0 { + i := strings.IndexByte(tag, ',') + if i < 0 { + i = len(tag) + } + switch s := tag[:i]; { + case strings.HasPrefix(s, "name="): + p.OrigName = s[len("name="):] + case strings.HasPrefix(s, "json="): + p.JSONName = s[len("json="):] + case strings.HasPrefix(s, "enum="): + p.Enum = s[len("enum="):] + case strings.HasPrefix(s, "weak="): + p.Weak = s[len("weak="):] + case strings.Trim(s, "0123456789") == "": + n, _ := strconv.ParseUint(s, 10, 32) + p.Tag = int(n) + case s == "opt": + p.Optional = true + case s == "req": + p.Required = true + case s == "rep": + p.Repeated = true + case s == "varint" || s == "zigzag32" || s == "zigzag64": + p.Wire = s + p.WireType = WireVarint + case s == "fixed32": + p.Wire = s + p.WireType = WireFixed32 + case s == "fixed64": + p.Wire = s + p.WireType = WireFixed64 + case s == "bytes": + p.Wire = s + p.WireType = WireBytes + case s == "group": + p.Wire = s + p.WireType = WireStartGroup + case s == "packed": + p.Packed = true + case s == "proto3": + p.Proto3 = true + case s == "oneof": + p.Oneof = true + case strings.HasPrefix(s, "def="): + // The default tag is special in that everything afterwards is the + // default regardless of the presence of commas. + p.HasDefault = true + p.Default, i = tag[len("def="):], len(tag) + } + tag = strings.TrimPrefix(tag[i:], ",") + } +} + +// Init populates the properties from a protocol buffer struct tag. +// +// Deprecated: Do not use. +func (p *Properties) Init(typ reflect.Type, name, tag string, f *reflect.StructField) { + p.Name = name + p.OrigName = name + if tag == "" { + return + } + p.Parse(tag) + + if typ != nil && typ.Kind() == reflect.Map { + p.MapKeyProp = new(Properties) + p.MapKeyProp.Init(nil, "Key", f.Tag.Get("protobuf_key"), nil) + p.MapValProp = new(Properties) + p.MapValProp.Init(nil, "Value", f.Tag.Get("protobuf_val"), nil) + } +} + +var propertiesCache sync.Map // map[reflect.Type]*StructProperties + +// GetProperties returns the list of properties for the type represented by t, +// which must be a generated protocol buffer message in the open-struct API, +// where protobuf message fields are represented by exported Go struct fields. +// +// Deprecated: Use protobuf reflection instead. +func GetProperties(t reflect.Type) *StructProperties { + if p, ok := propertiesCache.Load(t); ok { + return p.(*StructProperties) + } + p, _ := propertiesCache.LoadOrStore(t, newProperties(t)) + return p.(*StructProperties) +} + +func newProperties(t reflect.Type) *StructProperties { + if t.Kind() != reflect.Struct { + panic(fmt.Sprintf("%v is not a generated message in the open-struct API", t)) + } + + var hasOneof bool + prop := new(StructProperties) + + // Construct a list of properties for each field in the struct. + for i := 0; i < t.NumField(); i++ { + p := new(Properties) + f := t.Field(i) + tagField := f.Tag.Get("protobuf") + p.Init(f.Type, f.Name, tagField, &f) + + tagOneof := f.Tag.Get("protobuf_oneof") + if tagOneof != "" { + hasOneof = true + p.OrigName = tagOneof + } + + // Rename unrelated struct fields with the "XXX_" prefix since so much + // user code simply checks for this to exclude special fields. + if tagField == "" && tagOneof == "" && !strings.HasPrefix(p.Name, "XXX_") { + p.Name = "XXX_" + p.Name + p.OrigName = "XXX_" + p.OrigName + } else if p.Weak != "" { + p.Name = p.OrigName // avoid possible "XXX_" prefix on weak field + } + + prop.Prop = append(prop.Prop, p) + } + + // Construct a mapping of oneof field names to properties. + if hasOneof { + var oneofWrappers []interface{} + if fn, ok := reflect.PtrTo(t).MethodByName("XXX_OneofFuncs"); ok { + oneofWrappers = fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))})[3].Interface().([]interface{}) + } + if fn, ok := reflect.PtrTo(t).MethodByName("XXX_OneofWrappers"); ok { + oneofWrappers = fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))})[0].Interface().([]interface{}) + } + if m, ok := reflect.Zero(reflect.PtrTo(t)).Interface().(protoreflect.ProtoMessage); ok { + if m, ok := m.ProtoReflect().(interface{ ProtoMessageInfo() *protoimpl.MessageInfo }); ok { + oneofWrappers = m.ProtoMessageInfo().OneofWrappers + } + } + + prop.OneofTypes = make(map[string]*OneofProperties) + for _, wrapper := range oneofWrappers { + p := &OneofProperties{ + Type: reflect.ValueOf(wrapper).Type(), // *T + Prop: new(Properties), + } + f := p.Type.Elem().Field(0) + p.Prop.Name = f.Name + p.Prop.Parse(f.Tag.Get("protobuf")) + + // Determine the struct field that contains this oneof. + // Each wrapper is assignable to exactly one parent field. + var foundOneof bool + for i := 0; i < t.NumField() && !foundOneof; i++ { + if p.Type.AssignableTo(t.Field(i).Type) { + p.Field = i + foundOneof = true + } + } + if !foundOneof { + panic(fmt.Sprintf("%v is not a generated message in the open-struct API", t)) + } + prop.OneofTypes[p.Prop.OrigName] = p + } + } + + return prop +} + +func (sp *StructProperties) Len() int { return len(sp.Prop) } +func (sp *StructProperties) Less(i, j int) bool { return false } +func (sp *StructProperties) Swap(i, j int) { return } diff --git a/services/vendor/github.com/golang/protobuf/proto/proto.go b/services/vendor/github.com/golang/protobuf/proto/proto.go new file mode 100644 index 00000000..5aee89c3 --- /dev/null +++ b/services/vendor/github.com/golang/protobuf/proto/proto.go @@ -0,0 +1,167 @@ +// Copyright 2019 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 proto provides functionality for handling protocol buffer messages. +// In particular, it provides marshaling and unmarshaling between a protobuf +// message and the binary wire format. +// +// See https://developers.google.com/protocol-buffers/docs/gotutorial for +// more information. +// +// Deprecated: Use the "google.golang.org/protobuf/proto" package instead. +package proto + +import ( + protoV2 "google.golang.org/protobuf/proto" + "google.golang.org/protobuf/reflect/protoreflect" + "google.golang.org/protobuf/runtime/protoiface" + "google.golang.org/protobuf/runtime/protoimpl" +) + +const ( + ProtoPackageIsVersion1 = true + ProtoPackageIsVersion2 = true + ProtoPackageIsVersion3 = true + ProtoPackageIsVersion4 = true +) + +// GeneratedEnum is any enum type generated by protoc-gen-go +// which is a named int32 kind. +// This type exists for documentation purposes. +type GeneratedEnum interface{} + +// GeneratedMessage is any message type generated by protoc-gen-go +// which is a pointer to a named struct kind. +// This type exists for documentation purposes. +type GeneratedMessage interface{} + +// Message is a protocol buffer message. +// +// This is the v1 version of the message interface and is marginally better +// than an empty interface as it lacks any method to programatically interact +// with the contents of the message. +// +// A v2 message is declared in "google.golang.org/protobuf/proto".Message and +// exposes protobuf reflection as a first-class feature of the interface. +// +// To convert a v1 message to a v2 message, use the MessageV2 function. +// To convert a v2 message to a v1 message, use the MessageV1 function. +type Message = protoiface.MessageV1 + +// MessageV1 converts either a v1 or v2 message to a v1 message. +// It returns nil if m is nil. +func MessageV1(m GeneratedMessage) protoiface.MessageV1 { + return protoimpl.X.ProtoMessageV1Of(m) +} + +// MessageV2 converts either a v1 or v2 message to a v2 message. +// It returns nil if m is nil. +func MessageV2(m GeneratedMessage) protoV2.Message { + return protoimpl.X.ProtoMessageV2Of(m) +} + +// MessageReflect returns a reflective view for a message. +// It returns nil if m is nil. +func MessageReflect(m Message) protoreflect.Message { + return protoimpl.X.MessageOf(m) +} + +// Marshaler is implemented by messages that can marshal themselves. +// This interface is used by the following functions: Size, Marshal, +// Buffer.Marshal, and Buffer.EncodeMessage. +// +// Deprecated: Do not implement. +type Marshaler interface { + // Marshal formats the encoded bytes of the message. + // It should be deterministic and emit valid protobuf wire data. + // The caller takes ownership of the returned buffer. + Marshal() ([]byte, error) +} + +// Unmarshaler is implemented by messages that can unmarshal themselves. +// This interface is used by the following functions: Unmarshal, UnmarshalMerge, +// Buffer.Unmarshal, Buffer.DecodeMessage, and Buffer.DecodeGroup. +// +// Deprecated: Do not implement. +type Unmarshaler interface { + // Unmarshal parses the encoded bytes of the protobuf wire input. + // The provided buffer is only valid for during method call. + // It should not reset the receiver message. + Unmarshal([]byte) error +} + +// Merger is implemented by messages that can merge themselves. +// This interface is used by the following functions: Clone and Merge. +// +// Deprecated: Do not implement. +type Merger interface { + // Merge merges the contents of src into the receiver message. + // It clones all data structures in src such that it aliases no mutable + // memory referenced by src. + Merge(src Message) +} + +// RequiredNotSetError is an error type returned when +// marshaling or unmarshaling a message with missing required fields. +type RequiredNotSetError struct { + err error +} + +func (e *RequiredNotSetError) Error() string { + if e.err != nil { + return e.err.Error() + } + return "proto: required field not set" +} +func (e *RequiredNotSetError) RequiredNotSet() bool { + return true +} + +func checkRequiredNotSet(m protoV2.Message) error { + if err := protoV2.CheckInitialized(m); err != nil { + return &RequiredNotSetError{err: err} + } + return nil +} + +// Clone returns a deep copy of src. +func Clone(src Message) Message { + return MessageV1(protoV2.Clone(MessageV2(src))) +} + +// Merge merges src into dst, which must be messages of the same type. +// +// Populated scalar fields in src are copied to dst, while populated +// singular messages in src are merged into dst by recursively calling Merge. +// The elements of every list field in src is appended to the corresponded +// list fields in dst. The entries of every map field in src is copied into +// the corresponding map field in dst, possibly replacing existing entries. +// The unknown fields of src are appended to the unknown fields of dst. +func Merge(dst, src Message) { + protoV2.Merge(MessageV2(dst), MessageV2(src)) +} + +// Equal reports whether two messages are equal. +// If two messages marshal to the same bytes under deterministic serialization, +// then Equal is guaranteed to report true. +// +// Two messages are equal if they are the same protobuf message type, +// have the same set of populated known and extension field values, +// and the same set of unknown fields values. +// +// Scalar values are compared with the equivalent of the == operator in Go, +// except bytes values which are compared using bytes.Equal and +// floating point values which specially treat NaNs as equal. +// Message values are compared by recursively calling Equal. +// Lists are equal if each element value is also equal. +// Maps are equal if they have the same set of keys, where the pair of values +// for each key is also equal. +func Equal(x, y Message) bool { + return protoV2.Equal(MessageV2(x), MessageV2(y)) +} + +func isMessageSet(md protoreflect.MessageDescriptor) bool { + ms, ok := md.(interface{ IsMessageSet() bool }) + return ok && ms.IsMessageSet() +} diff --git a/services/vendor/github.com/golang/protobuf/proto/registry.go b/services/vendor/github.com/golang/protobuf/proto/registry.go new file mode 100644 index 00000000..066b4323 --- /dev/null +++ b/services/vendor/github.com/golang/protobuf/proto/registry.go @@ -0,0 +1,317 @@ +// Copyright 2019 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 proto + +import ( + "bytes" + "compress/gzip" + "fmt" + "io/ioutil" + "reflect" + "strings" + "sync" + + "google.golang.org/protobuf/reflect/protodesc" + "google.golang.org/protobuf/reflect/protoreflect" + "google.golang.org/protobuf/reflect/protoregistry" + "google.golang.org/protobuf/runtime/protoimpl" +) + +// filePath is the path to the proto source file. +type filePath = string // e.g., "google/protobuf/descriptor.proto" + +// fileDescGZIP is the compressed contents of the encoded FileDescriptorProto. +type fileDescGZIP = []byte + +var fileCache sync.Map // map[filePath]fileDescGZIP + +// RegisterFile is called from generated code to register the compressed +// FileDescriptorProto with the file path for a proto source file. +// +// Deprecated: Use protoregistry.GlobalFiles.RegisterFile instead. +func RegisterFile(s filePath, d fileDescGZIP) { + // Decompress the descriptor. + zr, err := gzip.NewReader(bytes.NewReader(d)) + if err != nil { + panic(fmt.Sprintf("proto: invalid compressed file descriptor: %v", err)) + } + b, err := ioutil.ReadAll(zr) + if err != nil { + panic(fmt.Sprintf("proto: invalid compressed file descriptor: %v", err)) + } + + // Construct a protoreflect.FileDescriptor from the raw descriptor. + // Note that DescBuilder.Build automatically registers the constructed + // file descriptor with the v2 registry. + protoimpl.DescBuilder{RawDescriptor: b}.Build() + + // Locally cache the raw descriptor form for the file. + fileCache.Store(s, d) +} + +// FileDescriptor returns the compressed FileDescriptorProto given the file path +// for a proto source file. It returns nil if not found. +// +// Deprecated: Use protoregistry.GlobalFiles.FindFileByPath instead. +func FileDescriptor(s filePath) fileDescGZIP { + if v, ok := fileCache.Load(s); ok { + return v.(fileDescGZIP) + } + + // Find the descriptor in the v2 registry. + var b []byte + if fd, _ := protoregistry.GlobalFiles.FindFileByPath(s); fd != nil { + b, _ = Marshal(protodesc.ToFileDescriptorProto(fd)) + } + + // Locally cache the raw descriptor form for the file. + if len(b) > 0 { + v, _ := fileCache.LoadOrStore(s, protoimpl.X.CompressGZIP(b)) + return v.(fileDescGZIP) + } + return nil +} + +// enumName is the name of an enum. For historical reasons, the enum name is +// neither the full Go name nor the full protobuf name of the enum. +// The name is the dot-separated combination of just the proto package that the +// enum is declared within followed by the Go type name of the generated enum. +type enumName = string // e.g., "my.proto.package.GoMessage_GoEnum" + +// enumsByName maps enum values by name to their numeric counterpart. +type enumsByName = map[string]int32 + +// enumsByNumber maps enum values by number to their name counterpart. +type enumsByNumber = map[int32]string + +var enumCache sync.Map // map[enumName]enumsByName +var numFilesCache sync.Map // map[protoreflect.FullName]int + +// RegisterEnum is called from the generated code to register the mapping of +// enum value names to enum numbers for the enum identified by s. +// +// Deprecated: Use protoregistry.GlobalTypes.RegisterEnum instead. +func RegisterEnum(s enumName, _ enumsByNumber, m enumsByName) { + if _, ok := enumCache.Load(s); ok { + panic("proto: duplicate enum registered: " + s) + } + enumCache.Store(s, m) + + // This does not forward registration to the v2 registry since this API + // lacks sufficient information to construct a complete v2 enum descriptor. +} + +// EnumValueMap returns the mapping from enum value names to enum numbers for +// the enum of the given name. It returns nil if not found. +// +// Deprecated: Use protoregistry.GlobalTypes.FindEnumByName instead. +func EnumValueMap(s enumName) enumsByName { + if v, ok := enumCache.Load(s); ok { + return v.(enumsByName) + } + + // Check whether the cache is stale. If the number of files in the current + // package differs, then it means that some enums may have been recently + // registered upstream that we do not know about. + var protoPkg protoreflect.FullName + if i := strings.LastIndexByte(s, '.'); i >= 0 { + protoPkg = protoreflect.FullName(s[:i]) + } + v, _ := numFilesCache.Load(protoPkg) + numFiles, _ := v.(int) + if protoregistry.GlobalFiles.NumFilesByPackage(protoPkg) == numFiles { + return nil // cache is up-to-date; was not found earlier + } + + // Update the enum cache for all enums declared in the given proto package. + numFiles = 0 + protoregistry.GlobalFiles.RangeFilesByPackage(protoPkg, func(fd protoreflect.FileDescriptor) bool { + walkEnums(fd, func(ed protoreflect.EnumDescriptor) { + name := protoimpl.X.LegacyEnumName(ed) + if _, ok := enumCache.Load(name); !ok { + m := make(enumsByName) + evs := ed.Values() + for i := evs.Len() - 1; i >= 0; i-- { + ev := evs.Get(i) + m[string(ev.Name())] = int32(ev.Number()) + } + enumCache.LoadOrStore(name, m) + } + }) + numFiles++ + return true + }) + numFilesCache.Store(protoPkg, numFiles) + + // Check cache again for enum map. + if v, ok := enumCache.Load(s); ok { + return v.(enumsByName) + } + return nil +} + +// walkEnums recursively walks all enums declared in d. +func walkEnums(d interface { + Enums() protoreflect.EnumDescriptors + Messages() protoreflect.MessageDescriptors +}, f func(protoreflect.EnumDescriptor)) { + eds := d.Enums() + for i := eds.Len() - 1; i >= 0; i-- { + f(eds.Get(i)) + } + mds := d.Messages() + for i := mds.Len() - 1; i >= 0; i-- { + walkEnums(mds.Get(i), f) + } +} + +// messageName is the full name of protobuf message. +type messageName = string + +var messageTypeCache sync.Map // map[messageName]reflect.Type + +// RegisterType is called from generated code to register the message Go type +// for a message of the given name. +// +// Deprecated: Use protoregistry.GlobalTypes.RegisterMessage instead. +func RegisterType(m Message, s messageName) { + mt := protoimpl.X.LegacyMessageTypeOf(m, protoreflect.FullName(s)) + if err := protoregistry.GlobalTypes.RegisterMessage(mt); err != nil { + panic(err) + } + messageTypeCache.Store(s, reflect.TypeOf(m)) +} + +// RegisterMapType is called from generated code to register the Go map type +// for a protobuf message representing a map entry. +// +// Deprecated: Do not use. +func RegisterMapType(m interface{}, s messageName) { + t := reflect.TypeOf(m) + if t.Kind() != reflect.Map { + panic(fmt.Sprintf("invalid map kind: %v", t)) + } + if _, ok := messageTypeCache.Load(s); ok { + panic(fmt.Errorf("proto: duplicate proto message registered: %s", s)) + } + messageTypeCache.Store(s, t) +} + +// MessageType returns the message type for a named message. +// It returns nil if not found. +// +// Deprecated: Use protoregistry.GlobalTypes.FindMessageByName instead. +func MessageType(s messageName) reflect.Type { + if v, ok := messageTypeCache.Load(s); ok { + return v.(reflect.Type) + } + + // Derive the message type from the v2 registry. + var t reflect.Type + if mt, _ := protoregistry.GlobalTypes.FindMessageByName(protoreflect.FullName(s)); mt != nil { + t = messageGoType(mt) + } + + // If we could not get a concrete type, it is possible that it is a + // pseudo-message for a map entry. + if t == nil { + d, _ := protoregistry.GlobalFiles.FindDescriptorByName(protoreflect.FullName(s)) + if md, _ := d.(protoreflect.MessageDescriptor); md != nil && md.IsMapEntry() { + kt := goTypeForField(md.Fields().ByNumber(1)) + vt := goTypeForField(md.Fields().ByNumber(2)) + t = reflect.MapOf(kt, vt) + } + } + + // Locally cache the message type for the given name. + if t != nil { + v, _ := messageTypeCache.LoadOrStore(s, t) + return v.(reflect.Type) + } + return nil +} + +func goTypeForField(fd protoreflect.FieldDescriptor) reflect.Type { + switch k := fd.Kind(); k { + case protoreflect.EnumKind: + if et, _ := protoregistry.GlobalTypes.FindEnumByName(fd.Enum().FullName()); et != nil { + return enumGoType(et) + } + return reflect.TypeOf(protoreflect.EnumNumber(0)) + case protoreflect.MessageKind, protoreflect.GroupKind: + if mt, _ := protoregistry.GlobalTypes.FindMessageByName(fd.Message().FullName()); mt != nil { + return messageGoType(mt) + } + return reflect.TypeOf((*protoreflect.Message)(nil)).Elem() + default: + return reflect.TypeOf(fd.Default().Interface()) + } +} + +func enumGoType(et protoreflect.EnumType) reflect.Type { + return reflect.TypeOf(et.New(0)) +} + +func messageGoType(mt protoreflect.MessageType) reflect.Type { + return reflect.TypeOf(MessageV1(mt.Zero().Interface())) +} + +// MessageName returns the full protobuf name for the given message type. +// +// Deprecated: Use protoreflect.MessageDescriptor.FullName instead. +func MessageName(m Message) messageName { + if m == nil { + return "" + } + if m, ok := m.(interface{ XXX_MessageName() messageName }); ok { + return m.XXX_MessageName() + } + return messageName(protoimpl.X.MessageDescriptorOf(m).FullName()) +} + +// RegisterExtension is called from the generated code to register +// the extension descriptor. +// +// Deprecated: Use protoregistry.GlobalTypes.RegisterExtension instead. +func RegisterExtension(d *ExtensionDesc) { + if err := protoregistry.GlobalTypes.RegisterExtension(d); err != nil { + panic(err) + } +} + +type extensionsByNumber = map[int32]*ExtensionDesc + +var extensionCache sync.Map // map[messageName]extensionsByNumber + +// RegisteredExtensions returns a map of the registered extensions for the +// provided protobuf message, indexed by the extension field number. +// +// Deprecated: Use protoregistry.GlobalTypes.RangeExtensionsByMessage instead. +func RegisteredExtensions(m Message) extensionsByNumber { + // Check whether the cache is stale. If the number of extensions for + // the given message differs, then it means that some extensions were + // recently registered upstream that we do not know about. + s := MessageName(m) + v, _ := extensionCache.Load(s) + xs, _ := v.(extensionsByNumber) + if protoregistry.GlobalTypes.NumExtensionsByMessage(protoreflect.FullName(s)) == len(xs) { + return xs // cache is up-to-date + } + + // Cache is stale, re-compute the extensions map. + xs = make(extensionsByNumber) + protoregistry.GlobalTypes.RangeExtensionsByMessage(protoreflect.FullName(s), func(xt protoreflect.ExtensionType) bool { + if xd, ok := xt.(*ExtensionDesc); ok { + xs[int32(xt.TypeDescriptor().Number())] = xd + } else { + // TODO: This implies that the protoreflect.ExtensionType is a + // custom type not generated by protoc-gen-go. We could try and + // convert the type to an ExtensionDesc. + } + return true + }) + extensionCache.Store(s, xs) + return xs +} diff --git a/services/vendor/github.com/golang/protobuf/proto/text_decode.go b/services/vendor/github.com/golang/protobuf/proto/text_decode.go new file mode 100644 index 00000000..47eb3e44 --- /dev/null +++ b/services/vendor/github.com/golang/protobuf/proto/text_decode.go @@ -0,0 +1,801 @@ +// Copyright 2010 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 proto + +import ( + "encoding" + "errors" + "fmt" + "reflect" + "strconv" + "strings" + "unicode/utf8" + + "google.golang.org/protobuf/encoding/prototext" + protoV2 "google.golang.org/protobuf/proto" + "google.golang.org/protobuf/reflect/protoreflect" + "google.golang.org/protobuf/reflect/protoregistry" +) + +const wrapTextUnmarshalV2 = false + +// ParseError is returned by UnmarshalText. +type ParseError struct { + Message string + + // Deprecated: Do not use. + Line, Offset int +} + +func (e *ParseError) Error() string { + if wrapTextUnmarshalV2 { + return e.Message + } + if e.Line == 1 { + return fmt.Sprintf("line 1.%d: %v", e.Offset, e.Message) + } + return fmt.Sprintf("line %d: %v", e.Line, e.Message) +} + +// UnmarshalText parses a proto text formatted string into m. +func UnmarshalText(s string, m Message) error { + if u, ok := m.(encoding.TextUnmarshaler); ok { + return u.UnmarshalText([]byte(s)) + } + + m.Reset() + mi := MessageV2(m) + + if wrapTextUnmarshalV2 { + err := prototext.UnmarshalOptions{ + AllowPartial: true, + }.Unmarshal([]byte(s), mi) + if err != nil { + return &ParseError{Message: err.Error()} + } + return checkRequiredNotSet(mi) + } else { + if err := newTextParser(s).unmarshalMessage(mi.ProtoReflect(), ""); err != nil { + return err + } + return checkRequiredNotSet(mi) + } +} + +type textParser struct { + s string // remaining input + done bool // whether the parsing is finished (success or error) + backed bool // whether back() was called + offset, line int + cur token +} + +type token struct { + value string + err *ParseError + line int // line number + offset int // byte number from start of input, not start of line + unquoted string // the unquoted version of value, if it was a quoted string +} + +func newTextParser(s string) *textParser { + p := new(textParser) + p.s = s + p.line = 1 + p.cur.line = 1 + return p +} + +func (p *textParser) unmarshalMessage(m protoreflect.Message, terminator string) (err error) { + md := m.Descriptor() + fds := md.Fields() + + // A struct is a sequence of "name: value", terminated by one of + // '>' or '}', or the end of the input. A name may also be + // "[extension]" or "[type/url]". + // + // The whole struct can also be an expanded Any message, like: + // [type/url] < ... struct contents ... > + seen := make(map[protoreflect.FieldNumber]bool) + for { + tok := p.next() + if tok.err != nil { + return tok.err + } + if tok.value == terminator { + break + } + if tok.value == "[" { + if err := p.unmarshalExtensionOrAny(m, seen); err != nil { + return err + } + continue + } + + // This is a normal, non-extension field. + name := protoreflect.Name(tok.value) + fd := fds.ByName(name) + switch { + case fd == nil: + gd := fds.ByName(protoreflect.Name(strings.ToLower(string(name)))) + if gd != nil && gd.Kind() == protoreflect.GroupKind && gd.Message().Name() == name { + fd = gd + } + case fd.Kind() == protoreflect.GroupKind && fd.Message().Name() != name: + fd = nil + case fd.IsWeak() && fd.Message().IsPlaceholder(): + fd = nil + } + if fd == nil { + typeName := string(md.FullName()) + if m, ok := m.Interface().(Message); ok { + t := reflect.TypeOf(m) + if t.Kind() == reflect.Ptr { + typeName = t.Elem().String() + } + } + return p.errorf("unknown field name %q in %v", name, typeName) + } + if od := fd.ContainingOneof(); od != nil && m.WhichOneof(od) != nil { + return p.errorf("field '%s' would overwrite already parsed oneof '%s'", name, od.Name()) + } + if fd.Cardinality() != protoreflect.Repeated && seen[fd.Number()] { + return p.errorf("non-repeated field %q was repeated", fd.Name()) + } + seen[fd.Number()] = true + + // Consume any colon. + if err := p.checkForColon(fd); err != nil { + return err + } + + // Parse into the field. + v := m.Get(fd) + if !m.Has(fd) && (fd.IsList() || fd.IsMap() || fd.Message() != nil) { + v = m.Mutable(fd) + } + if v, err = p.unmarshalValue(v, fd); err != nil { + return err + } + m.Set(fd, v) + + if err := p.consumeOptionalSeparator(); err != nil { + return err + } + } + return nil +} + +func (p *textParser) unmarshalExtensionOrAny(m protoreflect.Message, seen map[protoreflect.FieldNumber]bool) error { + name, err := p.consumeExtensionOrAnyName() + if err != nil { + return err + } + + // If it contains a slash, it's an Any type URL. + if slashIdx := strings.LastIndex(name, "/"); slashIdx >= 0 { + tok := p.next() + if tok.err != nil { + return tok.err + } + // consume an optional colon + if tok.value == ":" { + tok = p.next() + if tok.err != nil { + return tok.err + } + } + + var terminator string + switch tok.value { + case "<": + terminator = ">" + case "{": + terminator = "}" + default: + return p.errorf("expected '{' or '<', found %q", tok.value) + } + + mt, err := protoregistry.GlobalTypes.FindMessageByURL(name) + if err != nil { + return p.errorf("unrecognized message %q in google.protobuf.Any", name[slashIdx+len("/"):]) + } + m2 := mt.New() + if err := p.unmarshalMessage(m2, terminator); err != nil { + return err + } + b, err := protoV2.Marshal(m2.Interface()) + if err != nil { + return p.errorf("failed to marshal message of type %q: %v", name[slashIdx+len("/"):], err) + } + + urlFD := m.Descriptor().Fields().ByName("type_url") + valFD := m.Descriptor().Fields().ByName("value") + if seen[urlFD.Number()] { + return p.errorf("Any message unpacked multiple times, or %q already set", urlFD.Name()) + } + if seen[valFD.Number()] { + return p.errorf("Any message unpacked multiple times, or %q already set", valFD.Name()) + } + m.Set(urlFD, protoreflect.ValueOfString(name)) + m.Set(valFD, protoreflect.ValueOfBytes(b)) + seen[urlFD.Number()] = true + seen[valFD.Number()] = true + return nil + } + + xname := protoreflect.FullName(name) + xt, _ := protoregistry.GlobalTypes.FindExtensionByName(xname) + if xt == nil && isMessageSet(m.Descriptor()) { + xt, _ = protoregistry.GlobalTypes.FindExtensionByName(xname.Append("message_set_extension")) + } + if xt == nil { + return p.errorf("unrecognized extension %q", name) + } + fd := xt.TypeDescriptor() + if fd.ContainingMessage().FullName() != m.Descriptor().FullName() { + return p.errorf("extension field %q does not extend message %q", name, m.Descriptor().FullName()) + } + + if err := p.checkForColon(fd); err != nil { + return err + } + + v := m.Get(fd) + if !m.Has(fd) && (fd.IsList() || fd.IsMap() || fd.Message() != nil) { + v = m.Mutable(fd) + } + v, err = p.unmarshalValue(v, fd) + if err != nil { + return err + } + m.Set(fd, v) + return p.consumeOptionalSeparator() +} + +func (p *textParser) unmarshalValue(v protoreflect.Value, fd protoreflect.FieldDescriptor) (protoreflect.Value, error) { + tok := p.next() + if tok.err != nil { + return v, tok.err + } + if tok.value == "" { + return v, p.errorf("unexpected EOF") + } + + switch { + case fd.IsList(): + lv := v.List() + var err error + if tok.value == "[" { + // Repeated field with list notation, like [1,2,3]. + for { + vv := lv.NewElement() + vv, err = p.unmarshalSingularValue(vv, fd) + if err != nil { + return v, err + } + lv.Append(vv) + + tok := p.next() + if tok.err != nil { + return v, tok.err + } + if tok.value == "]" { + break + } + if tok.value != "," { + return v, p.errorf("Expected ']' or ',' found %q", tok.value) + } + } + return v, nil + } + + // One value of the repeated field. + p.back() + vv := lv.NewElement() + vv, err = p.unmarshalSingularValue(vv, fd) + if err != nil { + return v, err + } + lv.Append(vv) + return v, nil + case fd.IsMap(): + // The map entry should be this sequence of tokens: + // < key : KEY value : VALUE > + // However, implementations may omit key or value, and technically + // we should support them in any order. + var terminator string + switch tok.value { + case "<": + terminator = ">" + case "{": + terminator = "}" + default: + return v, p.errorf("expected '{' or '<', found %q", tok.value) + } + + keyFD := fd.MapKey() + valFD := fd.MapValue() + + mv := v.Map() + kv := keyFD.Default() + vv := mv.NewValue() + for { + tok := p.next() + if tok.err != nil { + return v, tok.err + } + if tok.value == terminator { + break + } + var err error + switch tok.value { + case "key": + if err := p.consumeToken(":"); err != nil { + return v, err + } + if kv, err = p.unmarshalSingularValue(kv, keyFD); err != nil { + return v, err + } + if err := p.consumeOptionalSeparator(); err != nil { + return v, err + } + case "value": + if err := p.checkForColon(valFD); err != nil { + return v, err + } + if vv, err = p.unmarshalSingularValue(vv, valFD); err != nil { + return v, err + } + if err := p.consumeOptionalSeparator(); err != nil { + return v, err + } + default: + p.back() + return v, p.errorf(`expected "key", "value", or %q, found %q`, terminator, tok.value) + } + } + mv.Set(kv.MapKey(), vv) + return v, nil + default: + p.back() + return p.unmarshalSingularValue(v, fd) + } +} + +func (p *textParser) unmarshalSingularValue(v protoreflect.Value, fd protoreflect.FieldDescriptor) (protoreflect.Value, error) { + tok := p.next() + if tok.err != nil { + return v, tok.err + } + if tok.value == "" { + return v, p.errorf("unexpected EOF") + } + + switch fd.Kind() { + case protoreflect.BoolKind: + switch tok.value { + case "true", "1", "t", "True": + return protoreflect.ValueOfBool(true), nil + case "false", "0", "f", "False": + return protoreflect.ValueOfBool(false), nil + } + case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind: + if x, err := strconv.ParseInt(tok.value, 0, 32); err == nil { + return protoreflect.ValueOfInt32(int32(x)), nil + } + + // The C++ parser accepts large positive hex numbers that uses + // two's complement arithmetic to represent negative numbers. + // This feature is here for backwards compatibility with C++. + if strings.HasPrefix(tok.value, "0x") { + if x, err := strconv.ParseUint(tok.value, 0, 32); err == nil { + return protoreflect.ValueOfInt32(int32(-(int64(^x) + 1))), nil + } + } + case protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind: + if x, err := strconv.ParseInt(tok.value, 0, 64); err == nil { + return protoreflect.ValueOfInt64(int64(x)), nil + } + + // The C++ parser accepts large positive hex numbers that uses + // two's complement arithmetic to represent negative numbers. + // This feature is here for backwards compatibility with C++. + if strings.HasPrefix(tok.value, "0x") { + if x, err := strconv.ParseUint(tok.value, 0, 64); err == nil { + return protoreflect.ValueOfInt64(int64(-(int64(^x) + 1))), nil + } + } + case protoreflect.Uint32Kind, protoreflect.Fixed32Kind: + if x, err := strconv.ParseUint(tok.value, 0, 32); err == nil { + return protoreflect.ValueOfUint32(uint32(x)), nil + } + case protoreflect.Uint64Kind, protoreflect.Fixed64Kind: + if x, err := strconv.ParseUint(tok.value, 0, 64); err == nil { + return protoreflect.ValueOfUint64(uint64(x)), nil + } + case protoreflect.FloatKind: + // Ignore 'f' for compatibility with output generated by C++, + // but don't remove 'f' when the value is "-inf" or "inf". + v := tok.value + if strings.HasSuffix(v, "f") && v != "-inf" && v != "inf" { + v = v[:len(v)-len("f")] + } + if x, err := strconv.ParseFloat(v, 32); err == nil { + return protoreflect.ValueOfFloat32(float32(x)), nil + } + case protoreflect.DoubleKind: + // Ignore 'f' for compatibility with output generated by C++, + // but don't remove 'f' when the value is "-inf" or "inf". + v := tok.value + if strings.HasSuffix(v, "f") && v != "-inf" && v != "inf" { + v = v[:len(v)-len("f")] + } + if x, err := strconv.ParseFloat(v, 64); err == nil { + return protoreflect.ValueOfFloat64(float64(x)), nil + } + case protoreflect.StringKind: + if isQuote(tok.value[0]) { + return protoreflect.ValueOfString(tok.unquoted), nil + } + case protoreflect.BytesKind: + if isQuote(tok.value[0]) { + return protoreflect.ValueOfBytes([]byte(tok.unquoted)), nil + } + case protoreflect.EnumKind: + if x, err := strconv.ParseInt(tok.value, 0, 32); err == nil { + return protoreflect.ValueOfEnum(protoreflect.EnumNumber(x)), nil + } + vd := fd.Enum().Values().ByName(protoreflect.Name(tok.value)) + if vd != nil { + return protoreflect.ValueOfEnum(vd.Number()), nil + } + case protoreflect.MessageKind, protoreflect.GroupKind: + var terminator string + switch tok.value { + case "{": + terminator = "}" + case "<": + terminator = ">" + default: + return v, p.errorf("expected '{' or '<', found %q", tok.value) + } + err := p.unmarshalMessage(v.Message(), terminator) + return v, err + default: + panic(fmt.Sprintf("invalid kind %v", fd.Kind())) + } + return v, p.errorf("invalid %v: %v", fd.Kind(), tok.value) +} + +// Consume a ':' from the input stream (if the next token is a colon), +// returning an error if a colon is needed but not present. +func (p *textParser) checkForColon(fd protoreflect.FieldDescriptor) *ParseError { + tok := p.next() + if tok.err != nil { + return tok.err + } + if tok.value != ":" { + if fd.Message() == nil { + return p.errorf("expected ':', found %q", tok.value) + } + p.back() + } + return nil +} + +// consumeExtensionOrAnyName consumes an extension name or an Any type URL and +// the following ']'. It returns the name or URL consumed. +func (p *textParser) consumeExtensionOrAnyName() (string, error) { + tok := p.next() + if tok.err != nil { + return "", tok.err + } + + // If extension name or type url is quoted, it's a single token. + if len(tok.value) > 2 && isQuote(tok.value[0]) && tok.value[len(tok.value)-1] == tok.value[0] { + name, err := unquoteC(tok.value[1:len(tok.value)-1], rune(tok.value[0])) + if err != nil { + return "", err + } + return name, p.consumeToken("]") + } + + // Consume everything up to "]" + var parts []string + for tok.value != "]" { + parts = append(parts, tok.value) + tok = p.next() + if tok.err != nil { + return "", p.errorf("unrecognized type_url or extension name: %s", tok.err) + } + if p.done && tok.value != "]" { + return "", p.errorf("unclosed type_url or extension name") + } + } + return strings.Join(parts, ""), nil +} + +// consumeOptionalSeparator consumes an optional semicolon or comma. +// It is used in unmarshalMessage to provide backward compatibility. +func (p *textParser) consumeOptionalSeparator() error { + tok := p.next() + if tok.err != nil { + return tok.err + } + if tok.value != ";" && tok.value != "," { + p.back() + } + return nil +} + +func (p *textParser) errorf(format string, a ...interface{}) *ParseError { + pe := &ParseError{fmt.Sprintf(format, a...), p.cur.line, p.cur.offset} + p.cur.err = pe + p.done = true + return pe +} + +func (p *textParser) skipWhitespace() { + i := 0 + for i < len(p.s) && (isWhitespace(p.s[i]) || p.s[i] == '#') { + if p.s[i] == '#' { + // comment; skip to end of line or input + for i < len(p.s) && p.s[i] != '\n' { + i++ + } + if i == len(p.s) { + break + } + } + if p.s[i] == '\n' { + p.line++ + } + i++ + } + p.offset += i + p.s = p.s[i:len(p.s)] + if len(p.s) == 0 { + p.done = true + } +} + +func (p *textParser) advance() { + // Skip whitespace + p.skipWhitespace() + if p.done { + return + } + + // Start of non-whitespace + p.cur.err = nil + p.cur.offset, p.cur.line = p.offset, p.line + p.cur.unquoted = "" + switch p.s[0] { + case '<', '>', '{', '}', ':', '[', ']', ';', ',', '/': + // Single symbol + p.cur.value, p.s = p.s[0:1], p.s[1:len(p.s)] + case '"', '\'': + // Quoted string + i := 1 + for i < len(p.s) && p.s[i] != p.s[0] && p.s[i] != '\n' { + if p.s[i] == '\\' && i+1 < len(p.s) { + // skip escaped char + i++ + } + i++ + } + if i >= len(p.s) || p.s[i] != p.s[0] { + p.errorf("unmatched quote") + return + } + unq, err := unquoteC(p.s[1:i], rune(p.s[0])) + if err != nil { + p.errorf("invalid quoted string %s: %v", p.s[0:i+1], err) + return + } + p.cur.value, p.s = p.s[0:i+1], p.s[i+1:len(p.s)] + p.cur.unquoted = unq + default: + i := 0 + for i < len(p.s) && isIdentOrNumberChar(p.s[i]) { + i++ + } + if i == 0 { + p.errorf("unexpected byte %#x", p.s[0]) + return + } + p.cur.value, p.s = p.s[0:i], p.s[i:len(p.s)] + } + p.offset += len(p.cur.value) +} + +// Back off the parser by one token. Can only be done between calls to next(). +// It makes the next advance() a no-op. +func (p *textParser) back() { p.backed = true } + +// Advances the parser and returns the new current token. +func (p *textParser) next() *token { + if p.backed || p.done { + p.backed = false + return &p.cur + } + p.advance() + if p.done { + p.cur.value = "" + } else if len(p.cur.value) > 0 && isQuote(p.cur.value[0]) { + // Look for multiple quoted strings separated by whitespace, + // and concatenate them. + cat := p.cur + for { + p.skipWhitespace() + if p.done || !isQuote(p.s[0]) { + break + } + p.advance() + if p.cur.err != nil { + return &p.cur + } + cat.value += " " + p.cur.value + cat.unquoted += p.cur.unquoted + } + p.done = false // parser may have seen EOF, but we want to return cat + p.cur = cat + } + return &p.cur +} + +func (p *textParser) consumeToken(s string) error { + tok := p.next() + if tok.err != nil { + return tok.err + } + if tok.value != s { + p.back() + return p.errorf("expected %q, found %q", s, tok.value) + } + return nil +} + +var errBadUTF8 = errors.New("proto: bad UTF-8") + +func unquoteC(s string, quote rune) (string, error) { + // This is based on C++'s tokenizer.cc. + // Despite its name, this is *not* parsing C syntax. + // For instance, "\0" is an invalid quoted string. + + // Avoid allocation in trivial cases. + simple := true + for _, r := range s { + if r == '\\' || r == quote { + simple = false + break + } + } + if simple { + return s, nil + } + + buf := make([]byte, 0, 3*len(s)/2) + for len(s) > 0 { + r, n := utf8.DecodeRuneInString(s) + if r == utf8.RuneError && n == 1 { + return "", errBadUTF8 + } + s = s[n:] + if r != '\\' { + if r < utf8.RuneSelf { + buf = append(buf, byte(r)) + } else { + buf = append(buf, string(r)...) + } + continue + } + + ch, tail, err := unescape(s) + if err != nil { + return "", err + } + buf = append(buf, ch...) + s = tail + } + return string(buf), nil +} + +func unescape(s string) (ch string, tail string, err error) { + r, n := utf8.DecodeRuneInString(s) + if r == utf8.RuneError && n == 1 { + return "", "", errBadUTF8 + } + s = s[n:] + switch r { + case 'a': + return "\a", s, nil + case 'b': + return "\b", s, nil + case 'f': + return "\f", s, nil + case 'n': + return "\n", s, nil + case 'r': + return "\r", s, nil + case 't': + return "\t", s, nil + case 'v': + return "\v", s, nil + case '?': + return "?", s, nil // trigraph workaround + case '\'', '"', '\\': + return string(r), s, nil + case '0', '1', '2', '3', '4', '5', '6', '7': + if len(s) < 2 { + return "", "", fmt.Errorf(`\%c requires 2 following digits`, r) + } + ss := string(r) + s[:2] + s = s[2:] + i, err := strconv.ParseUint(ss, 8, 8) + if err != nil { + return "", "", fmt.Errorf(`\%s contains non-octal digits`, ss) + } + return string([]byte{byte(i)}), s, nil + case 'x', 'X', 'u', 'U': + var n int + switch r { + case 'x', 'X': + n = 2 + case 'u': + n = 4 + case 'U': + n = 8 + } + if len(s) < n { + return "", "", fmt.Errorf(`\%c requires %d following digits`, r, n) + } + ss := s[:n] + s = s[n:] + i, err := strconv.ParseUint(ss, 16, 64) + if err != nil { + return "", "", fmt.Errorf(`\%c%s contains non-hexadecimal digits`, r, ss) + } + if r == 'x' || r == 'X' { + return string([]byte{byte(i)}), s, nil + } + if i > utf8.MaxRune { + return "", "", fmt.Errorf(`\%c%s is not a valid Unicode code point`, r, ss) + } + return string(rune(i)), s, nil + } + return "", "", fmt.Errorf(`unknown escape \%c`, r) +} + +func isIdentOrNumberChar(c byte) bool { + switch { + case 'A' <= c && c <= 'Z', 'a' <= c && c <= 'z': + return true + case '0' <= c && c <= '9': + return true + } + switch c { + case '-', '+', '.', '_': + return true + } + return false +} + +func isWhitespace(c byte) bool { + switch c { + case ' ', '\t', '\n', '\r': + return true + } + return false +} + +func isQuote(c byte) bool { + switch c { + case '"', '\'': + return true + } + return false +} diff --git a/services/vendor/github.com/golang/protobuf/proto/text_encode.go b/services/vendor/github.com/golang/protobuf/proto/text_encode.go new file mode 100644 index 00000000..a31134ee --- /dev/null +++ b/services/vendor/github.com/golang/protobuf/proto/text_encode.go @@ -0,0 +1,560 @@ +// Copyright 2010 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 proto + +import ( + "bytes" + "encoding" + "fmt" + "io" + "math" + "sort" + "strings" + + "google.golang.org/protobuf/encoding/prototext" + "google.golang.org/protobuf/encoding/protowire" + "google.golang.org/protobuf/proto" + "google.golang.org/protobuf/reflect/protoreflect" + "google.golang.org/protobuf/reflect/protoregistry" +) + +const wrapTextMarshalV2 = false + +// TextMarshaler is a configurable text format marshaler. +type TextMarshaler struct { + Compact bool // use compact text format (one line) + ExpandAny bool // expand google.protobuf.Any messages of known types +} + +// Marshal writes the proto text format of m to w. +func (tm *TextMarshaler) Marshal(w io.Writer, m Message) error { + b, err := tm.marshal(m) + if len(b) > 0 { + if _, err := w.Write(b); err != nil { + return err + } + } + return err +} + +// Text returns a proto text formatted string of m. +func (tm *TextMarshaler) Text(m Message) string { + b, _ := tm.marshal(m) + return string(b) +} + +func (tm *TextMarshaler) marshal(m Message) ([]byte, error) { + mr := MessageReflect(m) + if mr == nil || !mr.IsValid() { + return []byte(""), nil + } + + if wrapTextMarshalV2 { + if m, ok := m.(encoding.TextMarshaler); ok { + return m.MarshalText() + } + + opts := prototext.MarshalOptions{ + AllowPartial: true, + EmitUnknown: true, + } + if !tm.Compact { + opts.Indent = " " + } + if !tm.ExpandAny { + opts.Resolver = (*protoregistry.Types)(nil) + } + return opts.Marshal(mr.Interface()) + } else { + w := &textWriter{ + compact: tm.Compact, + expandAny: tm.ExpandAny, + complete: true, + } + + if m, ok := m.(encoding.TextMarshaler); ok { + b, err := m.MarshalText() + if err != nil { + return nil, err + } + w.Write(b) + return w.buf, nil + } + + err := w.writeMessage(mr) + return w.buf, err + } +} + +var ( + defaultTextMarshaler = TextMarshaler{} + compactTextMarshaler = TextMarshaler{Compact: true} +) + +// MarshalText writes the proto text format of m to w. +func MarshalText(w io.Writer, m Message) error { return defaultTextMarshaler.Marshal(w, m) } + +// MarshalTextString returns a proto text formatted string of m. +func MarshalTextString(m Message) string { return defaultTextMarshaler.Text(m) } + +// CompactText writes the compact proto text format of m to w. +func CompactText(w io.Writer, m Message) error { return compactTextMarshaler.Marshal(w, m) } + +// CompactTextString returns a compact proto text formatted string of m. +func CompactTextString(m Message) string { return compactTextMarshaler.Text(m) } + +var ( + newline = []byte("\n") + endBraceNewline = []byte("}\n") + posInf = []byte("inf") + negInf = []byte("-inf") + nan = []byte("nan") +) + +// textWriter is an io.Writer that tracks its indentation level. +type textWriter struct { + compact bool // same as TextMarshaler.Compact + expandAny bool // same as TextMarshaler.ExpandAny + complete bool // whether the current position is a complete line + indent int // indentation level; never negative + buf []byte +} + +func (w *textWriter) Write(p []byte) (n int, _ error) { + newlines := bytes.Count(p, newline) + if newlines == 0 { + if !w.compact && w.complete { + w.writeIndent() + } + w.buf = append(w.buf, p...) + w.complete = false + return len(p), nil + } + + frags := bytes.SplitN(p, newline, newlines+1) + if w.compact { + for i, frag := range frags { + if i > 0 { + w.buf = append(w.buf, ' ') + n++ + } + w.buf = append(w.buf, frag...) + n += len(frag) + } + return n, nil + } + + for i, frag := range frags { + if w.complete { + w.writeIndent() + } + w.buf = append(w.buf, frag...) + n += len(frag) + if i+1 < len(frags) { + w.buf = append(w.buf, '\n') + n++ + } + } + w.complete = len(frags[len(frags)-1]) == 0 + return n, nil +} + +func (w *textWriter) WriteByte(c byte) error { + if w.compact && c == '\n' { + c = ' ' + } + if !w.compact && w.complete { + w.writeIndent() + } + w.buf = append(w.buf, c) + w.complete = c == '\n' + return nil +} + +func (w *textWriter) writeName(fd protoreflect.FieldDescriptor) { + if !w.compact && w.complete { + w.writeIndent() + } + w.complete = false + + if fd.Kind() != protoreflect.GroupKind { + w.buf = append(w.buf, fd.Name()...) + w.WriteByte(':') + } else { + // Use message type name for group field name. + w.buf = append(w.buf, fd.Message().Name()...) + } + + if !w.compact { + w.WriteByte(' ') + } +} + +func requiresQuotes(u string) bool { + // When type URL contains any characters except [0-9A-Za-z./\-]*, it must be quoted. + for _, ch := range u { + switch { + case ch == '.' || ch == '/' || ch == '_': + continue + case '0' <= ch && ch <= '9': + continue + case 'A' <= ch && ch <= 'Z': + continue + case 'a' <= ch && ch <= 'z': + continue + default: + return true + } + } + return false +} + +// writeProto3Any writes an expanded google.protobuf.Any message. +// +// It returns (false, nil) if sv value can't be unmarshaled (e.g. because +// required messages are not linked in). +// +// It returns (true, error) when sv was written in expanded format or an error +// was encountered. +func (w *textWriter) writeProto3Any(m protoreflect.Message) (bool, error) { + md := m.Descriptor() + fdURL := md.Fields().ByName("type_url") + fdVal := md.Fields().ByName("value") + + url := m.Get(fdURL).String() + mt, err := protoregistry.GlobalTypes.FindMessageByURL(url) + if err != nil { + return false, nil + } + + b := m.Get(fdVal).Bytes() + m2 := mt.New() + if err := proto.Unmarshal(b, m2.Interface()); err != nil { + return false, nil + } + w.Write([]byte("[")) + if requiresQuotes(url) { + w.writeQuotedString(url) + } else { + w.Write([]byte(url)) + } + if w.compact { + w.Write([]byte("]:<")) + } else { + w.Write([]byte("]: <\n")) + w.indent++ + } + if err := w.writeMessage(m2); err != nil { + return true, err + } + if w.compact { + w.Write([]byte("> ")) + } else { + w.indent-- + w.Write([]byte(">\n")) + } + return true, nil +} + +func (w *textWriter) writeMessage(m protoreflect.Message) error { + md := m.Descriptor() + if w.expandAny && md.FullName() == "google.protobuf.Any" { + if canExpand, err := w.writeProto3Any(m); canExpand { + return err + } + } + + fds := md.Fields() + for i := 0; i < fds.Len(); { + fd := fds.Get(i) + if od := fd.ContainingOneof(); od != nil { + fd = m.WhichOneof(od) + i += od.Fields().Len() + } else { + i++ + } + if fd == nil || !m.Has(fd) { + continue + } + + switch { + case fd.IsList(): + lv := m.Get(fd).List() + for j := 0; j < lv.Len(); j++ { + w.writeName(fd) + v := lv.Get(j) + if err := w.writeSingularValue(v, fd); err != nil { + return err + } + w.WriteByte('\n') + } + case fd.IsMap(): + kfd := fd.MapKey() + vfd := fd.MapValue() + mv := m.Get(fd).Map() + + type entry struct{ key, val protoreflect.Value } + var entries []entry + mv.Range(func(k protoreflect.MapKey, v protoreflect.Value) bool { + entries = append(entries, entry{k.Value(), v}) + return true + }) + sort.Slice(entries, func(i, j int) bool { + switch kfd.Kind() { + case protoreflect.BoolKind: + return !entries[i].key.Bool() && entries[j].key.Bool() + case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind, protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind: + return entries[i].key.Int() < entries[j].key.Int() + case protoreflect.Uint32Kind, protoreflect.Fixed32Kind, protoreflect.Uint64Kind, protoreflect.Fixed64Kind: + return entries[i].key.Uint() < entries[j].key.Uint() + case protoreflect.StringKind: + return entries[i].key.String() < entries[j].key.String() + default: + panic("invalid kind") + } + }) + for _, entry := range entries { + w.writeName(fd) + w.WriteByte('<') + if !w.compact { + w.WriteByte('\n') + } + w.indent++ + w.writeName(kfd) + if err := w.writeSingularValue(entry.key, kfd); err != nil { + return err + } + w.WriteByte('\n') + w.writeName(vfd) + if err := w.writeSingularValue(entry.val, vfd); err != nil { + return err + } + w.WriteByte('\n') + w.indent-- + w.WriteByte('>') + w.WriteByte('\n') + } + default: + w.writeName(fd) + if err := w.writeSingularValue(m.Get(fd), fd); err != nil { + return err + } + w.WriteByte('\n') + } + } + + if b := m.GetUnknown(); len(b) > 0 { + w.writeUnknownFields(b) + } + return w.writeExtensions(m) +} + +func (w *textWriter) writeSingularValue(v protoreflect.Value, fd protoreflect.FieldDescriptor) error { + switch fd.Kind() { + case protoreflect.FloatKind, protoreflect.DoubleKind: + switch vf := v.Float(); { + case math.IsInf(vf, +1): + w.Write(posInf) + case math.IsInf(vf, -1): + w.Write(negInf) + case math.IsNaN(vf): + w.Write(nan) + default: + fmt.Fprint(w, v.Interface()) + } + case protoreflect.StringKind: + // NOTE: This does not validate UTF-8 for historical reasons. + w.writeQuotedString(string(v.String())) + case protoreflect.BytesKind: + w.writeQuotedString(string(v.Bytes())) + case protoreflect.MessageKind, protoreflect.GroupKind: + var bra, ket byte = '<', '>' + if fd.Kind() == protoreflect.GroupKind { + bra, ket = '{', '}' + } + w.WriteByte(bra) + if !w.compact { + w.WriteByte('\n') + } + w.indent++ + m := v.Message() + if m2, ok := m.Interface().(encoding.TextMarshaler); ok { + b, err := m2.MarshalText() + if err != nil { + return err + } + w.Write(b) + } else { + w.writeMessage(m) + } + w.indent-- + w.WriteByte(ket) + case protoreflect.EnumKind: + if ev := fd.Enum().Values().ByNumber(v.Enum()); ev != nil { + fmt.Fprint(w, ev.Name()) + } else { + fmt.Fprint(w, v.Enum()) + } + default: + fmt.Fprint(w, v.Interface()) + } + return nil +} + +// writeQuotedString writes a quoted string in the protocol buffer text format. +func (w *textWriter) writeQuotedString(s string) { + w.WriteByte('"') + for i := 0; i < len(s); i++ { + switch c := s[i]; c { + case '\n': + w.buf = append(w.buf, `\n`...) + case '\r': + w.buf = append(w.buf, `\r`...) + case '\t': + w.buf = append(w.buf, `\t`...) + case '"': + w.buf = append(w.buf, `\"`...) + case '\\': + w.buf = append(w.buf, `\\`...) + default: + if isPrint := c >= 0x20 && c < 0x7f; isPrint { + w.buf = append(w.buf, c) + } else { + w.buf = append(w.buf, fmt.Sprintf(`\%03o`, c)...) + } + } + } + w.WriteByte('"') +} + +func (w *textWriter) writeUnknownFields(b []byte) { + if !w.compact { + fmt.Fprintf(w, "/* %d unknown bytes */\n", len(b)) + } + + for len(b) > 0 { + num, wtyp, n := protowire.ConsumeTag(b) + if n < 0 { + return + } + b = b[n:] + + if wtyp == protowire.EndGroupType { + w.indent-- + w.Write(endBraceNewline) + continue + } + fmt.Fprint(w, num) + if wtyp != protowire.StartGroupType { + w.WriteByte(':') + } + if !w.compact || wtyp == protowire.StartGroupType { + w.WriteByte(' ') + } + switch wtyp { + case protowire.VarintType: + v, n := protowire.ConsumeVarint(b) + if n < 0 { + return + } + b = b[n:] + fmt.Fprint(w, v) + case protowire.Fixed32Type: + v, n := protowire.ConsumeFixed32(b) + if n < 0 { + return + } + b = b[n:] + fmt.Fprint(w, v) + case protowire.Fixed64Type: + v, n := protowire.ConsumeFixed64(b) + if n < 0 { + return + } + b = b[n:] + fmt.Fprint(w, v) + case protowire.BytesType: + v, n := protowire.ConsumeBytes(b) + if n < 0 { + return + } + b = b[n:] + fmt.Fprintf(w, "%q", v) + case protowire.StartGroupType: + w.WriteByte('{') + w.indent++ + default: + fmt.Fprintf(w, "/* unknown wire type %d */", wtyp) + } + w.WriteByte('\n') + } +} + +// writeExtensions writes all the extensions in m. +func (w *textWriter) writeExtensions(m protoreflect.Message) error { + md := m.Descriptor() + if md.ExtensionRanges().Len() == 0 { + return nil + } + + type ext struct { + desc protoreflect.FieldDescriptor + val protoreflect.Value + } + var exts []ext + m.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool { + if fd.IsExtension() { + exts = append(exts, ext{fd, v}) + } + return true + }) + sort.Slice(exts, func(i, j int) bool { + return exts[i].desc.Number() < exts[j].desc.Number() + }) + + for _, ext := range exts { + // For message set, use the name of the message as the extension name. + name := string(ext.desc.FullName()) + if isMessageSet(ext.desc.ContainingMessage()) { + name = strings.TrimSuffix(name, ".message_set_extension") + } + + if !ext.desc.IsList() { + if err := w.writeSingularExtension(name, ext.val, ext.desc); err != nil { + return err + } + } else { + lv := ext.val.List() + for i := 0; i < lv.Len(); i++ { + if err := w.writeSingularExtension(name, lv.Get(i), ext.desc); err != nil { + return err + } + } + } + } + return nil +} + +func (w *textWriter) writeSingularExtension(name string, v protoreflect.Value, fd protoreflect.FieldDescriptor) error { + fmt.Fprintf(w, "[%s]:", name) + if !w.compact { + w.WriteByte(' ') + } + if err := w.writeSingularValue(v, fd); err != nil { + return err + } + w.WriteByte('\n') + return nil +} + +func (w *textWriter) writeIndent() { + if !w.complete { + return + } + for i := 0; i < w.indent*2; i++ { + w.buf = append(w.buf, ' ') + } + w.complete = false +} diff --git a/services/vendor/github.com/golang/protobuf/proto/wire.go b/services/vendor/github.com/golang/protobuf/proto/wire.go new file mode 100644 index 00000000..d7c28da5 --- /dev/null +++ b/services/vendor/github.com/golang/protobuf/proto/wire.go @@ -0,0 +1,78 @@ +// Copyright 2019 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 proto + +import ( + protoV2 "google.golang.org/protobuf/proto" + "google.golang.org/protobuf/runtime/protoiface" +) + +// Size returns the size in bytes of the wire-format encoding of m. +func Size(m Message) int { + if m == nil { + return 0 + } + mi := MessageV2(m) + return protoV2.Size(mi) +} + +// Marshal returns the wire-format encoding of m. +func Marshal(m Message) ([]byte, error) { + b, err := marshalAppend(nil, m, false) + if b == nil { + b = zeroBytes + } + return b, err +} + +var zeroBytes = make([]byte, 0, 0) + +func marshalAppend(buf []byte, m Message, deterministic bool) ([]byte, error) { + if m == nil { + return nil, ErrNil + } + mi := MessageV2(m) + nbuf, err := protoV2.MarshalOptions{ + Deterministic: deterministic, + AllowPartial: true, + }.MarshalAppend(buf, mi) + if err != nil { + return buf, err + } + if len(buf) == len(nbuf) { + if !mi.ProtoReflect().IsValid() { + return buf, ErrNil + } + } + return nbuf, checkRequiredNotSet(mi) +} + +// Unmarshal parses a wire-format message in b and places the decoded results in m. +// +// Unmarshal resets m before starting to unmarshal, so any existing data in m is always +// removed. Use UnmarshalMerge to preserve and append to existing data. +func Unmarshal(b []byte, m Message) error { + m.Reset() + return UnmarshalMerge(b, m) +} + +// UnmarshalMerge parses a wire-format message in b and places the decoded results in m. +func UnmarshalMerge(b []byte, m Message) error { + mi := MessageV2(m) + out, err := protoV2.UnmarshalOptions{ + AllowPartial: true, + Merge: true, + }.UnmarshalState(protoiface.UnmarshalInput{ + Buf: b, + Message: mi.ProtoReflect(), + }) + if err != nil { + return err + } + if out.Flags&protoiface.UnmarshalInitialized > 0 { + return nil + } + return checkRequiredNotSet(mi) +} diff --git a/services/vendor/github.com/golang/protobuf/proto/wrappers.go b/services/vendor/github.com/golang/protobuf/proto/wrappers.go new file mode 100644 index 00000000..398e3485 --- /dev/null +++ b/services/vendor/github.com/golang/protobuf/proto/wrappers.go @@ -0,0 +1,34 @@ +// Copyright 2019 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 proto + +// Bool stores v in a new bool value and returns a pointer to it. +func Bool(v bool) *bool { return &v } + +// Int stores v in a new int32 value and returns a pointer to it. +// +// Deprecated: Use Int32 instead. +func Int(v int) *int32 { return Int32(int32(v)) } + +// Int32 stores v in a new int32 value and returns a pointer to it. +func Int32(v int32) *int32 { return &v } + +// Int64 stores v in a new int64 value and returns a pointer to it. +func Int64(v int64) *int64 { return &v } + +// Uint32 stores v in a new uint32 value and returns a pointer to it. +func Uint32(v uint32) *uint32 { return &v } + +// Uint64 stores v in a new uint64 value and returns a pointer to it. +func Uint64(v uint64) *uint64 { return &v } + +// Float32 stores v in a new float32 value and returns a pointer to it. +func Float32(v float32) *float32 { return &v } + +// Float64 stores v in a new float64 value and returns a pointer to it. +func Float64(v float64) *float64 { return &v } + +// String stores v in a new string value and returns a pointer to it. +func String(v string) *string { return &v } diff --git a/services/vendor/github.com/monzo/terrors/.gitignore b/services/vendor/github.com/monzo/terrors/.gitignore new file mode 100644 index 00000000..1485e10a --- /dev/null +++ b/services/vendor/github.com/monzo/terrors/.gitignore @@ -0,0 +1,6 @@ +.DS_Store +.AppleDouble +.LSOverride +.idea +.vscode +coverage.out diff --git a/services/vendor/github.com/monzo/terrors/LICENSE b/services/vendor/github.com/monzo/terrors/LICENSE new file mode 100644 index 00000000..090ae794 --- /dev/null +++ b/services/vendor/github.com/monzo/terrors/LICENSE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2015 Focus FS Limited + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/services/vendor/github.com/monzo/terrors/README.md b/services/vendor/github.com/monzo/terrors/README.md new file mode 100644 index 00000000..1eab3a37 --- /dev/null +++ b/services/vendor/github.com/monzo/terrors/README.md @@ -0,0 +1,64 @@ +`terrors` +========= + +[![Build Status](https://travis-ci.org/monzo/terrors.svg)](https://travis-ci.org/monzo/terrors) +[![GoDoc](https://godoc.org/github.com/monzo/terrors?status.svg)](https://godoc.org/github.com/monzo/terrors) + +Terrors is a package for wrapping Golang errors. Terrors provides additional +context to an error, such as an error code and a stack trace. + +Terrors is built and used at [Monzo](https://monzo.com/). + +## Usage + +Terrors can be used to wrap any object that satisfies the error interface: + +```go +terr := terrors.Wrap(err, map[string]string{"context": "my_context"}) +``` +Terrors can be instantiated directly: + +```go +err := terrors.New("not_found", "object not found", map[string]string{ + "context": "my_context" +}) +``` + +Terrors offers built-in functions for instantiating `Error`s with common codes: + +```go +err := terrors.NotFound("config_file", "config file not found", map[string]string{ + "context": my_context +}) +``` + +Terrors provides functions for matching specific `Error`s: + +```go +err := NotFound("handler_missing", "Handler not found", nil) +fmt.Println(Matches(err, "not_found.handler_missing")) // true +``` + +### Retryability + +Terrors contains the ability to declare whether or not an error is retryable. This property +is derived from the error code if not specified explicitly. + +When using the the wrapping functionality (e.g. `Wrap`, `Augment`, `Propagate`), the retryability +of an error is preserved as expected. Importantly, it is also preserved when constructing a new error from +a causal error with `NewInternalWithCause`. + +## API + +Full API documentation can be found on +[godoc](https://godoc.org/github.com/monzo/terrors) + +## Install + +``` +$ go get -u github.com/monzo/terrors +``` + +## License + +Terrors is licenced under the MIT License diff --git a/services/vendor/github.com/monzo/terrors/errors.go b/services/vendor/github.com/monzo/terrors/errors.go new file mode 100644 index 00000000..737daf75 --- /dev/null +++ b/services/vendor/github.com/monzo/terrors/errors.go @@ -0,0 +1,452 @@ +// Package terrors implements an error wrapping library. +// +// Terrors are used to provide context to an error, offering a stack trace and +// user defined error parameters. +// +// Terrors can be used to wrap any object that satisfies the error interface: +// +// terr := terrors.Wrap(err, map[string]string{"context": "my_context"}) +// +// Terrors can be instantiated directly: +// +// err := terrors.New("not_found", "object not found", map[string]string{ +// "context": "my_context" +// }) +// +// Terrors offers built-in functions for instantiating Errors with common codes: +// +// err := terrors.NotFound("config_file", "config file not found", map[string]string{ +// "context": my_context +// }) +package terrors + +import ( + "fmt" + "strings" + + "github.com/monzo/terrors/stack" +) + +// Generic error codes. Each of these has their own constructor for convenience. +// You can use any string as a code, just use the `New` method. +// Warning: any new generic error code must be added to GenericErrorCodes. +const ( + ErrBadRequest = "bad_request" + ErrBadResponse = "bad_response" + ErrForbidden = "forbidden" + ErrInternalService = "internal_service" + ErrNotFound = "not_found" + ErrPreconditionFailed = "precondition_failed" + ErrTimeout = "timeout" + ErrUnauthorized = "unauthorized" + ErrUnknown = "unknown" + ErrRateLimited = "rate_limited" +) + +// GenericErrorCodes is a list of all well known generic error codes. +var GenericErrorCodes = []string{ + ErrBadRequest, + ErrBadResponse, + ErrForbidden, + ErrInternalService, + ErrNotFound, + ErrPreconditionFailed, + ErrTimeout, + ErrUnauthorized, + ErrUnknown, + ErrRateLimited, +} + +var retryableCodes = []string{ + ErrInternalService, + ErrTimeout, + ErrUnknown, + ErrRateLimited, +} + +// Error is terror's error. It implements Go's error interface. +type Error struct { + Code string `json:"code"` + Message string `json:"message"` + Params map[string]string `json:"params"` + StackFrames stack.Stack `json:"stack"` + + // Exported for serialization, but you should use Retryable to read the value. + IsRetryable *bool `json:"is_retryable"` + + // Exported for serialization, but you should use Unexpected to read the value. + IsUnexpected *bool `json:"is_unexpected"` + + // Incremented each time the error is marshalled so that we can tell (approximately) how many services the error + // has propagated through. Higher level code can use this to influence decisions, for example it may only be + // desirable to retry on an error that's only been marshalled once to avoid retries on top of retries... ad nauseam + MarshalCount int `json:"marshal_count"` + + // When errors are marshalled certain information is lost (e.g. the 'cause'). This means if an error travels through + // a number of services (and it's potentially augmented at each hop) that the core error message may be lost. The + // history of an error is often a helpful debugging aid, so MessageChain is used to track this. + MessageChain []string `json:"message_chain"` + + // Cause is the initial cause of this error, and will be populated + // when using the Propagate function. This is intentionally not exported + // so that we don't serialize causes and send them across process boundaries. + // The cause refers to the cause of the error within a given process, and you + // should not expect it to contain information about terrors from other downstream + // processes. + cause error +} + +// Error returns a string message of the error. +// It will contain the code and error message. If there is a causal chain, the +// message from each error in the chain will be added to the output. +func (p *Error) Error() string { + if p.cause == nil { + // Not sure if the empty code/message cases actually happen, but to be safe, defer to + // the 'old' error message if there is no cause present (i.e. we're not using + // new wrapping functionality) + return p.legacyErrString() + } + return fmt.Sprintf("%s: %s", p.Code, p.ErrorMessage()) +} + +// ErrorMessage returns a string message of the error. +// It will contain the error message, but not the code. If there is a causal +// chain, the message from each error in the chain will be added to the output. +func (p *Error) ErrorMessage() string { + output := strings.Builder{} + output.WriteString(p.Message) + var next error = p.cause + for next != nil { + output.WriteString(": ") + switch typed := next.(type) { + case *Error: + output.WriteString(typed.Message) + next = typed.cause + case error: + output.WriteString(typed.Error()) + next = nil + } + } + return output.String() +} + +func (p *Error) legacyErrString() string { + if p == nil { + return "" + } + if p.Message == "" { + return p.Code + } + if p.Code == "" { + return p.Message + } + return fmt.Sprintf("%s: %s", p.Code, p.Message) +} + +// Unwrap retruns the cause of the error. It may be nil. +func (p *Error) Unwrap() error { + return p.cause +} + +// StackTrace returns a slice of program counters taken from the stack frames. +// This adapts the terrors package to allow stacks to be reported to Sentry correctly. +func (p *Error) StackTrace() []uintptr { + out := make([]uintptr, len(p.StackFrames)) + for i := 0; i < len(p.StackFrames); i++ { + out[i] = p.StackFrames[i].PC + } + return out +} + +// StackString formats the stacks from the terror chain as a string. If we +// encounter more than one terror in the chain with a stack frame, we'll print +// each one, separated by three hyphens on their own line. +func (p *Error) StackString() string { + // 32,000 seems like a reasonable limit for a stack trace. Otherwise, we risk + // overwhelming downstream systems. + return StackStringWithMaxSize(p, 32000) +} + +func StackStringWithMaxSize(p *Error, sizeLimit int) string { + // if we run into this many causes, we've likely run into something absurd. Like + // a self causing error. + const maxCausalDepth = 1024 + var buffer strings.Builder + terr := p + var causalDepth int +outer: + for terr != nil { + if buffer.Len() != 0 && len(terr.StackFrames) > 0 { + fmt.Fprintf(&buffer, "\n---") + } + for _, frame := range terr.StackFrames { + // 10 seems like a reasonable estimate of how large the rest of the line would be. + estimatedLineLen := len(frame.Filename) + len(frame.Method) + 16 + if estimatedLineLen+buffer.Len() > sizeLimit { + break outer + } + fmt.Fprintf(&buffer, "\n %s:%d in %s", frame.Filename, frame.Line, frame.Method) + } + + if tcause, ok := terr.cause.(*Error); ok && causalDepth < maxCausalDepth { + terr = tcause + causalDepth += 1 + } else { + break outer + } + } + + return buffer.String() +} + +// VerboseString returns the error message, stack trace and params +func (p *Error) VerboseString() string { + return fmt.Sprintf("%s\nParams: %+v\n%s", p.Error(), p.Params, p.StackString()) +} + +// Retryable determines whether the error was caused by an action which can be retried. +func (p *Error) Retryable() bool { + if p.IsRetryable != nil { + return *p.IsRetryable + } + for _, c := range retryableCodes { + if PrefixMatches(p, c) { + return true + } + } + return false +} + +// Unexpected states whether an error is not expected to occur. In many cases this will be due to a bug, e.g. due to a +// defensive check failing +func (p *Error) Unexpected() bool { + if p.IsUnexpected != nil { + return *p.IsUnexpected + } + + return false +} + +func (p *Error) SetIsRetryable(value bool) { + if value { + p.IsRetryable = &retryable + } else { + p.IsRetryable = ¬Retryable + } +} + +// SetIsUnexpected can be used to explicitly mark an error as unexpected or not. In practice the vast majority of +// code should not need to use this. An example use case might be when returning a validation error that must +// mean there is a coding mistake somewhere (e.g. default statement in a switch that is never expected to be +// taken). By marking the error as unexpected there is a greater chance that an alert will be sent. +func (p *Error) SetIsUnexpected(value bool) { + if value { + p.IsUnexpected = &unexpected + } else { + p.IsUnexpected = ¬Unexpected + } +} + +// LogMetadata implements the logMetadataProvider interface in the slog library which means that +// the error params will automatically be merged with the slog metadata. +// Additionally we put stack data in here for slog use. +func (p *Error) LogMetadata() map[string]string { + return p.Params +} + +// New creates a new error for you. Use this if you want to pass along a custom error code. +// Otherwise use the handy shorthand factories below +func New(code string, message string, params map[string]string) *Error { + return errorFactory(code, message, params) +} + +// NewInternalWithCause creates a new Terror from an existing error. +// The new error will always have the code `ErrInternalService`. The original +// error is attached as the `cause`, and can be tested with the `Is` function. +// You probably want to use the `Augment` func instead; +// only use this if you need to set a subcode on an error. +func NewInternalWithCause(err error, message string, params map[string]string, subCode string) *Error { + newErr := errorFactory(errCode(ErrInternalService, subCode), message, params) + newErr.cause = err + + switch v := err.(type) { + case *Error: + newErr.MessageChain = append([]string{v.Message}, v.MessageChain...) + default: + newErr.MessageChain = []string{err.Error()} + } + + switch v := err.(type) { + // If the causal error is a terror with retryability set, inherit that value. + // Otherwise, we'll default to retryable based on the ErrInternalService code above. + // This allows us to have an non-retryable InternalService error if the cause was not-retryable, + // which allows the retryability of errors to propagate through the system by default, even + // if an error handling case is missed in an upstream. + case *Error: + newErr.MarshalCount = v.MarshalCount + if v.IsRetryable != nil { + newErr.IsRetryable = v.IsRetryable + } + // Test if the causal error is anything else that implements the same interface and is retryable. + case retryableError: + r := v.Retryable() + newErr.IsRetryable = &r + } + + return newErr +} + +type retryableError interface { + Retryable() bool +} + +// addParams returns a new error with new params merged into the original error's +func addParams(err *Error, params map[string]string) *Error { + copiedParams := make(map[string]string, len(err.Params)+len(params)) + for k, v := range err.Params { + copiedParams[k] = v + } + for k, v := range params { + copiedParams[k] = v + } + + return &Error{ + Code: err.Code, + Message: err.Message, + MessageChain: err.MessageChain, + Params: copiedParams, + StackFrames: err.StackFrames, + IsRetryable: err.IsRetryable, + IsUnexpected: err.IsUnexpected, + MarshalCount: err.MarshalCount, + cause: err.cause, + } +} + +// Matches returns whether the string returned from error.Error() contains the given param string. This means you can +// match the error on different levels e.g. dotted codes `bad_request` or `bad_request.missing_param` or even on the +// more descriptive message +// Deprecated: Please use `Is` instead. See docs for `Matches` for breaking change risks. +func (p *Error) Matches(match string) bool { + return strings.Contains(p.Error(), match) +} + +// PrefixMatches returns whether the string returned from error.Error() starts with the given param string. This means +// you can match the error on different levels e.g. dotted codes `bad_request` or `bad_request.missing_param`. Each +// dotted part can be passed as a separate argument e.g. `terr.PrefixMatches(terrors.ErrBadRequest, "missing_param")` +// is the same as `terr.PrefixMatches("bad_request.missing_param")` +// Deprecated: Please use `Is` instead. +func (p *Error) PrefixMatches(prefixParts ...string) bool { + prefix := strings.Join(prefixParts, ".") + + return strings.HasPrefix(p.Code, prefix) +} + +// Matches returns true if the error is a terror error and the string returned from error.Error() contains the given +// param string. This means you can match the error on different levels e.g. dotted codes `bad_request` or +// `bad_request.missing_param` or even on the more descriptive message +// Deprecated: Please use `Is` instead. Note that `Is` will attempt to match each error in the stack using +// `PrefixMatches`, so if you were previously matching against a part of the string returned from error.Error() that +// is _not_ the prefix, then this will be a breaking change. In this case you should update the string to match the +// prefix. If this is not possible, you can match against the entire error string explicitly, for example: +// +// strings.Contains(err.Error(), "context deadline exceeded") +// +// But we consider this bad practice and is part of the motivation for deprecating Matches in the first place. +func Matches(err error, match string) bool { + if terr, ok := Wrap(err, nil).(*Error); ok { + return terr.Matches(match) + } + + return false +} + +// PrefixMatches returns true if the error is a terror and the string returned from error.Error() starts with the +// given param string. This means you can match the error on different levels e.g. dotted codes `bad_request` or +// `bad_request.missing_param`. Each dotted part can be passed as a separate argument +// e.g. `terrors.PrefixMatches(terr, terrors.ErrBadRequest, "missing_param")` is the same as +// terrors.PrefixMatches(terr, "bad_request.missing_param")` +// Deprecated: Please use `Is` instead. +func PrefixMatches(err error, prefixParts ...string) bool { + if terr, ok := Wrap(err, nil).(*Error); ok { + return terr.PrefixMatches(prefixParts...) + } + + return false +} + +// IsRetryable returns true if the error is a terror and whether the error was caused by an action which can be +// retried. +func IsRetryable(err error) bool { + if r, ok := Propagate(err).(*Error); ok { + return r.Retryable() + } + return false +} + +// Augment adds context to an existing error. +// If the error given is not already a terror, a new terror is created. +func Augment(err error, context string, params map[string]string) error { + if err == nil { + return nil + } + switch err := err.(type) { + case *Error: + withMergedParams := addParams(err, params) + // The underlying terror will already have a stack, so we don't take a new trace here. + return &Error{ + Code: err.Code, + Message: context, + MessageChain: append([]string{err.Message}, err.MessageChain...), + Params: withMergedParams.Params, + StackFrames: stack.Stack{}, + IsRetryable: err.IsRetryable, + IsUnexpected: err.IsUnexpected, + MarshalCount: err.MarshalCount, + cause: err, + } + default: + return NewInternalWithCause(err, context, params, "") + } +} + +// Propagate an error without changing it. This is equivalent to `return err` +// if the error is already a terror. If it is not a terror, this function will +// create one, and set the given error as the cause. +// This is a drop-in replacement for `terrors.Wrap(err, nil)` which adds causal +// chain functionality. +func Propagate(err error) error { + if err == nil { + return nil + } + switch err := err.(type) { + case *Error: + return err + default: + return NewInternalWithCause(err, err.Error(), nil, "") + } +} + +// Is checks whether an error is a given code. Similarly to `errors.Is`, +// this unwinds the error stack and checks each underlying error for the code. +// If any match, this returns true. +// Note that Is only behaves differently to PrefixMatches when errors in the stack have different codes. +// For example, this is the case when errors are initialized with NewInternalWithCause, but not with Augment. +// We prefer this over using a method receiver on the terrors Error, as the function +// signature requires an error to test against, and checking against terrors would +// requite creating a new terror with the specific code. +func Is(err error, code ...string) bool { + switch err := err.(type) { + case *Error: + if err.PrefixMatches(code...) { + return true + } + next := err.Unwrap() + if next == nil { + return false + } + return Is(next, code...) + default: + return false + } +} diff --git a/services/vendor/github.com/monzo/terrors/factory.go b/services/vendor/github.com/monzo/terrors/factory.go new file mode 100644 index 00000000..dacd1f04 --- /dev/null +++ b/services/vendor/github.com/monzo/terrors/factory.go @@ -0,0 +1,158 @@ +package terrors + +import ( + "strings" + + "github.com/monzo/terrors/stack" +) + +var ( + // Used when setting Error.IsRetryable + retryable = true + notRetryable = false + // Used when setting Error.IsUnexpected + unexpected = true + notUnexpected = false +) + +// Wrap takes any error interface and wraps it into an Error. +// This is useful because an Error contains lots of useful goodies, like the stacktrace of the error. +// NOTE: If `err` is already an `Error`, it will add the params passed in to the params of the Error +// Deprecated: Use Augment instead. +func Wrap(err error, params map[string]string) error { + return WrapWithCode(err, params, ErrInternalService) +} + +// WrapWithCode wraps an error with a custom error code. If `err` is already +// an `Error`, it will add the params passed in to the params of the error +// Deprecated: Use Augment instead. If you need to set the code of the error, +// then you should return a new error instead. For example +// +// terrors.WrapWithCode(err, map[string]string{"foo": "bar"}, "bad_request.failed") +// +// would become +// +// terrors.BadRequest("failed", err.Error(), map[string]string{"foo": "bar"}) +func WrapWithCode(err error, params map[string]string, code string) error { + if err == nil { + return nil + } + switch err := err.(type) { + case *Error: + return addParams(err, params) + default: + return errorFactory(code, err.Error(), params) + } +} + +// InternalService creates a new error to represent an internal service error. +// Only use internal service error if we know very little about the error. Most +// internal service errors will come from `Wrap`ing a vanilla `error` interface. +// Errors returned by this function are considered to be retryable by default. +// Consider using NonRetryableInternalService if retries are not desirable. +func InternalService(code, message string, params map[string]string) *Error { + return errorFactory(errCode(ErrInternalService, code), message, params) +} + +// NonRetryableInternalService creates a new error to represent an internal service error. +// Only use internal service error if we know very little about the error. Most +// internal service errors will come from `Wrap`ing a vanilla `error` interface. +// Errors returned by this function are not considered to be retryable by default. +func NonRetryableInternalService(code, message string, params map[string]string) *Error { + err := InternalService(code, message, params) + err.SetIsRetryable(false) + + return err +} + +// BadRequest creates a new error to represent an error caused by the client sending +// an invalid request. This is non-retryable unless the request is modified. +func BadRequest(code, message string, params map[string]string) *Error { + return errorFactory(errCode(ErrBadRequest, code), message, params) +} + +// BadResponse creates a new error representing a failure to response with a valid response +// Examples of this would be a handler returning an invalid message format +func BadResponse(code, message string, params map[string]string) *Error { + return errorFactory(errCode(ErrBadResponse, code), message, params) +} + +// Timeout creates a new error representing a timeout from client to server +func Timeout(code, message string, params map[string]string) *Error { + return errorFactory(errCode(ErrTimeout, code), message, params) +} + +// NotFound creates a new error representing a resource that cannot be found. In some +// cases this is not an error, and would be better represented by a zero length slice of elements +func NotFound(code, message string, params map[string]string) *Error { + return errorFactory(errCode(ErrNotFound, code), message, params) +} + +// Forbidden creates a new error representing a resource that cannot be accessed with +// the current authorisation credentials. The user may need authorising, or if authorised, +// may not be permitted to perform this action +func Forbidden(code, message string, params map[string]string) *Error { + return errorFactory(errCode(ErrForbidden, code), message, params) +} + +// Unauthorized creates a new error indicating that authentication is required, +// but has either failed or not been provided. +func Unauthorized(code, message string, params map[string]string) *Error { + return errorFactory(errCode(ErrUnauthorized, code), message, params) +} + +// PreconditionFailed creates a new error indicating that one or more conditions +// given in the request evaluated to false when tested on the server. +func PreconditionFailed(code, message string, params map[string]string) *Error { + return errorFactory(errCode(ErrPreconditionFailed, code), message, params) +} + +// RateLimited creates a new error indicating that the request has been rate-limited, +// and that the caller should back-off. +func RateLimited(code, message string, params map[string]string) *Error { + return errorFactory(errCode(ErrRateLimited, code), message, params) +} + +// errorConstructor returns a `*Error` with the specified code, message and params. +// Builds a stack based on the current call stack +func errorFactory(code string, message string, params map[string]string) *Error { + err := &Error{ + Code: ErrUnknown, + Message: message, + Params: map[string]string{}, + IsUnexpected: ¬Unexpected, + } + if len(code) > 0 { + err.Code = code + + err.IsRetryable = ¬Retryable + for _, c := range retryableCodes { + if PrefixMatches(err, c) { + err.IsRetryable = &retryable + } + } + } + if params != nil { + err.Params = params + } + + // TODO pass in context.Context + + // Build stack and skip first three lines: + // - stack.go BuildStack() + // - errors.go errorFactory() + // - errors.go public constructor method + err.StackFrames = stack.BuildStack(3) + + return err +} + +func errCode(prefix, code string) string { + if code == "" { + return prefix + } + if prefix == "" { + return code + } + return strings.Join([]string{prefix, code}, ".") +} diff --git a/services/vendor/github.com/monzo/terrors/marshaling.go b/services/vendor/github.com/monzo/terrors/marshaling.go new file mode 100644 index 00000000..0eda12fa --- /dev/null +++ b/services/vendor/github.com/monzo/terrors/marshaling.go @@ -0,0 +1,116 @@ +package terrors + +import ( + pe "github.com/monzo/terrors/proto" + "github.com/monzo/terrors/stack" +) + +// Marshal an error into a protobuf for transmission +func Marshal(e *Error) *pe.Error { + // Account for nil errors + if e == nil { + return &pe.Error{ + Code: ErrUnknown, + Message: "Unknown error, nil error marshalled", + } + } + + retryable := &pe.BoolValue{} + if e.IsRetryable != nil { + retryable.Value = *e.IsRetryable + } + + unexpected := &pe.BoolValue{} + if e.IsUnexpected != nil { + unexpected.Value = *e.IsUnexpected + } + + err := &pe.Error{ + Code: e.Code, + Message: e.Message, + MessageChain: e.MessageChain, + Stack: stackToProto(e.StackFrames), + Params: e.Params, + Retryable: retryable, + Unexpected: unexpected, + MarshalCount: int32(e.MarshalCount + 1), + } + if err.Code == "" { + err.Code = ErrUnknown + } + return err +} + +// Unmarshal a protobuf error into a local error +func Unmarshal(p *pe.Error) *Error { + if p == nil { + return &Error{ + Code: ErrUnknown, + Message: "Nil error unmarshalled!", + Params: map[string]string{}, + } + } + + var retryable *bool + if p.Retryable != nil { + retryable = &p.Retryable.Value + } + + var unexpected *bool + if p.Unexpected != nil { + unexpected = &p.Unexpected.Value + } + + err := &Error{ + Code: p.Code, + Message: p.Message, + MessageChain: p.MessageChain, + StackFrames: protoToStack(p.Stack), + Params: p.Params, + IsRetryable: retryable, + IsUnexpected: unexpected, + MarshalCount: int(p.MarshalCount), + } + if err.Code == "" { + err.Code = ErrUnknown + } + // empty map[string]string come out as nil. thanks proto. + if err.Params == nil { + err.Params = map[string]string{} + } + return err +} + +// protoToStack converts a slice of *pe.StackFrame and returns a stack.Stack +func protoToStack(protoStack []*pe.StackFrame) stack.Stack { + if protoStack == nil { + return stack.Stack{} + } + + s := make(stack.Stack, 0, len(protoStack)) + for _, frame := range protoStack { + s = append(s, &stack.Frame{ + Filename: frame.Filename, + Method: frame.Method, + Line: int(frame.Line), + }) + } + return s +} + +// stackToProto converts a stack.Stack and returns a slice of *pe.StackFrame +func stackToProto(s stack.Stack) []*pe.StackFrame { + if s == nil { + return []*pe.StackFrame{} + } + + protoStack := make([]*pe.StackFrame, 0, len(s)) + for _, frame := range s { + protoStack = append(protoStack, &pe.StackFrame{ + Filename: frame.Filename, + Line: int32(frame.Line), + Method: frame.Method, + }) + } + return protoStack +} diff --git a/services/vendor/github.com/monzo/terrors/proto/error.pb.go b/services/vendor/github.com/monzo/terrors/proto/error.pb.go new file mode 100644 index 00000000..2a8e0753 --- /dev/null +++ b/services/vendor/github.com/monzo/terrors/proto/error.pb.go @@ -0,0 +1,248 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// source: github.com/monzo/terrors/proto/error.proto + +package terrorsproto + +import ( + fmt "fmt" + proto "github.com/golang/protobuf/proto" + math "math" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package + +type StackFrame struct { + Filename string `protobuf:"bytes,1,opt,name=filename,proto3" json:"filename,omitempty"` + Line int32 `protobuf:"varint,2,opt,name=line,proto3" json:"line,omitempty"` + Method string `protobuf:"bytes,3,opt,name=method,proto3" json:"method,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *StackFrame) Reset() { *m = StackFrame{} } +func (m *StackFrame) String() string { return proto.CompactTextString(m) } +func (*StackFrame) ProtoMessage() {} +func (*StackFrame) Descriptor() ([]byte, []int) { + return fileDescriptor_ae33a222c066248f, []int{0} +} + +func (m *StackFrame) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_StackFrame.Unmarshal(m, b) +} +func (m *StackFrame) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_StackFrame.Marshal(b, m, deterministic) +} +func (m *StackFrame) XXX_Merge(src proto.Message) { + xxx_messageInfo_StackFrame.Merge(m, src) +} +func (m *StackFrame) XXX_Size() int { + return xxx_messageInfo_StackFrame.Size(m) +} +func (m *StackFrame) XXX_DiscardUnknown() { + xxx_messageInfo_StackFrame.DiscardUnknown(m) +} + +var xxx_messageInfo_StackFrame proto.InternalMessageInfo + +func (m *StackFrame) GetFilename() string { + if m != nil { + return m.Filename + } + return "" +} + +func (m *StackFrame) GetLine() int32 { + if m != nil { + return m.Line + } + return 0 +} + +func (m *StackFrame) GetMethod() string { + if m != nil { + return m.Method + } + return "" +} + +type Error struct { + Code string `protobuf:"bytes,1,opt,name=code,proto3" json:"code,omitempty"` + Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"` + Params map[string]string `protobuf:"bytes,3,rep,name=params,proto3" json:"params,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + Stack []*StackFrame `protobuf:"bytes,4,rep,name=stack,proto3" json:"stack,omitempty"` + // We don't use google.protobuf.BoolValue as it doesn't serialize properly without jsonpb. + Retryable *BoolValue `protobuf:"bytes,5,opt,name=retryable,proto3" json:"retryable,omitempty"` + MarshalCount int32 `protobuf:"varint,6,opt,name=marshal_count,json=marshalCount,proto3" json:"marshal_count,omitempty"` + MessageChain []string `protobuf:"bytes,7,rep,name=message_chain,json=messageChain,proto3" json:"message_chain,omitempty"` + Unexpected *BoolValue `protobuf:"bytes,8,opt,name=unexpected,proto3" json:"unexpected,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Error) Reset() { *m = Error{} } +func (m *Error) String() string { return proto.CompactTextString(m) } +func (*Error) ProtoMessage() {} +func (*Error) Descriptor() ([]byte, []int) { + return fileDescriptor_ae33a222c066248f, []int{1} +} + +func (m *Error) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_Error.Unmarshal(m, b) +} +func (m *Error) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_Error.Marshal(b, m, deterministic) +} +func (m *Error) XXX_Merge(src proto.Message) { + xxx_messageInfo_Error.Merge(m, src) +} +func (m *Error) XXX_Size() int { + return xxx_messageInfo_Error.Size(m) +} +func (m *Error) XXX_DiscardUnknown() { + xxx_messageInfo_Error.DiscardUnknown(m) +} + +var xxx_messageInfo_Error proto.InternalMessageInfo + +func (m *Error) GetCode() string { + if m != nil { + return m.Code + } + return "" +} + +func (m *Error) GetMessage() string { + if m != nil { + return m.Message + } + return "" +} + +func (m *Error) GetParams() map[string]string { + if m != nil { + return m.Params + } + return nil +} + +func (m *Error) GetStack() []*StackFrame { + if m != nil { + return m.Stack + } + return nil +} + +func (m *Error) GetRetryable() *BoolValue { + if m != nil { + return m.Retryable + } + return nil +} + +func (m *Error) GetMarshalCount() int32 { + if m != nil { + return m.MarshalCount + } + return 0 +} + +func (m *Error) GetMessageChain() []string { + if m != nil { + return m.MessageChain + } + return nil +} + +func (m *Error) GetUnexpected() *BoolValue { + if m != nil { + return m.Unexpected + } + return nil +} + +type BoolValue struct { + Value bool `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *BoolValue) Reset() { *m = BoolValue{} } +func (m *BoolValue) String() string { return proto.CompactTextString(m) } +func (*BoolValue) ProtoMessage() {} +func (*BoolValue) Descriptor() ([]byte, []int) { + return fileDescriptor_ae33a222c066248f, []int{2} +} + +func (m *BoolValue) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_BoolValue.Unmarshal(m, b) +} +func (m *BoolValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_BoolValue.Marshal(b, m, deterministic) +} +func (m *BoolValue) XXX_Merge(src proto.Message) { + xxx_messageInfo_BoolValue.Merge(m, src) +} +func (m *BoolValue) XXX_Size() int { + return xxx_messageInfo_BoolValue.Size(m) +} +func (m *BoolValue) XXX_DiscardUnknown() { + xxx_messageInfo_BoolValue.DiscardUnknown(m) +} + +var xxx_messageInfo_BoolValue proto.InternalMessageInfo + +func (m *BoolValue) GetValue() bool { + if m != nil { + return m.Value + } + return false +} + +func init() { + proto.RegisterType((*StackFrame)(nil), "StackFrame") + proto.RegisterType((*Error)(nil), "Error") + proto.RegisterMapType((map[string]string)(nil), "Error.ParamsEntry") + proto.RegisterType((*BoolValue)(nil), "BoolValue") +} + +func init() { + proto.RegisterFile("github.com/monzo/terrors/proto/error.proto", fileDescriptor_ae33a222c066248f) +} + +var fileDescriptor_ae33a222c066248f = []byte{ + // 349 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x64, 0x51, 0x4d, 0x6f, 0xe2, 0x30, + 0x10, 0x55, 0x08, 0x09, 0x64, 0xc2, 0xae, 0x56, 0xd6, 0x6a, 0x65, 0x71, 0x0a, 0xec, 0x25, 0xe2, + 0x90, 0x48, 0xf4, 0xd2, 0xf6, 0x08, 0xa2, 0xe7, 0x2a, 0xad, 0x7a, 0xe8, 0x05, 0x99, 0x30, 0x25, + 0x11, 0x71, 0x8c, 0x1c, 0xa7, 0x2a, 0xfd, 0xb3, 0xfd, 0x2b, 0x95, 0x1d, 0xf3, 0x21, 0xf5, 0xe4, + 0xf7, 0xde, 0xbc, 0x79, 0xf6, 0x78, 0x60, 0xb6, 0x2b, 0x55, 0xd1, 0x6e, 0x92, 0x5c, 0xf0, 0x94, + 0x8b, 0xfa, 0x53, 0xa4, 0x0a, 0xa5, 0x14, 0xb2, 0x49, 0x0f, 0x52, 0x28, 0x91, 0x1a, 0x92, 0x18, + 0x3c, 0x7d, 0x06, 0x78, 0x52, 0x2c, 0xdf, 0x3f, 0x48, 0xc6, 0x91, 0x8c, 0x61, 0xf8, 0x56, 0x56, + 0x58, 0x33, 0x8e, 0xd4, 0x89, 0x9c, 0x38, 0xc8, 0xce, 0x9c, 0x10, 0xe8, 0x57, 0x65, 0x8d, 0xb4, + 0x17, 0x39, 0xb1, 0x97, 0x19, 0x4c, 0xfe, 0x81, 0xcf, 0x51, 0x15, 0x62, 0x4b, 0x5d, 0xe3, 0xb6, + 0x6c, 0xfa, 0xd5, 0x03, 0x6f, 0xa5, 0x6f, 0xd1, 0x5d, 0xb9, 0xd8, 0x9e, 0xd2, 0x0c, 0x26, 0x14, + 0x06, 0x1c, 0x9b, 0x86, 0xed, 0xba, 0xb0, 0x20, 0x3b, 0x51, 0x32, 0x03, 0xff, 0xc0, 0x24, 0xe3, + 0x0d, 0x75, 0x23, 0x37, 0x0e, 0xe7, 0x24, 0x31, 0x29, 0xc9, 0xa3, 0x11, 0x57, 0xb5, 0x92, 0xc7, + 0xcc, 0x3a, 0xc8, 0x04, 0xbc, 0x46, 0xbf, 0x9c, 0xf6, 0x8d, 0x35, 0x4c, 0x2e, 0x73, 0x64, 0x5d, + 0x85, 0xc4, 0x10, 0x48, 0x54, 0xf2, 0xc8, 0x36, 0x15, 0x52, 0x2f, 0x72, 0xe2, 0x70, 0x0e, 0xc9, + 0x42, 0x88, 0xea, 0x85, 0x55, 0x2d, 0x66, 0x97, 0x22, 0xf9, 0x0f, 0xbf, 0x38, 0x93, 0x4d, 0xc1, + 0xaa, 0x75, 0x2e, 0xda, 0x5a, 0x51, 0xdf, 0x4c, 0x39, 0xb2, 0xe2, 0x52, 0x6b, 0xc6, 0xd4, 0x3d, + 0x74, 0x9d, 0x17, 0xac, 0xac, 0xe9, 0x20, 0x72, 0xe3, 0x20, 0x1b, 0x59, 0x71, 0xa9, 0x35, 0x32, + 0x03, 0x68, 0x6b, 0xfc, 0x38, 0x60, 0xae, 0x70, 0x4b, 0x87, 0x3f, 0x2e, 0xbd, 0xaa, 0x8e, 0xef, + 0x20, 0xbc, 0x9a, 0x8c, 0xfc, 0x01, 0x77, 0x8f, 0x47, 0xfb, 0x55, 0x1a, 0x92, 0xbf, 0xe0, 0xbd, + 0xeb, 0x2e, 0xfb, 0x4f, 0x1d, 0xb9, 0xef, 0xdd, 0x3a, 0xd3, 0x09, 0x04, 0xe7, 0xcc, 0x8b, 0x4d, + 0xb7, 0x0e, 0xad, 0x6d, 0xf1, 0xfb, 0x75, 0x64, 0xf7, 0x6e, 0x56, 0xbd, 0xf1, 0xcd, 0x71, 0xf3, + 0x1d, 0x00, 0x00, 0xff, 0xff, 0x7f, 0xf8, 0x36, 0x67, 0x1f, 0x02, 0x00, 0x00, +} diff --git a/services/vendor/github.com/monzo/terrors/proto/error.proto b/services/vendor/github.com/monzo/terrors/proto/error.proto new file mode 100644 index 00000000..56449a3c --- /dev/null +++ b/services/vendor/github.com/monzo/terrors/proto/error.proto @@ -0,0 +1,24 @@ +syntax = "proto3"; +option go_package = "terrorsproto"; + +message StackFrame { + string filename = 1; + int32 line = 2; + string method = 3; +} + +message Error { + string code = 1; + string message = 2; + map params = 3; + repeated StackFrame stack = 4; + // We don't use google.protobuf.BoolValue as it doesn't serialize properly without jsonpb. + BoolValue retryable = 5; + int32 marshal_count = 6; + repeated string message_chain = 7; + BoolValue unexpected = 8; +} + +message BoolValue { + bool value = 1; +} \ No newline at end of file diff --git a/services/vendor/github.com/monzo/terrors/stack/stack.go b/services/vendor/github.com/monzo/terrors/stack/stack.go new file mode 100644 index 00000000..0d9a9e8e --- /dev/null +++ b/services/vendor/github.com/monzo/terrors/stack/stack.go @@ -0,0 +1,105 @@ +// totally stolen from https://github.com/stvp/rollbar/blob/master/stack.go +package stack + +import ( + "fmt" + "hash/crc32" + "os" + "runtime" + "strings" +) + +var ( + knownFilePathPatterns []string = []string{ + "github.com/", + "code.google.com/", + "bitbucket.org/", + "launchpad.net/", + } +) + +type Frame struct { + Filename string `json:"filename"` + Method string `json:"method"` + Line int `json:"lineno"` + PC uintptr `json:"pc"` +} + +type Stack []*Frame + +func BuildStack(skip int) Stack { + stack := make(Stack, 0) + + // Look up to a maximum depth of 100 + ret := make([]uintptr, 100) + + // Note that indexes must be one higher when passed to Callers() + // than they would be when passed to Caller() + // see https://golang.org/pkg/runtime/#Caller + index := runtime.Callers(skip+1, ret) + if index == 0 { + // We have no frames to report, skip must be too high + return stack + } + + // This function takes a list of counters and gets function/file/line information + cf := runtime.CallersFrames(ret[:index]) + + for { + frame, ok := cf.Next() + stack = append(stack, &Frame{ + Filename: shortenFilePath(frame.File), + Method: functionName(frame.PC), + Line: frame.Line, + PC: frame.PC, + }) + if !ok { + // This was the last valid caller + break + } + } + return stack +} + +// Create a fingerprint that uniquely identify a given message. We use the full +// callstack, including file names. That ensure that there are no false +// duplicates but also means that after changing the code (adding/removing +// lines), the fingerprints will change. It's a trade-off. +func (s Stack) Fingerprint() string { + hash := crc32.NewIEEE() + for _, frame := range s { + fmt.Fprintf(hash, "%s%s%d", frame.Filename, frame.Method, frame.Line) + } + return fmt.Sprintf("%x", hash.Sum32()) +} + +// Remove un-needed information from the source file path. This makes them +// shorter in Rollbar UI as well as making them the same, regardless of the +// machine the code was compiled on. +// +// Examples: +// /usr/local/go/src/pkg/runtime/proc.c -> pkg/runtime/proc.c +// /home/foo/go/src/github.com/rollbar/rollbar.go -> github.com/rollbar/rollbar.go +func shortenFilePath(s string) string { + idx := strings.Index(s, "/src/pkg/") + if idx != -1 { + return s[idx+5:] + } + for _, pattern := range knownFilePathPatterns { + idx = strings.Index(s, pattern) + if idx != -1 { + return s[idx:] + } + } + return s +} + +func functionName(pc uintptr) string { + fn := runtime.FuncForPC(pc) + if fn == nil { + return "???" + } + name := fn.Name() + end := strings.LastIndex(name, string(os.PathSeparator)) + return name[end+1:] +} diff --git a/services/vendor/github.com/munnerz/goautoneg/Makefile b/services/vendor/github.com/munnerz/goautoneg/Makefile deleted file mode 100644 index e33ee173..00000000 --- a/services/vendor/github.com/munnerz/goautoneg/Makefile +++ /dev/null @@ -1,13 +0,0 @@ -include $(GOROOT)/src/Make.inc - -TARG=bitbucket.org/ww/goautoneg -GOFILES=autoneg.go - -include $(GOROOT)/src/Make.pkg - -format: - gofmt -w *.go - -docs: - gomake clean - godoc ${TARG} > README.txt diff --git a/services/vendor/github.com/prometheus/client_model/go/metrics.pb.go b/services/vendor/github.com/prometheus/client_model/go/metrics.pb.go index 2f154907..cee360db 100644 --- a/services/vendor/github.com/prometheus/client_model/go/metrics.pb.go +++ b/services/vendor/github.com/prometheus/client_model/go/metrics.pb.go @@ -483,8 +483,6 @@ type Histogram struct { // histograms. PositiveDelta []int64 `protobuf:"zigzag64,13,rep,name=positive_delta,json=positiveDelta" json:"positive_delta,omitempty"` // Count delta of each bucket compared to previous one (or to zero for 1st bucket). PositiveCount []float64 `protobuf:"fixed64,14,rep,name=positive_count,json=positiveCount" json:"positive_count,omitempty"` // Absolute count of each bucket. - // Only used for native histograms. These exemplars MUST have a timestamp. - Exemplars []*Exemplar `protobuf:"bytes,16,rep,name=exemplars" json:"exemplars,omitempty"` } func (x *Histogram) Reset() { @@ -624,13 +622,6 @@ func (x *Histogram) GetPositiveCount() []float64 { return nil } -func (x *Histogram) GetExemplars() []*Exemplar { - if x != nil { - return x.Exemplars - } - return nil -} - // A Bucket of a conventional histogram, each of which is treated as // an individual counter-like time series by Prometheus. type Bucket struct { @@ -932,7 +923,6 @@ type MetricFamily struct { Help *string `protobuf:"bytes,2,opt,name=help" json:"help,omitempty"` Type *MetricType `protobuf:"varint,3,opt,name=type,enum=io.prometheus.client.MetricType" json:"type,omitempty"` Metric []*Metric `protobuf:"bytes,4,rep,name=metric" json:"metric,omitempty"` - Unit *string `protobuf:"bytes,5,opt,name=unit" json:"unit,omitempty"` } func (x *MetricFamily) Reset() { @@ -995,13 +985,6 @@ func (x *MetricFamily) GetMetric() []*Metric { return nil } -func (x *MetricFamily) GetUnit() string { - if x != nil && x.Unit != nil { - return *x.Unit - } - return "" -} - var File_io_prometheus_client_metrics_proto protoreflect.FileDescriptor var file_io_prometheus_client_metrics_proto_rawDesc = []byte{ @@ -1045,7 +1028,7 @@ var file_io_prometheus_client_metrics_proto_rawDesc = []byte{ 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x10, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x1f, 0x0a, 0x07, 0x55, 0x6e, 0x74, 0x79, 0x70, 0x65, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x01, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0xea, 0x05, 0x0a, 0x09, 0x48, + 0x01, 0x28, 0x01, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0xac, 0x05, 0x0a, 0x09, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x67, 0x72, 0x61, 0x6d, 0x12, 0x21, 0x0a, 0x0c, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0b, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x2c, 0x0a, 0x12, 0x73, @@ -1088,84 +1071,79 @@ var file_io_prometheus_client_metrics_proto_rawDesc = []byte{ 0x03, 0x28, 0x12, 0x52, 0x0d, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x76, 0x65, 0x44, 0x65, 0x6c, 0x74, 0x61, 0x12, 0x25, 0x0a, 0x0e, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x0e, 0x20, 0x03, 0x28, 0x01, 0x52, 0x0d, 0x70, 0x6f, 0x73, 0x69, - 0x74, 0x69, 0x76, 0x65, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x3c, 0x0a, 0x09, 0x65, 0x78, 0x65, - 0x6d, 0x70, 0x6c, 0x61, 0x72, 0x73, 0x18, 0x10, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x69, - 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x6d, 0x65, 0x74, 0x68, 0x65, 0x75, 0x73, 0x2e, 0x63, 0x6c, 0x69, - 0x65, 0x6e, 0x74, 0x2e, 0x45, 0x78, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x72, 0x52, 0x09, 0x65, 0x78, - 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x72, 0x73, 0x22, 0xc6, 0x01, 0x0a, 0x06, 0x42, 0x75, 0x63, 0x6b, - 0x65, 0x74, 0x12, 0x29, 0x0a, 0x10, 0x63, 0x75, 0x6d, 0x75, 0x6c, 0x61, 0x74, 0x69, 0x76, 0x65, - 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0f, 0x63, 0x75, - 0x6d, 0x75, 0x6c, 0x61, 0x74, 0x69, 0x76, 0x65, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x34, 0x0a, - 0x16, 0x63, 0x75, 0x6d, 0x75, 0x6c, 0x61, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x63, 0x6f, 0x75, 0x6e, - 0x74, 0x5f, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x01, 0x52, 0x14, 0x63, - 0x75, 0x6d, 0x75, 0x6c, 0x61, 0x74, 0x69, 0x76, 0x65, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x46, 0x6c, - 0x6f, 0x61, 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x75, 0x70, 0x70, 0x65, 0x72, 0x5f, 0x62, 0x6f, 0x75, - 0x6e, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0a, 0x75, 0x70, 0x70, 0x65, 0x72, 0x42, - 0x6f, 0x75, 0x6e, 0x64, 0x12, 0x3a, 0x0a, 0x08, 0x65, 0x78, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x72, - 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x69, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x6d, - 0x65, 0x74, 0x68, 0x65, 0x75, 0x73, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x45, 0x78, - 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x72, 0x52, 0x08, 0x65, 0x78, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x72, - 0x22, 0x3c, 0x0a, 0x0a, 0x42, 0x75, 0x63, 0x6b, 0x65, 0x74, 0x53, 0x70, 0x61, 0x6e, 0x12, 0x16, - 0x0a, 0x06, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x11, 0x52, 0x06, - 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, - 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x06, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x22, 0x91, - 0x01, 0x0a, 0x08, 0x45, 0x78, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x72, 0x12, 0x35, 0x0a, 0x05, 0x6c, - 0x61, 0x62, 0x65, 0x6c, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x69, 0x6f, 0x2e, - 0x70, 0x72, 0x6f, 0x6d, 0x65, 0x74, 0x68, 0x65, 0x75, 0x73, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, - 0x74, 0x2e, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x50, 0x61, 0x69, 0x72, 0x52, 0x05, 0x6c, 0x61, 0x62, - 0x65, 0x6c, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, - 0x01, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x38, 0x0a, 0x09, 0x74, 0x69, 0x6d, 0x65, - 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, - 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, - 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, - 0x6d, 0x70, 0x22, 0xff, 0x02, 0x0a, 0x06, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x12, 0x35, 0x0a, + 0x74, 0x69, 0x76, 0x65, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0xc6, 0x01, 0x0a, 0x06, 0x42, 0x75, + 0x63, 0x6b, 0x65, 0x74, 0x12, 0x29, 0x0a, 0x10, 0x63, 0x75, 0x6d, 0x75, 0x6c, 0x61, 0x74, 0x69, + 0x76, 0x65, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0f, + 0x63, 0x75, 0x6d, 0x75, 0x6c, 0x61, 0x74, 0x69, 0x76, 0x65, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, + 0x34, 0x0a, 0x16, 0x63, 0x75, 0x6d, 0x75, 0x6c, 0x61, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x63, 0x6f, + 0x75, 0x6e, 0x74, 0x5f, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x01, 0x52, + 0x14, 0x63, 0x75, 0x6d, 0x75, 0x6c, 0x61, 0x74, 0x69, 0x76, 0x65, 0x43, 0x6f, 0x75, 0x6e, 0x74, + 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x75, 0x70, 0x70, 0x65, 0x72, 0x5f, 0x62, + 0x6f, 0x75, 0x6e, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0a, 0x75, 0x70, 0x70, 0x65, + 0x72, 0x42, 0x6f, 0x75, 0x6e, 0x64, 0x12, 0x3a, 0x0a, 0x08, 0x65, 0x78, 0x65, 0x6d, 0x70, 0x6c, + 0x61, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x69, 0x6f, 0x2e, 0x70, 0x72, + 0x6f, 0x6d, 0x65, 0x74, 0x68, 0x65, 0x75, 0x73, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, + 0x45, 0x78, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x72, 0x52, 0x08, 0x65, 0x78, 0x65, 0x6d, 0x70, 0x6c, + 0x61, 0x72, 0x22, 0x3c, 0x0a, 0x0a, 0x42, 0x75, 0x63, 0x6b, 0x65, 0x74, 0x53, 0x70, 0x61, 0x6e, + 0x12, 0x16, 0x0a, 0x06, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x11, + 0x52, 0x06, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x6c, 0x65, 0x6e, 0x67, + 0x74, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x06, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, + 0x22, 0x91, 0x01, 0x0a, 0x08, 0x45, 0x78, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x72, 0x12, 0x35, 0x0a, 0x05, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x69, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x6d, 0x65, 0x74, 0x68, 0x65, 0x75, 0x73, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x50, 0x61, 0x69, 0x72, 0x52, 0x05, 0x6c, - 0x61, 0x62, 0x65, 0x6c, 0x12, 0x31, 0x0a, 0x05, 0x67, 0x61, 0x75, 0x67, 0x65, 0x18, 0x02, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x69, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x6d, 0x65, 0x74, 0x68, - 0x65, 0x75, 0x73, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x47, 0x61, 0x75, 0x67, 0x65, - 0x52, 0x05, 0x67, 0x61, 0x75, 0x67, 0x65, 0x12, 0x37, 0x0a, 0x07, 0x63, 0x6f, 0x75, 0x6e, 0x74, - 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x69, 0x6f, 0x2e, 0x70, 0x72, - 0x6f, 0x6d, 0x65, 0x74, 0x68, 0x65, 0x75, 0x73, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, - 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x72, 0x52, 0x07, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x72, - 0x12, 0x37, 0x0a, 0x07, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, - 0x0b, 0x32, 0x1d, 0x2e, 0x69, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x6d, 0x65, 0x74, 0x68, 0x65, 0x75, - 0x73, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, - 0x52, 0x07, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x12, 0x37, 0x0a, 0x07, 0x75, 0x6e, 0x74, - 0x79, 0x70, 0x65, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x69, 0x6f, 0x2e, + 0x61, 0x62, 0x65, 0x6c, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x01, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x38, 0x0a, 0x09, 0x74, 0x69, + 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, + 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, + 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, + 0x74, 0x61, 0x6d, 0x70, 0x22, 0xff, 0x02, 0x0a, 0x06, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x12, + 0x35, 0x0a, 0x05, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, + 0x2e, 0x69, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x6d, 0x65, 0x74, 0x68, 0x65, 0x75, 0x73, 0x2e, 0x63, + 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x50, 0x61, 0x69, 0x72, 0x52, + 0x05, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x12, 0x31, 0x0a, 0x05, 0x67, 0x61, 0x75, 0x67, 0x65, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x69, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x6d, 0x65, + 0x74, 0x68, 0x65, 0x75, 0x73, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x47, 0x61, 0x75, + 0x67, 0x65, 0x52, 0x05, 0x67, 0x61, 0x75, 0x67, 0x65, 0x12, 0x37, 0x0a, 0x07, 0x63, 0x6f, 0x75, + 0x6e, 0x74, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x69, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x6d, 0x65, 0x74, 0x68, 0x65, 0x75, 0x73, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, - 0x74, 0x2e, 0x55, 0x6e, 0x74, 0x79, 0x70, 0x65, 0x64, 0x52, 0x07, 0x75, 0x6e, 0x74, 0x79, 0x70, - 0x65, 0x64, 0x12, 0x3d, 0x0a, 0x09, 0x68, 0x69, 0x73, 0x74, 0x6f, 0x67, 0x72, 0x61, 0x6d, 0x18, - 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x69, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x6d, 0x65, - 0x74, 0x68, 0x65, 0x75, 0x73, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x48, 0x69, 0x73, - 0x74, 0x6f, 0x67, 0x72, 0x61, 0x6d, 0x52, 0x09, 0x68, 0x69, 0x73, 0x74, 0x6f, 0x67, 0x72, 0x61, - 0x6d, 0x12, 0x21, 0x0a, 0x0c, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x5f, 0x6d, - 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, - 0x6d, 0x70, 0x4d, 0x73, 0x22, 0xb6, 0x01, 0x0a, 0x0c, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x46, - 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x68, 0x65, 0x6c, - 0x70, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x68, 0x65, 0x6c, 0x70, 0x12, 0x34, 0x0a, - 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x20, 0x2e, 0x69, 0x6f, - 0x2e, 0x70, 0x72, 0x6f, 0x6d, 0x65, 0x74, 0x68, 0x65, 0x75, 0x73, 0x2e, 0x63, 0x6c, 0x69, 0x65, - 0x6e, 0x74, 0x2e, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, 0x74, - 0x79, 0x70, 0x65, 0x12, 0x34, 0x0a, 0x06, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x18, 0x04, 0x20, - 0x03, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x6d, 0x65, 0x74, 0x68, - 0x65, 0x75, 0x73, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x4d, 0x65, 0x74, 0x72, 0x69, - 0x63, 0x52, 0x06, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x12, 0x12, 0x0a, 0x04, 0x75, 0x6e, 0x69, - 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x75, 0x6e, 0x69, 0x74, 0x2a, 0x62, 0x0a, - 0x0a, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0b, 0x0a, 0x07, 0x43, - 0x4f, 0x55, 0x4e, 0x54, 0x45, 0x52, 0x10, 0x00, 0x12, 0x09, 0x0a, 0x05, 0x47, 0x41, 0x55, 0x47, - 0x45, 0x10, 0x01, 0x12, 0x0b, 0x0a, 0x07, 0x53, 0x55, 0x4d, 0x4d, 0x41, 0x52, 0x59, 0x10, 0x02, - 0x12, 0x0b, 0x0a, 0x07, 0x55, 0x4e, 0x54, 0x59, 0x50, 0x45, 0x44, 0x10, 0x03, 0x12, 0x0d, 0x0a, - 0x09, 0x48, 0x49, 0x53, 0x54, 0x4f, 0x47, 0x52, 0x41, 0x4d, 0x10, 0x04, 0x12, 0x13, 0x0a, 0x0f, - 0x47, 0x41, 0x55, 0x47, 0x45, 0x5f, 0x48, 0x49, 0x53, 0x54, 0x4f, 0x47, 0x52, 0x41, 0x4d, 0x10, - 0x05, 0x42, 0x52, 0x0a, 0x14, 0x69, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x6d, 0x65, 0x74, 0x68, 0x65, - 0x75, 0x73, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x5a, 0x3a, 0x67, 0x69, 0x74, 0x68, 0x75, - 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x70, 0x72, 0x6f, 0x6d, 0x65, 0x74, 0x68, 0x65, 0x75, 0x73, - 0x2f, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x2f, 0x67, 0x6f, - 0x3b, 0x69, 0x6f, 0x5f, 0x70, 0x72, 0x6f, 0x6d, 0x65, 0x74, 0x68, 0x65, 0x75, 0x73, 0x5f, 0x63, - 0x6c, 0x69, 0x65, 0x6e, 0x74, + 0x74, 0x2e, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x72, 0x52, 0x07, 0x63, 0x6f, 0x75, 0x6e, 0x74, + 0x65, 0x72, 0x12, 0x37, 0x0a, 0x07, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x18, 0x04, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x69, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x6d, 0x65, 0x74, 0x68, + 0x65, 0x75, 0x73, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x53, 0x75, 0x6d, 0x6d, 0x61, + 0x72, 0x79, 0x52, 0x07, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x12, 0x37, 0x0a, 0x07, 0x75, + 0x6e, 0x74, 0x79, 0x70, 0x65, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x69, + 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x6d, 0x65, 0x74, 0x68, 0x65, 0x75, 0x73, 0x2e, 0x63, 0x6c, 0x69, + 0x65, 0x6e, 0x74, 0x2e, 0x55, 0x6e, 0x74, 0x79, 0x70, 0x65, 0x64, 0x52, 0x07, 0x75, 0x6e, 0x74, + 0x79, 0x70, 0x65, 0x64, 0x12, 0x3d, 0x0a, 0x09, 0x68, 0x69, 0x73, 0x74, 0x6f, 0x67, 0x72, 0x61, + 0x6d, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x69, 0x6f, 0x2e, 0x70, 0x72, 0x6f, + 0x6d, 0x65, 0x74, 0x68, 0x65, 0x75, 0x73, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x48, + 0x69, 0x73, 0x74, 0x6f, 0x67, 0x72, 0x61, 0x6d, 0x52, 0x09, 0x68, 0x69, 0x73, 0x74, 0x6f, 0x67, + 0x72, 0x61, 0x6d, 0x12, 0x21, 0x0a, 0x0c, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, + 0x5f, 0x6d, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x74, 0x69, 0x6d, 0x65, 0x73, + 0x74, 0x61, 0x6d, 0x70, 0x4d, 0x73, 0x22, 0xa2, 0x01, 0x0a, 0x0c, 0x4d, 0x65, 0x74, 0x72, 0x69, + 0x63, 0x46, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x68, + 0x65, 0x6c, 0x70, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x68, 0x65, 0x6c, 0x70, 0x12, + 0x34, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x20, 0x2e, + 0x69, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x6d, 0x65, 0x74, 0x68, 0x65, 0x75, 0x73, 0x2e, 0x63, 0x6c, + 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x54, 0x79, 0x70, 0x65, 0x52, + 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x34, 0x0a, 0x06, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x18, + 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x6d, 0x65, + 0x74, 0x68, 0x65, 0x75, 0x73, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x4d, 0x65, 0x74, + 0x72, 0x69, 0x63, 0x52, 0x06, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x2a, 0x62, 0x0a, 0x0a, 0x4d, + 0x65, 0x74, 0x72, 0x69, 0x63, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0b, 0x0a, 0x07, 0x43, 0x4f, 0x55, + 0x4e, 0x54, 0x45, 0x52, 0x10, 0x00, 0x12, 0x09, 0x0a, 0x05, 0x47, 0x41, 0x55, 0x47, 0x45, 0x10, + 0x01, 0x12, 0x0b, 0x0a, 0x07, 0x53, 0x55, 0x4d, 0x4d, 0x41, 0x52, 0x59, 0x10, 0x02, 0x12, 0x0b, + 0x0a, 0x07, 0x55, 0x4e, 0x54, 0x59, 0x50, 0x45, 0x44, 0x10, 0x03, 0x12, 0x0d, 0x0a, 0x09, 0x48, + 0x49, 0x53, 0x54, 0x4f, 0x47, 0x52, 0x41, 0x4d, 0x10, 0x04, 0x12, 0x13, 0x0a, 0x0f, 0x47, 0x41, + 0x55, 0x47, 0x45, 0x5f, 0x48, 0x49, 0x53, 0x54, 0x4f, 0x47, 0x52, 0x41, 0x4d, 0x10, 0x05, 0x42, + 0x52, 0x0a, 0x14, 0x69, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x6d, 0x65, 0x74, 0x68, 0x65, 0x75, 0x73, + 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x5a, 0x3a, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, + 0x63, 0x6f, 0x6d, 0x2f, 0x70, 0x72, 0x6f, 0x6d, 0x65, 0x74, 0x68, 0x65, 0x75, 0x73, 0x2f, 0x63, + 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x2f, 0x67, 0x6f, 0x3b, 0x69, + 0x6f, 0x5f, 0x70, 0x72, 0x6f, 0x6d, 0x65, 0x74, 0x68, 0x65, 0x75, 0x73, 0x5f, 0x63, 0x6c, 0x69, + 0x65, 0x6e, 0x74, } var ( @@ -1207,23 +1185,22 @@ var file_io_prometheus_client_metrics_proto_depIdxs = []int32{ 13, // 5: io.prometheus.client.Histogram.created_timestamp:type_name -> google.protobuf.Timestamp 9, // 6: io.prometheus.client.Histogram.negative_span:type_name -> io.prometheus.client.BucketSpan 9, // 7: io.prometheus.client.Histogram.positive_span:type_name -> io.prometheus.client.BucketSpan - 10, // 8: io.prometheus.client.Histogram.exemplars:type_name -> io.prometheus.client.Exemplar - 10, // 9: io.prometheus.client.Bucket.exemplar:type_name -> io.prometheus.client.Exemplar - 1, // 10: io.prometheus.client.Exemplar.label:type_name -> io.prometheus.client.LabelPair - 13, // 11: io.prometheus.client.Exemplar.timestamp:type_name -> google.protobuf.Timestamp - 1, // 12: io.prometheus.client.Metric.label:type_name -> io.prometheus.client.LabelPair - 2, // 13: io.prometheus.client.Metric.gauge:type_name -> io.prometheus.client.Gauge - 3, // 14: io.prometheus.client.Metric.counter:type_name -> io.prometheus.client.Counter - 5, // 15: io.prometheus.client.Metric.summary:type_name -> io.prometheus.client.Summary - 6, // 16: io.prometheus.client.Metric.untyped:type_name -> io.prometheus.client.Untyped - 7, // 17: io.prometheus.client.Metric.histogram:type_name -> io.prometheus.client.Histogram - 0, // 18: io.prometheus.client.MetricFamily.type:type_name -> io.prometheus.client.MetricType - 11, // 19: io.prometheus.client.MetricFamily.metric:type_name -> io.prometheus.client.Metric - 20, // [20:20] is the sub-list for method output_type - 20, // [20:20] is the sub-list for method input_type - 20, // [20:20] is the sub-list for extension type_name - 20, // [20:20] is the sub-list for extension extendee - 0, // [0:20] is the sub-list for field type_name + 10, // 8: io.prometheus.client.Bucket.exemplar:type_name -> io.prometheus.client.Exemplar + 1, // 9: io.prometheus.client.Exemplar.label:type_name -> io.prometheus.client.LabelPair + 13, // 10: io.prometheus.client.Exemplar.timestamp:type_name -> google.protobuf.Timestamp + 1, // 11: io.prometheus.client.Metric.label:type_name -> io.prometheus.client.LabelPair + 2, // 12: io.prometheus.client.Metric.gauge:type_name -> io.prometheus.client.Gauge + 3, // 13: io.prometheus.client.Metric.counter:type_name -> io.prometheus.client.Counter + 5, // 14: io.prometheus.client.Metric.summary:type_name -> io.prometheus.client.Summary + 6, // 15: io.prometheus.client.Metric.untyped:type_name -> io.prometheus.client.Untyped + 7, // 16: io.prometheus.client.Metric.histogram:type_name -> io.prometheus.client.Histogram + 0, // 17: io.prometheus.client.MetricFamily.type:type_name -> io.prometheus.client.MetricType + 11, // 18: io.prometheus.client.MetricFamily.metric:type_name -> io.prometheus.client.Metric + 19, // [19:19] is the sub-list for method output_type + 19, // [19:19] is the sub-list for method input_type + 19, // [19:19] is the sub-list for extension type_name + 19, // [19:19] is the sub-list for extension extendee + 0, // [0:19] is the sub-list for field type_name } func init() { file_io_prometheus_client_metrics_proto_init() } diff --git a/services/vendor/github.com/prometheus/common/expfmt/decode.go b/services/vendor/github.com/prometheus/common/expfmt/decode.go index 25cfaa21..b2b89b01 100644 --- a/services/vendor/github.com/prometheus/common/expfmt/decode.go +++ b/services/vendor/github.com/prometheus/common/expfmt/decode.go @@ -75,14 +75,14 @@ func ResponseFormat(h http.Header) Format { func NewDecoder(r io.Reader, format Format) Decoder { switch format.FormatType() { case TypeProtoDelim: - return &protoDecoder{r: bufio.NewReader(r)} + return &protoDecoder{r: r} } return &textDecoder{r: r} } // protoDecoder implements the Decoder interface for protocol buffers. type protoDecoder struct { - r protodelim.Reader + r io.Reader } // Decode implements the Decoder interface. @@ -90,7 +90,7 @@ func (d *protoDecoder) Decode(v *dto.MetricFamily) error { opts := protodelim.UnmarshalOptions{ MaxSize: -1, } - if err := opts.UnmarshalFrom(d.r, v); err != nil { + if err := opts.UnmarshalFrom(bufio.NewReader(d.r), v); err != nil { return err } if !model.IsValidMetricName(model.LabelValue(v.GetName())) { diff --git a/services/vendor/github.com/prometheus/common/expfmt/encode.go b/services/vendor/github.com/prometheus/common/expfmt/encode.go index ff5ef7a9..8fd80618 100644 --- a/services/vendor/github.com/prometheus/common/expfmt/encode.go +++ b/services/vendor/github.com/prometheus/common/expfmt/encode.go @@ -21,10 +21,9 @@ import ( "google.golang.org/protobuf/encoding/protodelim" "google.golang.org/protobuf/encoding/prototext" + "github.com/prometheus/common/internal/bitbucket.org/ww/goautoneg" "github.com/prometheus/common/model" - "github.com/munnerz/goautoneg" - dto "github.com/prometheus/client_model/go" ) @@ -140,13 +139,7 @@ func NegotiateIncludingOpenMetrics(h http.Header) Format { // interface is kept for backwards compatibility. // In cases where the Format does not allow for UTF-8 names, the global // NameEscapingScheme will be applied. -// -// NewEncoder can be called with additional options to customize the OpenMetrics text output. -// For example: -// NewEncoder(w, FmtOpenMetrics_1_0_0, WithCreatedLines()) -// -// Extra options are ignored for all other formats. -func NewEncoder(w io.Writer, format Format, options ...EncoderOption) Encoder { +func NewEncoder(w io.Writer, format Format) Encoder { escapingScheme := format.ToEscapingScheme() switch format.FormatType() { @@ -185,7 +178,7 @@ func NewEncoder(w io.Writer, format Format, options ...EncoderOption) Encoder { case TypeOpenMetrics: return encoderCloser{ encode: func(v *dto.MetricFamily) error { - _, err := MetricFamilyToOpenMetrics(w, model.EscapeMetricFamily(v, escapingScheme), options...) + _, err := MetricFamilyToOpenMetrics(w, model.EscapeMetricFamily(v, escapingScheme)) return err }, close: func() error { diff --git a/services/vendor/github.com/prometheus/common/expfmt/expfmt.go b/services/vendor/github.com/prometheus/common/expfmt/expfmt.go index 051b38cd..6fc9555e 100644 --- a/services/vendor/github.com/prometheus/common/expfmt/expfmt.go +++ b/services/vendor/github.com/prometheus/common/expfmt/expfmt.go @@ -15,7 +15,6 @@ package expfmt import ( - "fmt" "strings" "github.com/prometheus/common/model" @@ -64,7 +63,7 @@ const ( type FormatType int const ( - TypeUnknown FormatType = iota + TypeUnknown = iota TypeProtoCompact TypeProtoDelim TypeProtoText @@ -74,8 +73,7 @@ const ( // NewFormat generates a new Format from the type provided. Mostly used for // tests, most Formats should be generated as part of content negotiation in -// encode.go. If a type has more than one version, the latest version will be -// returned. +// encode.go. func NewFormat(t FormatType) Format { switch t { case TypeProtoCompact: @@ -93,21 +91,13 @@ func NewFormat(t FormatType) Format { } } -// NewOpenMetricsFormat generates a new OpenMetrics format matching the -// specified version number. -func NewOpenMetricsFormat(version string) (Format, error) { - if version == OpenMetricsVersion_0_0_1 { - return fmtOpenMetrics_0_0_1, nil - } - if version == OpenMetricsVersion_1_0_0 { - return fmtOpenMetrics_1_0_0, nil - } - return fmtUnknown, fmt.Errorf("unknown open metrics version string") -} - // FormatType deduces an overall FormatType for the given format. func (f Format) FormatType() FormatType { toks := strings.Split(string(f), ";") + if len(toks) < 2 { + return TypeUnknown + } + params := make(map[string]string) for i, t := range toks { if i == 0 { diff --git a/services/vendor/github.com/prometheus/common/expfmt/openmetrics_create.go b/services/vendor/github.com/prometheus/common/expfmt/openmetrics_create.go index 353c5e93..5622578e 100644 --- a/services/vendor/github.com/prometheus/common/expfmt/openmetrics_create.go +++ b/services/vendor/github.com/prometheus/common/expfmt/openmetrics_create.go @@ -22,47 +22,11 @@ import ( "strconv" "strings" - "google.golang.org/protobuf/types/known/timestamppb" - "github.com/prometheus/common/model" dto "github.com/prometheus/client_model/go" ) -type encoderOption struct { - withCreatedLines bool - withUnit bool -} - -type EncoderOption func(*encoderOption) - -// WithCreatedLines is an EncoderOption that configures the OpenMetrics encoder -// to include _created lines (See -// https://github.com/OpenObservability/OpenMetrics/blob/main/specification/OpenMetrics.md#counter-1). -// Created timestamps can improve the accuracy of series reset detection, but -// come with a bandwidth cost. -// -// At the time of writing, created timestamp ingestion is still experimental in -// Prometheus and need to be enabled with the feature-flag -// `--feature-flag=created-timestamp-zero-ingestion`, and breaking changes are -// still possible. Therefore, it is recommended to use this feature with caution. -func WithCreatedLines() EncoderOption { - return func(t *encoderOption) { - t.withCreatedLines = true - } -} - -// WithUnit is an EncoderOption enabling a set unit to be written to the output -// and to be added to the metric name, if it's not there already, as a suffix. -// Without opting in this way, the unit will not be added to the metric name and, -// on top of that, the unit will not be passed onto the output, even if it -// were declared in the *dto.MetricFamily struct, i.e. even if in.Unit !=nil. -func WithUnit() EncoderOption { - return func(t *encoderOption) { - t.withUnit = true - } -} - // MetricFamilyToOpenMetrics converts a MetricFamily proto message into the // OpenMetrics text format and writes the resulting lines to 'out'. It returns // the number of bytes written and any error encountered. The output will have @@ -95,34 +59,20 @@ func WithUnit() EncoderOption { // Prometheus to OpenMetrics or vice versa: // // - Counters are expected to have the `_total` suffix in their metric name. In -// the output, the suffix will be truncated from the `# TYPE`, `# HELP` and `# UNIT` -// lines. A counter with a missing `_total` suffix is not an error. However, +// the output, the suffix will be truncated from the `# TYPE` and `# HELP` +// line. A counter with a missing `_total` suffix is not an error. However, // its type will be set to `unknown` in that case to avoid invalid OpenMetrics // output. // -// - According to the OM specs, the `# UNIT` line is optional, but if populated, -// the unit has to be present in the metric name as its suffix: -// (see https://github.com/OpenObservability/OpenMetrics/blob/main/specification/OpenMetrics.md#unit). -// However, in order to accommodate any potential scenario where such a change in the -// metric name is not desirable, the users are here given the choice of either explicitly -// opt in, in case they wish for the unit to be included in the output AND in the metric name -// as a suffix (see the description of the WithUnit function above), -// or not to opt in, in case they don't want for any of that to happen. -// -// - No support for the following (optional) features: info type, -// stateset type, gaugehistogram type. +// - No support for the following (optional) features: `# UNIT` line, `_created` +// line, info type, stateset type, gaugehistogram type. // // - The size of exemplar labels is not checked (i.e. it's possible to create // exemplars that are larger than allowed by the OpenMetrics specification). // // - The value of Counters is not checked. (OpenMetrics doesn't allow counters // with a `NaN` value.) -func MetricFamilyToOpenMetrics(out io.Writer, in *dto.MetricFamily, options ...EncoderOption) (written int, err error) { - toOM := encoderOption{} - for _, option := range options { - option(&toOM) - } - +func MetricFamilyToOpenMetrics(out io.Writer, in *dto.MetricFamily) (written int, err error) { name := in.GetName() if name == "" { return 0, fmt.Errorf("MetricFamily has no name: %s", in) @@ -145,15 +95,12 @@ func MetricFamilyToOpenMetrics(out io.Writer, in *dto.MetricFamily, options ...E } var ( - n int - metricType = in.GetType() - compliantName = name + n int + metricType = in.GetType() + shortName = name ) - if metricType == dto.MetricType_COUNTER && strings.HasSuffix(compliantName, "_total") { - compliantName = name[:len(name)-6] - } - if toOM.withUnit && in.Unit != nil && !strings.HasSuffix(compliantName, fmt.Sprintf("_%s", *in.Unit)) { - compliantName = compliantName + fmt.Sprintf("_%s", *in.Unit) + if metricType == dto.MetricType_COUNTER && strings.HasSuffix(shortName, "_total") { + shortName = name[:len(name)-6] } // Comments, first HELP, then TYPE. @@ -163,7 +110,7 @@ func MetricFamilyToOpenMetrics(out io.Writer, in *dto.MetricFamily, options ...E if err != nil { return } - n, err = writeName(w, compliantName) + n, err = writeName(w, shortName) written += n if err != nil { return @@ -189,7 +136,7 @@ func MetricFamilyToOpenMetrics(out io.Writer, in *dto.MetricFamily, options ...E if err != nil { return } - n, err = writeName(w, compliantName) + n, err = writeName(w, shortName) written += n if err != nil { return @@ -216,89 +163,55 @@ func MetricFamilyToOpenMetrics(out io.Writer, in *dto.MetricFamily, options ...E if err != nil { return } - if toOM.withUnit && in.Unit != nil { - n, err = w.WriteString("# UNIT ") - written += n - if err != nil { - return - } - n, err = writeName(w, compliantName) - written += n - if err != nil { - return - } - - err = w.WriteByte(' ') - written++ - if err != nil { - return - } - n, err = writeEscapedString(w, *in.Unit, true) - written += n - if err != nil { - return - } - err = w.WriteByte('\n') - written++ - if err != nil { - return - } - } - - var createdTsBytesWritten int // Finally the samples, one line for each. - if metricType == dto.MetricType_COUNTER && strings.HasSuffix(name, "_total") { - compliantName = compliantName + "_total" - } for _, metric := range in.Metric { switch metricType { case dto.MetricType_COUNTER: if metric.Counter == nil { return written, fmt.Errorf( - "expected counter in metric %s %s", compliantName, metric, + "expected counter in metric %s %s", name, metric, ) } + // Note that we have ensured above that either the name + // ends on `_total` or that the rendered type is + // `unknown`. Therefore, no `_total` must be added here. n, err = writeOpenMetricsSample( - w, compliantName, "", metric, "", 0, + w, name, "", metric, "", 0, metric.Counter.GetValue(), 0, false, metric.Counter.Exemplar, ) - if toOM.withCreatedLines && metric.Counter.CreatedTimestamp != nil { - createdTsBytesWritten, err = writeOpenMetricsCreated(w, compliantName, "_total", metric, "", 0, metric.Counter.GetCreatedTimestamp()) - n += createdTsBytesWritten - } case dto.MetricType_GAUGE: if metric.Gauge == nil { return written, fmt.Errorf( - "expected gauge in metric %s %s", compliantName, metric, + "expected gauge in metric %s %s", name, metric, ) } n, err = writeOpenMetricsSample( - w, compliantName, "", metric, "", 0, + w, name, "", metric, "", 0, metric.Gauge.GetValue(), 0, false, nil, ) case dto.MetricType_UNTYPED: if metric.Untyped == nil { return written, fmt.Errorf( - "expected untyped in metric %s %s", compliantName, metric, + "expected untyped in metric %s %s", name, metric, ) } n, err = writeOpenMetricsSample( - w, compliantName, "", metric, "", 0, + w, name, "", metric, "", 0, metric.Untyped.GetValue(), 0, false, nil, ) case dto.MetricType_SUMMARY: if metric.Summary == nil { return written, fmt.Errorf( - "expected summary in metric %s %s", compliantName, metric, + "expected summary in metric %s %s", name, metric, ) } for _, q := range metric.Summary.Quantile { n, err = writeOpenMetricsSample( - w, compliantName, "", metric, + w, name, "", metric, model.QuantileLabel, q.GetQuantile(), q.GetValue(), 0, false, nil, @@ -309,7 +222,7 @@ func MetricFamilyToOpenMetrics(out io.Writer, in *dto.MetricFamily, options ...E } } n, err = writeOpenMetricsSample( - w, compliantName, "_sum", metric, "", 0, + w, name, "_sum", metric, "", 0, metric.Summary.GetSampleSum(), 0, false, nil, ) @@ -318,24 +231,20 @@ func MetricFamilyToOpenMetrics(out io.Writer, in *dto.MetricFamily, options ...E return } n, err = writeOpenMetricsSample( - w, compliantName, "_count", metric, "", 0, + w, name, "_count", metric, "", 0, 0, metric.Summary.GetSampleCount(), true, nil, ) - if toOM.withCreatedLines && metric.Summary.CreatedTimestamp != nil { - createdTsBytesWritten, err = writeOpenMetricsCreated(w, compliantName, "", metric, "", 0, metric.Summary.GetCreatedTimestamp()) - n += createdTsBytesWritten - } case dto.MetricType_HISTOGRAM: if metric.Histogram == nil { return written, fmt.Errorf( - "expected histogram in metric %s %s", compliantName, metric, + "expected histogram in metric %s %s", name, metric, ) } infSeen := false for _, b := range metric.Histogram.Bucket { n, err = writeOpenMetricsSample( - w, compliantName, "_bucket", metric, + w, name, "_bucket", metric, model.BucketLabel, b.GetUpperBound(), 0, b.GetCumulativeCount(), true, b.Exemplar, @@ -350,7 +259,7 @@ func MetricFamilyToOpenMetrics(out io.Writer, in *dto.MetricFamily, options ...E } if !infSeen { n, err = writeOpenMetricsSample( - w, compliantName, "_bucket", metric, + w, name, "_bucket", metric, model.BucketLabel, math.Inf(+1), 0, metric.Histogram.GetSampleCount(), true, nil, @@ -361,7 +270,7 @@ func MetricFamilyToOpenMetrics(out io.Writer, in *dto.MetricFamily, options ...E } } n, err = writeOpenMetricsSample( - w, compliantName, "_sum", metric, "", 0, + w, name, "_sum", metric, "", 0, metric.Histogram.GetSampleSum(), 0, false, nil, ) @@ -370,17 +279,13 @@ func MetricFamilyToOpenMetrics(out io.Writer, in *dto.MetricFamily, options ...E return } n, err = writeOpenMetricsSample( - w, compliantName, "_count", metric, "", 0, + w, name, "_count", metric, "", 0, 0, metric.Histogram.GetSampleCount(), true, nil, ) - if toOM.withCreatedLines && metric.Histogram.CreatedTimestamp != nil { - createdTsBytesWritten, err = writeOpenMetricsCreated(w, compliantName, "", metric, "", 0, metric.Histogram.GetCreatedTimestamp()) - n += createdTsBytesWritten - } default: return written, fmt.Errorf( - "unexpected type in metric %s %s", compliantName, metric, + "unexpected type in metric %s %s", name, metric, ) } written += n @@ -445,7 +350,7 @@ func writeOpenMetricsSample( return written, err } } - if exemplar != nil && len(exemplar.Label) > 0 { + if exemplar != nil { n, err = writeExemplar(w, exemplar) written += n if err != nil { @@ -568,49 +473,6 @@ func writeOpenMetricsNameAndLabelPairs( return written, nil } -// writeOpenMetricsCreated writes the created timestamp for a single time series -// following OpenMetrics text format to w, given the metric name, the metric proto -// message itself, optionally a suffix to be removed, e.g. '_total' for counters, -// an additional label name with a float64 value (use empty string as label name if -// not required) and the timestamp that represents the created timestamp. -// The function returns the number of bytes written and any error encountered. -func writeOpenMetricsCreated(w enhancedWriter, - name, suffixToTrim string, metric *dto.Metric, - additionalLabelName string, additionalLabelValue float64, - createdTimestamp *timestamppb.Timestamp, -) (int, error) { - written := 0 - n, err := writeOpenMetricsNameAndLabelPairs( - w, strings.TrimSuffix(name, suffixToTrim)+"_created", metric.Label, additionalLabelName, additionalLabelValue, - ) - written += n - if err != nil { - return written, err - } - - err = w.WriteByte(' ') - written++ - if err != nil { - return written, err - } - - // TODO(beorn7): Format this directly from components of ts to - // avoid overflow/underflow and precision issues of the float - // conversion. - n, err = writeOpenMetricsFloat(w, float64(createdTimestamp.AsTime().UnixNano())/1e9) - written += n - if err != nil { - return written, err - } - - err = w.WriteByte('\n') - written++ - if err != nil { - return written, err - } - return written, nil -} - // writeExemplar writes the provided exemplar in OpenMetrics format to w. The // function returns the number of bytes written and any error encountered. func writeExemplar(w enhancedWriter, e *dto.Exemplar) (int, error) { diff --git a/services/vendor/github.com/munnerz/goautoneg/README.txt b/services/vendor/github.com/prometheus/common/internal/bitbucket.org/ww/goautoneg/README.txt similarity index 100% rename from services/vendor/github.com/munnerz/goautoneg/README.txt rename to services/vendor/github.com/prometheus/common/internal/bitbucket.org/ww/goautoneg/README.txt diff --git a/services/vendor/github.com/munnerz/goautoneg/autoneg.go b/services/vendor/github.com/prometheus/common/internal/bitbucket.org/ww/goautoneg/autoneg.go similarity index 52% rename from services/vendor/github.com/munnerz/goautoneg/autoneg.go rename to services/vendor/github.com/prometheus/common/internal/bitbucket.org/ww/goautoneg/autoneg.go index 1dd1cad6..a21b9d15 100644 --- a/services/vendor/github.com/munnerz/goautoneg/autoneg.go +++ b/services/vendor/github.com/prometheus/common/internal/bitbucket.org/ww/goautoneg/autoneg.go @@ -1,28 +1,28 @@ /* +Copyright (c) 2011, Open Knowledge Foundation Ltd. +All rights reserved. + HTTP Content-Type Autonegotiation. The functions in this package implement the behaviour specified in http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html -Copyright (c) 2011, Open Knowledge Foundation Ltd. -All rights reserved. - Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: - Redistributions of source code must retain the above copyright - notice, this list of conditions and the following disclaimer. + Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. - Redistributions in binary form must reproduce the above copyright - notice, this list of conditions and the following disclaimer in - the documentation and/or other materials provided with the - distribution. + Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in + the documentation and/or other materials provided with the + distribution. - Neither the name of the Open Knowledge Foundation Ltd. nor the - names of its contributors may be used to endorse or promote - products derived from this software without specific prior written - permission. + Neither the name of the Open Knowledge Foundation Ltd. nor the + names of its contributors may be used to endorse or promote + products derived from this software without specific prior written + permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT @@ -36,7 +36,6 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ - package goautoneg import ( @@ -52,14 +51,16 @@ type Accept struct { Params map[string]string } -// acceptSlice is defined to implement sort interface. -type acceptSlice []Accept +// For internal use, so that we can use the sort interface +type accept_slice []Accept -func (slice acceptSlice) Len() int { +func (accept accept_slice) Len() int { + slice := []Accept(accept) return len(slice) } -func (slice acceptSlice) Less(i, j int) bool { +func (accept accept_slice) Less(i, j int) bool { + slice := []Accept(accept) ai, aj := slice[i], slice[j] if ai.Q > aj.Q { return true @@ -73,93 +74,63 @@ func (slice acceptSlice) Less(i, j int) bool { return false } -func (slice acceptSlice) Swap(i, j int) { +func (accept accept_slice) Swap(i, j int) { + slice := []Accept(accept) slice[i], slice[j] = slice[j], slice[i] } -func stringTrimSpaceCutset(r rune) bool { - return r == ' ' -} - -func nextSplitElement(s, sep string) (item string, remaining string) { - if index := strings.Index(s, sep); index != -1 { - return s[:index], s[index+1:] - } - return s, "" -} - // Parse an Accept Header string returning a sorted list // of clauses -func ParseAccept(header string) acceptSlice { - partsCount := 0 - remaining := header - for len(remaining) > 0 { - partsCount++ - _, remaining = nextSplitElement(remaining, ",") - } - accept := make(acceptSlice, 0, partsCount) - - remaining = header - var part string - for len(remaining) > 0 { - part, remaining = nextSplitElement(remaining, ",") - part = strings.TrimFunc(part, stringTrimSpaceCutset) +func ParseAccept(header string) (accept []Accept) { + parts := strings.Split(header, ",") + accept = make([]Accept, 0, len(parts)) + for _, part := range parts { + part := strings.Trim(part, " ") - a := Accept{ - Q: 1.0, - } + a := Accept{} + a.Params = make(map[string]string) + a.Q = 1.0 - sp, remainingPart := nextSplitElement(part, ";") + mrp := strings.Split(part, ";") - sp0, spRemaining := nextSplitElement(sp, "/") - a.Type = strings.TrimFunc(sp0, stringTrimSpaceCutset) + media_range := mrp[0] + sp := strings.Split(media_range, "/") + a.Type = strings.Trim(sp[0], " ") switch { - case len(spRemaining) == 0: - if a.Type == "*" { - a.SubType = "*" - } else { - continue - } + case len(sp) == 1 && a.Type == "*": + a.SubType = "*" + case len(sp) == 2: + a.SubType = strings.Trim(sp[1], " ") default: - var sp1 string - sp1, spRemaining = nextSplitElement(spRemaining, "/") - if len(spRemaining) > 0 { - continue - } - a.SubType = strings.TrimFunc(sp1, stringTrimSpaceCutset) + continue } - if len(remainingPart) == 0 { + if len(mrp) == 1 { accept = append(accept, a) continue } - a.Params = make(map[string]string) - for len(remainingPart) > 0 { - sp, remainingPart = nextSplitElement(remainingPart, ";") - sp0, spRemaining = nextSplitElement(sp, "=") - if len(spRemaining) == 0 { - continue - } - var sp1 string - sp1, spRemaining = nextSplitElement(spRemaining, "=") - if len(spRemaining) != 0 { + for _, param := range mrp[1:] { + sp := strings.SplitN(param, "=", 2) + if len(sp) != 2 { continue } - token := strings.TrimFunc(sp0, stringTrimSpaceCutset) + token := strings.Trim(sp[0], " ") if token == "q" { - a.Q, _ = strconv.ParseFloat(sp1, 32) + a.Q, _ = strconv.ParseFloat(sp[1], 32) } else { - a.Params[token] = strings.TrimFunc(sp1, stringTrimSpaceCutset) + a.Params[token] = strings.Trim(sp[1], " ") } } accept = append(accept, a) } - sort.Sort(accept) - return accept + slice := accept_slice(accept) + sort.Sort(slice) + + return } // Negotiate the most appropriate content_type given the accept header diff --git a/services/vendor/github.com/prometheus/common/model/alert.go b/services/vendor/github.com/prometheus/common/model/alert.go index 80d1fe94..178fdbaf 100644 --- a/services/vendor/github.com/prometheus/common/model/alert.go +++ b/services/vendor/github.com/prometheus/common/model/alert.go @@ -75,12 +75,7 @@ func (a *Alert) ResolvedAt(ts time.Time) bool { // Status returns the status of the alert. func (a *Alert) Status() AlertStatus { - return a.StatusAt(time.Now()) -} - -// StatusAt returns the status of the alert at the given timestamp. -func (a *Alert) StatusAt(ts time.Time) AlertStatus { - if a.ResolvedAt(ts) { + if a.Resolved() { return AlertResolved } return AlertFiring @@ -132,17 +127,6 @@ func (as Alerts) HasFiring() bool { return false } -// HasFiringAt returns true iff one of the alerts is not resolved -// at the time ts. -func (as Alerts) HasFiringAt(ts time.Time) bool { - for _, a := range as { - if !a.ResolvedAt(ts) { - return true - } - } - return false -} - // Status returns StatusFiring iff at least one of the alerts is firing. func (as Alerts) Status() AlertStatus { if as.HasFiring() { @@ -150,12 +134,3 @@ func (as Alerts) Status() AlertStatus { } return AlertResolved } - -// StatusAt returns StatusFiring iff at least one of the alerts is firing -// at the time ts. -func (as Alerts) StatusAt(ts time.Time) AlertStatus { - if as.HasFiringAt(ts) { - return AlertFiring - } - return AlertResolved -} diff --git a/services/vendor/github.com/prometheus/common/model/labelset.go b/services/vendor/github.com/prometheus/common/model/labelset.go index d0ad88da..6eda08a7 100644 --- a/services/vendor/github.com/prometheus/common/model/labelset.go +++ b/services/vendor/github.com/prometheus/common/model/labelset.go @@ -17,6 +17,7 @@ import ( "encoding/json" "fmt" "sort" + "strings" ) // A LabelSet is a collection of LabelName and LabelValue pairs. The LabelSet @@ -128,6 +129,16 @@ func (l LabelSet) Merge(other LabelSet) LabelSet { return result } +func (l LabelSet) String() string { + lstrs := make([]string, 0, len(l)) + for l, v := range l { + lstrs = append(lstrs, fmt.Sprintf("%s=%q", l, v)) + } + + sort.Strings(lstrs) + return fmt.Sprintf("{%s}", strings.Join(lstrs, ", ")) +} + // Fingerprint returns the LabelSet's fingerprint. func (ls LabelSet) Fingerprint() Fingerprint { return labelSetToFingerprint(ls) diff --git a/services/vendor/github.com/prometheus/common/model/labelset_string.go b/services/vendor/github.com/prometheus/common/model/labelset_string.go deleted file mode 100644 index 481c47b4..00000000 --- a/services/vendor/github.com/prometheus/common/model/labelset_string.go +++ /dev/null @@ -1,45 +0,0 @@ -// Copyright 2024 The Prometheus Authors -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -//go:build go1.21 - -package model - -import ( - "bytes" - "slices" - "strconv" -) - -// String will look like `{foo="bar", more="less"}`. Names are sorted alphabetically. -func (l LabelSet) String() string { - var lna [32]string // On stack to avoid memory allocation for sorting names. - labelNames := lna[:0] - for name := range l { - labelNames = append(labelNames, string(name)) - } - slices.Sort(labelNames) - var bytea [1024]byte // On stack to avoid memory allocation while building the output. - b := bytes.NewBuffer(bytea[:0]) - b.WriteByte('{') - for i, name := range labelNames { - if i > 0 { - b.WriteString(", ") - } - b.WriteString(name) - b.WriteByte('=') - b.Write(strconv.AppendQuote(b.AvailableBuffer(), string(l[LabelName(name)]))) - } - b.WriteByte('}') - return b.String() -} diff --git a/services/vendor/github.com/prometheus/common/model/labelset_string_go120.go b/services/vendor/github.com/prometheus/common/model/labelset_string_go120.go deleted file mode 100644 index c4212685..00000000 --- a/services/vendor/github.com/prometheus/common/model/labelset_string_go120.go +++ /dev/null @@ -1,39 +0,0 @@ -// Copyright 2024 The Prometheus Authors -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -//go:build !go1.21 - -package model - -import ( - "fmt" - "sort" - "strings" -) - -// String was optimized using functions not available for go 1.20 -// or lower. We keep the old implementation for compatibility with client_golang. -// Once client golang drops support for go 1.20 (scheduled for August 2024), this -// file can be removed. -func (l LabelSet) String() string { - labelNames := make([]string, 0, len(l)) - for name := range l { - labelNames = append(labelNames, string(name)) - } - sort.Strings(labelNames) - lstrs := make([]string, 0, len(l)) - for _, name := range labelNames { - lstrs = append(lstrs, fmt.Sprintf("%s=%q", name, l[LabelName(name)])) - } - return fmt.Sprintf("{%s}", strings.Join(lstrs, ", ")) -} diff --git a/services/vendor/github.com/prometheus/common/model/metric.go b/services/vendor/github.com/prometheus/common/model/metric.go index eb865e5a..0bd29b3a 100644 --- a/services/vendor/github.com/prometheus/common/model/metric.go +++ b/services/vendor/github.com/prometheus/common/model/metric.go @@ -204,7 +204,6 @@ func EscapeMetricFamily(v *dto.MetricFamily, scheme EscapingScheme) *dto.MetricF out := &dto.MetricFamily{ Help: v.Help, Type: v.Type, - Unit: v.Unit, } // If the name is nil, copy as-is, don't try to escape. diff --git a/services/vendor/github.com/prometheus/procfs/.golangci.yml b/services/vendor/github.com/prometheus/procfs/.golangci.yml index 126df9e6..c24864a9 100644 --- a/services/vendor/github.com/prometheus/procfs/.golangci.yml +++ b/services/vendor/github.com/prometheus/procfs/.golangci.yml @@ -1,16 +1,9 @@ --- linters: enable: - - errcheck - godot - - gosimple - - govet - - ineffassign - misspell - revive - - staticcheck - - testifylint - - unused linter-settings: godot: diff --git a/services/vendor/github.com/prometheus/procfs/MAINTAINERS.md b/services/vendor/github.com/prometheus/procfs/MAINTAINERS.md index e00f3b36..56ba67d3 100644 --- a/services/vendor/github.com/prometheus/procfs/MAINTAINERS.md +++ b/services/vendor/github.com/prometheus/procfs/MAINTAINERS.md @@ -1,3 +1,2 @@ * Johannes 'fish' Ziemke @discordianfish -* Paul Gier @pgier -* Ben Kochie @SuperQ +* Paul Gier @pgier diff --git a/services/vendor/github.com/prometheus/procfs/Makefile.common b/services/vendor/github.com/prometheus/procfs/Makefile.common index 16172923..062a2818 100644 --- a/services/vendor/github.com/prometheus/procfs/Makefile.common +++ b/services/vendor/github.com/prometheus/procfs/Makefile.common @@ -49,23 +49,23 @@ endif GOTEST := $(GO) test GOTEST_DIR := ifneq ($(CIRCLE_JOB),) -ifneq ($(shell command -v gotestsum 2> /dev/null),) +ifneq ($(shell command -v gotestsum > /dev/null),) GOTEST_DIR := test-results GOTEST := gotestsum --junitfile $(GOTEST_DIR)/unit-tests.xml -- endif endif -PROMU_VERSION ?= 0.17.0 +PROMU_VERSION ?= 0.15.0 PROMU_URL := https://github.com/prometheus/promu/releases/download/v$(PROMU_VERSION)/promu-$(PROMU_VERSION).$(GO_BUILD_PLATFORM).tar.gz SKIP_GOLANGCI_LINT := GOLANGCI_LINT := GOLANGCI_LINT_OPTS ?= -GOLANGCI_LINT_VERSION ?= v1.59.0 -# golangci-lint only supports linux, darwin and windows platforms on i386/amd64/arm64. +GOLANGCI_LINT_VERSION ?= v1.54.2 +# golangci-lint only supports linux, darwin and windows platforms on i386/amd64. # windows isn't included here because of the path separator being different. ifeq ($(GOHOSTOS),$(filter $(GOHOSTOS),linux darwin)) - ifeq ($(GOHOSTARCH),$(filter $(GOHOSTARCH),amd64 i386 arm64)) + ifeq ($(GOHOSTARCH),$(filter $(GOHOSTARCH),amd64 i386)) # If we're in CI and there is an Actions file, that means the linter # is being run in Actions, so we don't need to run it here. ifneq (,$(SKIP_GOLANGCI_LINT)) @@ -169,20 +169,16 @@ common-vet: common-lint: $(GOLANGCI_LINT) ifdef GOLANGCI_LINT @echo ">> running golangci-lint" +# 'go list' needs to be executed before staticcheck to prepopulate the modules cache. +# Otherwise staticcheck might fail randomly for some reason not yet explained. + $(GO) list -e -compiled -test=true -export=false -deps=true -find=false -tags= -- ./... > /dev/null $(GOLANGCI_LINT) run $(GOLANGCI_LINT_OPTS) $(pkgs) endif -.PHONY: common-lint-fix -common-lint-fix: $(GOLANGCI_LINT) -ifdef GOLANGCI_LINT - @echo ">> running golangci-lint fix" - $(GOLANGCI_LINT) run --fix $(GOLANGCI_LINT_OPTS) $(pkgs) -endif - .PHONY: common-yamllint common-yamllint: @echo ">> running yamllint on all YAML files in the repository" -ifeq (, $(shell command -v yamllint 2> /dev/null)) +ifeq (, $(shell command -v yamllint > /dev/null)) @echo "yamllint not installed so skipping" else yamllint . @@ -208,10 +204,6 @@ common-tarball: promu @echo ">> building release tarball" $(PROMU) tarball --prefix $(PREFIX) $(BIN_DIR) -.PHONY: common-docker-repo-name -common-docker-repo-name: - @echo "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)" - .PHONY: common-docker $(BUILD_DOCKER_ARCHS) common-docker: $(BUILD_DOCKER_ARCHS) $(BUILD_DOCKER_ARCHS): common-docker-%: diff --git a/services/vendor/github.com/prometheus/procfs/arp.go b/services/vendor/github.com/prometheus/procfs/arp.go index cdcc8a7c..28783e2d 100644 --- a/services/vendor/github.com/prometheus/procfs/arp.go +++ b/services/vendor/github.com/prometheus/procfs/arp.go @@ -55,7 +55,7 @@ type ARPEntry struct { func (fs FS) GatherARPEntries() ([]ARPEntry, error) { data, err := os.ReadFile(fs.proc.Path("net/arp")) if err != nil { - return nil, fmt.Errorf("%w: error reading arp %s: %w", ErrFileRead, fs.proc.Path("net/arp"), err) + return nil, fmt.Errorf("%s: error reading arp %s: %w", ErrFileRead, fs.proc.Path("net/arp"), err) } return parseARPEntries(data) @@ -78,11 +78,11 @@ func parseARPEntries(data []byte) ([]ARPEntry, error) { } else if width == expectedDataWidth { entry, err := parseARPEntry(columns) if err != nil { - return []ARPEntry{}, fmt.Errorf("%w: Failed to parse ARP entry: %v: %w", ErrFileParse, entry, err) + return []ARPEntry{}, fmt.Errorf("%s: Failed to parse ARP entry: %v: %w", ErrFileParse, entry, err) } entries = append(entries, entry) } else { - return []ARPEntry{}, fmt.Errorf("%w: %d columns found, but expected %d: %w", ErrFileParse, width, expectedDataWidth, err) + return []ARPEntry{}, fmt.Errorf("%s: %d columns found, but expected %d: %w", ErrFileParse, width, expectedDataWidth, err) } } diff --git a/services/vendor/github.com/prometheus/procfs/buddyinfo.go b/services/vendor/github.com/prometheus/procfs/buddyinfo.go index 83807500..4a173636 100644 --- a/services/vendor/github.com/prometheus/procfs/buddyinfo.go +++ b/services/vendor/github.com/prometheus/procfs/buddyinfo.go @@ -58,8 +58,8 @@ func parseBuddyInfo(r io.Reader) ([]BuddyInfo, error) { return nil, fmt.Errorf("%w: Invalid number of fields, found: %v", ErrFileParse, parts) } - node := strings.TrimSuffix(parts[1], ",") - zone := strings.TrimSuffix(parts[3], ",") + node := strings.TrimRight(parts[1], ",") + zone := strings.TrimRight(parts[3], ",") arraySize := len(parts[4:]) if bucketCount == -1 { @@ -74,7 +74,7 @@ func parseBuddyInfo(r io.Reader) ([]BuddyInfo, error) { for i := 0; i < arraySize; i++ { sizes[i], err = strconv.ParseFloat(parts[i+4], 64) if err != nil { - return nil, fmt.Errorf("%w: Invalid valid in buddyinfo: %f: %w", ErrFileParse, sizes[i], err) + return nil, fmt.Errorf("%s: Invalid valid in buddyinfo: %f: %w", ErrFileParse, sizes[i], err) } } diff --git a/services/vendor/github.com/prometheus/procfs/cpuinfo.go b/services/vendor/github.com/prometheus/procfs/cpuinfo.go index f0950bb4..f4f5501c 100644 --- a/services/vendor/github.com/prometheus/procfs/cpuinfo.go +++ b/services/vendor/github.com/prometheus/procfs/cpuinfo.go @@ -194,7 +194,7 @@ func parseCPUInfoARM(info []byte) ([]CPUInfo, error) { firstLine := firstNonEmptyLine(scanner) match, err := regexp.MatchString("^[Pp]rocessor", firstLine) if !match || !strings.Contains(firstLine, ":") { - return nil, fmt.Errorf("%w: Cannot parse line: %q: %w", ErrFileParse, firstLine, err) + return nil, fmt.Errorf("%s: Cannot parse line: %q: %w", ErrFileParse, firstLine, err) } field := strings.SplitN(firstLine, ": ", 2) @@ -386,7 +386,7 @@ func parseCPUInfoLoong(info []byte) ([]CPUInfo, error) { // find the first "processor" line firstLine := firstNonEmptyLine(scanner) if !strings.HasPrefix(firstLine, "system type") || !strings.Contains(firstLine, ":") { - return nil, fmt.Errorf("%w: %q", ErrFileParse, firstLine) + return nil, errors.New("invalid cpuinfo file: " + firstLine) } field := strings.SplitN(firstLine, ": ", 2) cpuinfo := []CPUInfo{} diff --git a/services/vendor/github.com/prometheus/procfs/crypto.go b/services/vendor/github.com/prometheus/procfs/crypto.go index 5f2a37a7..9a73e263 100644 --- a/services/vendor/github.com/prometheus/procfs/crypto.go +++ b/services/vendor/github.com/prometheus/procfs/crypto.go @@ -55,13 +55,13 @@ func (fs FS) Crypto() ([]Crypto, error) { path := fs.proc.Path("crypto") b, err := util.ReadFileNoStat(path) if err != nil { - return nil, fmt.Errorf("%w: Cannot read file %v: %w", ErrFileRead, b, err) + return nil, fmt.Errorf("%s: Cannot read file %v: %w", ErrFileRead, b, err) } crypto, err := parseCrypto(bytes.NewReader(b)) if err != nil { - return nil, fmt.Errorf("%w: Cannot parse %v: %w", ErrFileParse, crypto, err) + return nil, fmt.Errorf("%s: Cannot parse %v: %w", ErrFileParse, crypto, err) } return crypto, nil @@ -84,7 +84,7 @@ func parseCrypto(r io.Reader) ([]Crypto, error) { kv := strings.Split(text, ":") if len(kv) != 2 { - return nil, fmt.Errorf("%w: Cannot parse line: %q", ErrFileParse, text) + return nil, fmt.Errorf("%w: Cannot parae line: %q", ErrFileParse, text) } k := strings.TrimSpace(kv[0]) diff --git a/services/vendor/github.com/prometheus/procfs/fscache.go b/services/vendor/github.com/prometheus/procfs/fscache.go index cf2e3eaa..f560a8db 100644 --- a/services/vendor/github.com/prometheus/procfs/fscache.go +++ b/services/vendor/github.com/prometheus/procfs/fscache.go @@ -236,7 +236,7 @@ func (fs FS) Fscacheinfo() (Fscacheinfo, error) { m, err := parseFscacheinfo(bytes.NewReader(b)) if err != nil { - return Fscacheinfo{}, fmt.Errorf("%w: Cannot parse %v: %w", ErrFileParse, m, err) + return Fscacheinfo{}, fmt.Errorf("%s: Cannot parse %v: %w", ErrFileParse, m, err) } return *m, nil @@ -245,7 +245,7 @@ func (fs FS) Fscacheinfo() (Fscacheinfo, error) { func setFSCacheFields(fields []string, setFields ...*uint64) error { var err error if len(fields) < len(setFields) { - return fmt.Errorf("%w: Expected %d, but got %d: %w", ErrFileParse, len(setFields), len(fields), err) + return fmt.Errorf("%s: Expected %d, but got %d: %w", ErrFileParse, len(setFields), len(fields), err) } for i := range setFields { diff --git a/services/vendor/github.com/prometheus/procfs/ipvs.go b/services/vendor/github.com/prometheus/procfs/ipvs.go index bc3a20c9..5a145bbf 100644 --- a/services/vendor/github.com/prometheus/procfs/ipvs.go +++ b/services/vendor/github.com/prometheus/procfs/ipvs.go @@ -221,16 +221,16 @@ func parseIPPort(s string) (net.IP, uint16, error) { case 46: ip = net.ParseIP(s[1:40]) if ip == nil { - return nil, 0, fmt.Errorf("%w: Invalid IPv6 addr %s: %w", ErrFileParse, s[1:40], err) + return nil, 0, fmt.Errorf("%s: Invalid IPv6 addr %s: %w", ErrFileParse, s[1:40], err) } default: - return nil, 0, fmt.Errorf("%w: Unexpected IP:Port %s: %w", ErrFileParse, s, err) + return nil, 0, fmt.Errorf("%s: Unexpected IP:Port %s: %w", ErrFileParse, s, err) } portString := s[len(s)-4:] if len(portString) != 4 { return nil, 0, - fmt.Errorf("%w: Unexpected port string format %s: %w", ErrFileParse, portString, err) + fmt.Errorf("%s: Unexpected port string format %s: %w", ErrFileParse, portString, err) } port, err := strconv.ParseUint(portString, 16, 16) if err != nil { diff --git a/services/vendor/github.com/prometheus/procfs/loadavg.go b/services/vendor/github.com/prometheus/procfs/loadavg.go index 332e76c1..59465c5b 100644 --- a/services/vendor/github.com/prometheus/procfs/loadavg.go +++ b/services/vendor/github.com/prometheus/procfs/loadavg.go @@ -51,7 +51,7 @@ func parseLoad(loadavgBytes []byte) (*LoadAvg, error) { for i, load := range parts[0:3] { loads[i], err = strconv.ParseFloat(load, 64) if err != nil { - return nil, fmt.Errorf("%w: Cannot parse load: %f: %w", ErrFileParse, loads[i], err) + return nil, fmt.Errorf("%s: Cannot parse load: %f: %w", ErrFileParse, loads[i], err) } } return &LoadAvg{ diff --git a/services/vendor/github.com/prometheus/procfs/mdstat.go b/services/vendor/github.com/prometheus/procfs/mdstat.go index 67a9d2b4..fdd4b954 100644 --- a/services/vendor/github.com/prometheus/procfs/mdstat.go +++ b/services/vendor/github.com/prometheus/procfs/mdstat.go @@ -23,7 +23,7 @@ import ( var ( statusLineRE = regexp.MustCompile(`(\d+) blocks .*\[(\d+)/(\d+)\] \[([U_]+)\]`) - recoveryLineBlocksRE = regexp.MustCompile(`\((\d+/\d+)\)`) + recoveryLineBlocksRE = regexp.MustCompile(`\((\d+)/\d+\)`) recoveryLinePctRE = regexp.MustCompile(`= (.+)%`) recoveryLineFinishRE = regexp.MustCompile(`finish=(.+)min`) recoveryLineSpeedRE = regexp.MustCompile(`speed=(.+)[A-Z]`) @@ -50,8 +50,6 @@ type MDStat struct { BlocksTotal int64 // Number of blocks on the device that are in sync. BlocksSynced int64 - // Number of blocks on the device that need to be synced. - BlocksToBeSynced int64 // progress percentage of current sync BlocksSyncedPct float64 // estimated finishing time for current sync (in minutes) @@ -72,7 +70,7 @@ func (fs FS) MDStat() ([]MDStat, error) { } mdstat, err := parseMDStat(data) if err != nil { - return nil, fmt.Errorf("%w: Cannot parse %v: %w", ErrFileParse, fs.proc.Path("mdstat"), err) + return nil, fmt.Errorf("%s: Cannot parse %v: %w", ErrFileParse, fs.proc.Path("mdstat"), err) } return mdstat, nil } @@ -92,7 +90,7 @@ func parseMDStat(mdStatData []byte) ([]MDStat, error) { deviceFields := strings.Fields(line) if len(deviceFields) < 3 { - return nil, fmt.Errorf("%w: Expected 3+ lines, got %q", ErrFileParse, line) + return nil, fmt.Errorf("%s: Expected 3+ lines, got %q", ErrFileParse, line) } mdName := deviceFields[0] // mdx state := deviceFields[2] // active or inactive @@ -107,7 +105,7 @@ func parseMDStat(mdStatData []byte) ([]MDStat, error) { active, total, down, size, err := evalStatusLine(lines[i], lines[i+1]) if err != nil { - return nil, fmt.Errorf("%w: Cannot parse md device lines: %v: %w", ErrFileParse, active, err) + return nil, fmt.Errorf("%s: Cannot parse md device lines: %v: %w", ErrFileParse, active, err) } syncLineIdx := i + 2 @@ -117,8 +115,7 @@ func parseMDStat(mdStatData []byte) ([]MDStat, error) { // If device is syncing at the moment, get the number of currently // synced bytes, otherwise that number equals the size of the device. - blocksSynced := size - blocksToBeSynced := size + syncedBlocks := size speed := float64(0) finish := float64(0) pct := float64(0) @@ -139,11 +136,11 @@ func parseMDStat(mdStatData []byte) ([]MDStat, error) { // Handle case when resync=PENDING or resync=DELAYED. if strings.Contains(lines[syncLineIdx], "PENDING") || strings.Contains(lines[syncLineIdx], "DELAYED") { - blocksSynced = 0 + syncedBlocks = 0 } else { - blocksSynced, blocksToBeSynced, pct, finish, speed, err = evalRecoveryLine(lines[syncLineIdx]) + syncedBlocks, pct, finish, speed, err = evalRecoveryLine(lines[syncLineIdx]) if err != nil { - return nil, fmt.Errorf("%w: Cannot parse sync line in md device: %q: %w", ErrFileParse, mdName, err) + return nil, fmt.Errorf("%s: Cannot parse sync line in md device: %q: %w", ErrFileParse, mdName, err) } } } @@ -157,8 +154,7 @@ func parseMDStat(mdStatData []byte) ([]MDStat, error) { DisksSpare: spare, DisksTotal: total, BlocksTotal: size, - BlocksSynced: blocksSynced, - BlocksToBeSynced: blocksToBeSynced, + BlocksSynced: syncedBlocks, BlocksSyncedPct: pct, BlocksSyncedFinishTime: finish, BlocksSyncedSpeed: speed, @@ -172,13 +168,13 @@ func parseMDStat(mdStatData []byte) ([]MDStat, error) { func evalStatusLine(deviceLine, statusLine string) (active, total, down, size int64, err error) { statusFields := strings.Fields(statusLine) if len(statusFields) < 1 { - return 0, 0, 0, 0, fmt.Errorf("%w: Unexpected statusline %q: %w", ErrFileParse, statusLine, err) + return 0, 0, 0, 0, fmt.Errorf("%s: Unexpected statusline %q: %w", ErrFileParse, statusLine, err) } sizeStr := statusFields[0] size, err = strconv.ParseInt(sizeStr, 10, 64) if err != nil { - return 0, 0, 0, 0, fmt.Errorf("%w: Unexpected statusline %q: %w", ErrFileParse, statusLine, err) + return 0, 0, 0, 0, fmt.Errorf("%s: Unexpected statusline %q: %w", ErrFileParse, statusLine, err) } if strings.Contains(deviceLine, "raid0") || strings.Contains(deviceLine, "linear") { @@ -193,71 +189,65 @@ func evalStatusLine(deviceLine, statusLine string) (active, total, down, size in matches := statusLineRE.FindStringSubmatch(statusLine) if len(matches) != 5 { - return 0, 0, 0, 0, fmt.Errorf("%w: Could not fild all substring matches %s: %w", ErrFileParse, statusLine, err) + return 0, 0, 0, 0, fmt.Errorf("%s: Could not fild all substring matches %s: %w", ErrFileParse, statusLine, err) } total, err = strconv.ParseInt(matches[2], 10, 64) if err != nil { - return 0, 0, 0, 0, fmt.Errorf("%w: Unexpected statusline %q: %w", ErrFileParse, statusLine, err) + return 0, 0, 0, 0, fmt.Errorf("%s: Unexpected statusline %q: %w", ErrFileParse, statusLine, err) } active, err = strconv.ParseInt(matches[3], 10, 64) if err != nil { - return 0, 0, 0, 0, fmt.Errorf("%w: Unexpected active %d: %w", ErrFileParse, active, err) + return 0, 0, 0, 0, fmt.Errorf("%s: Unexpected active %d: %w", ErrFileParse, active, err) } down = int64(strings.Count(matches[4], "_")) return active, total, down, size, nil } -func evalRecoveryLine(recoveryLine string) (blocksSynced int64, blocksToBeSynced int64, pct float64, finish float64, speed float64, err error) { +func evalRecoveryLine(recoveryLine string) (syncedBlocks int64, pct float64, finish float64, speed float64, err error) { matches := recoveryLineBlocksRE.FindStringSubmatch(recoveryLine) if len(matches) != 2 { - return 0, 0, 0, 0, 0, fmt.Errorf("%w: Unexpected recoveryLine blocks %s: %w", ErrFileParse, recoveryLine, err) + return 0, 0, 0, 0, fmt.Errorf("%s: Unexpected recoveryLine %s: %w", ErrFileParse, recoveryLine, err) } - blocks := strings.Split(matches[1], "/") - blocksSynced, err = strconv.ParseInt(blocks[0], 10, 64) + syncedBlocks, err = strconv.ParseInt(matches[1], 10, 64) if err != nil { - return 0, 0, 0, 0, 0, fmt.Errorf("%w: Unable to parse recovery blocks synced %q: %w", ErrFileParse, matches[1], err) - } - - blocksToBeSynced, err = strconv.ParseInt(blocks[1], 10, 64) - if err != nil { - return blocksSynced, 0, 0, 0, 0, fmt.Errorf("%w: Unable to parse recovery to be synced blocks %q: %w", ErrFileParse, matches[2], err) + return 0, 0, 0, 0, fmt.Errorf("%s: Unexpected parsing of recoveryLine %q: %w", ErrFileParse, recoveryLine, err) } // Get percentage complete matches = recoveryLinePctRE.FindStringSubmatch(recoveryLine) if len(matches) != 2 { - return blocksSynced, blocksToBeSynced, 0, 0, 0, fmt.Errorf("%w: Unexpected recoveryLine matching percentage %s", ErrFileParse, recoveryLine) + return syncedBlocks, 0, 0, 0, fmt.Errorf("%w: Unexpected recoveryLine matching percentage %s", ErrFileParse, recoveryLine) } pct, err = strconv.ParseFloat(strings.TrimSpace(matches[1]), 64) if err != nil { - return blocksSynced, blocksToBeSynced, 0, 0, 0, fmt.Errorf("%w: Error parsing float from recoveryLine %q", ErrFileParse, recoveryLine) + return syncedBlocks, 0, 0, 0, fmt.Errorf("%w: Error parsing float from recoveryLine %q", ErrFileParse, recoveryLine) } // Get time expected left to complete matches = recoveryLineFinishRE.FindStringSubmatch(recoveryLine) if len(matches) != 2 { - return blocksSynced, blocksToBeSynced, pct, 0, 0, fmt.Errorf("%w: Unexpected recoveryLine matching est. finish time: %s", ErrFileParse, recoveryLine) + return syncedBlocks, pct, 0, 0, fmt.Errorf("%w: Unexpected recoveryLine matching est. finish time: %s", ErrFileParse, recoveryLine) } finish, err = strconv.ParseFloat(matches[1], 64) if err != nil { - return blocksSynced, blocksToBeSynced, pct, 0, 0, fmt.Errorf("%w: Unable to parse float from recoveryLine: %q", ErrFileParse, recoveryLine) + return syncedBlocks, pct, 0, 0, fmt.Errorf("%w: Unable to parse float from recoveryLine: %q", ErrFileParse, recoveryLine) } // Get recovery speed matches = recoveryLineSpeedRE.FindStringSubmatch(recoveryLine) if len(matches) != 2 { - return blocksSynced, blocksToBeSynced, pct, finish, 0, fmt.Errorf("%w: Unexpected recoveryLine value: %s", ErrFileParse, recoveryLine) + return syncedBlocks, pct, finish, 0, fmt.Errorf("%w: Unexpected recoveryLine value: %s", ErrFileParse, recoveryLine) } speed, err = strconv.ParseFloat(matches[1], 64) if err != nil { - return blocksSynced, blocksToBeSynced, pct, finish, 0, fmt.Errorf("%w: Error parsing float from recoveryLine: %q: %w", ErrFileParse, recoveryLine, err) + return syncedBlocks, pct, finish, 0, fmt.Errorf("%s: Error parsing float from recoveryLine: %q: %w", ErrFileParse, recoveryLine, err) } - return blocksSynced, blocksToBeSynced, pct, finish, speed, nil + return syncedBlocks, pct, finish, speed, nil } func evalComponentDevices(deviceFields []string) []string { diff --git a/services/vendor/github.com/prometheus/procfs/meminfo.go b/services/vendor/github.com/prometheus/procfs/meminfo.go index 4b2c4050..eaf00e22 100644 --- a/services/vendor/github.com/prometheus/procfs/meminfo.go +++ b/services/vendor/github.com/prometheus/procfs/meminfo.go @@ -126,7 +126,6 @@ type Meminfo struct { VmallocUsed *uint64 // largest contiguous block of vmalloc area which is free VmallocChunk *uint64 - Percpu *uint64 HardwareCorrupted *uint64 AnonHugePages *uint64 ShmemHugePages *uint64 @@ -141,55 +140,6 @@ type Meminfo struct { DirectMap4k *uint64 DirectMap2M *uint64 DirectMap1G *uint64 - - // The struct fields below are the byte-normalized counterparts to the - // existing struct fields. Values are normalized using the optional - // unit field in the meminfo line. - MemTotalBytes *uint64 - MemFreeBytes *uint64 - MemAvailableBytes *uint64 - BuffersBytes *uint64 - CachedBytes *uint64 - SwapCachedBytes *uint64 - ActiveBytes *uint64 - InactiveBytes *uint64 - ActiveAnonBytes *uint64 - InactiveAnonBytes *uint64 - ActiveFileBytes *uint64 - InactiveFileBytes *uint64 - UnevictableBytes *uint64 - MlockedBytes *uint64 - SwapTotalBytes *uint64 - SwapFreeBytes *uint64 - DirtyBytes *uint64 - WritebackBytes *uint64 - AnonPagesBytes *uint64 - MappedBytes *uint64 - ShmemBytes *uint64 - SlabBytes *uint64 - SReclaimableBytes *uint64 - SUnreclaimBytes *uint64 - KernelStackBytes *uint64 - PageTablesBytes *uint64 - NFSUnstableBytes *uint64 - BounceBytes *uint64 - WritebackTmpBytes *uint64 - CommitLimitBytes *uint64 - CommittedASBytes *uint64 - VmallocTotalBytes *uint64 - VmallocUsedBytes *uint64 - VmallocChunkBytes *uint64 - PercpuBytes *uint64 - HardwareCorruptedBytes *uint64 - AnonHugePagesBytes *uint64 - ShmemHugePagesBytes *uint64 - ShmemPmdMappedBytes *uint64 - CmaTotalBytes *uint64 - CmaFreeBytes *uint64 - HugepagesizeBytes *uint64 - DirectMap4kBytes *uint64 - DirectMap2MBytes *uint64 - DirectMap1GBytes *uint64 } // Meminfo returns an information about current kernel/system memory statistics. @@ -202,7 +152,7 @@ func (fs FS) Meminfo() (Meminfo, error) { m, err := parseMemInfo(bytes.NewReader(b)) if err != nil { - return Meminfo{}, fmt.Errorf("%w: %w", ErrFileParse, err) + return Meminfo{}, fmt.Errorf("%s: %w", ErrFileParse, err) } return *m, nil @@ -212,176 +162,114 @@ func parseMemInfo(r io.Reader) (*Meminfo, error) { var m Meminfo s := bufio.NewScanner(r) for s.Scan() { + // Each line has at least a name and value; we ignore the unit. fields := strings.Fields(s.Text()) - var val, valBytes uint64 + if len(fields) < 2 { + return nil, fmt.Errorf("%w: Malformed line %q", ErrFileParse, s.Text()) + } - val, err := strconv.ParseUint(fields[1], 0, 64) + v, err := strconv.ParseUint(fields[1], 0, 64) if err != nil { return nil, err } - switch len(fields) { - case 2: - // No unit present, use the parsed the value as bytes directly. - valBytes = val - case 3: - // Unit present in optional 3rd field, convert it to - // bytes. The only unit supported within the Linux - // kernel is `kB`. - if fields[2] != "kB" { - return nil, fmt.Errorf("%w: Unsupported unit in optional 3rd field %q", ErrFileParse, fields[2]) - } - - valBytes = 1024 * val - - default: - return nil, fmt.Errorf("%w: Malformed line %q", ErrFileParse, s.Text()) - } - switch fields[0] { case "MemTotal:": - m.MemTotal = &val - m.MemTotalBytes = &valBytes + m.MemTotal = &v case "MemFree:": - m.MemFree = &val - m.MemFreeBytes = &valBytes + m.MemFree = &v case "MemAvailable:": - m.MemAvailable = &val - m.MemAvailableBytes = &valBytes + m.MemAvailable = &v case "Buffers:": - m.Buffers = &val - m.BuffersBytes = &valBytes + m.Buffers = &v case "Cached:": - m.Cached = &val - m.CachedBytes = &valBytes + m.Cached = &v case "SwapCached:": - m.SwapCached = &val - m.SwapCachedBytes = &valBytes + m.SwapCached = &v case "Active:": - m.Active = &val - m.ActiveBytes = &valBytes + m.Active = &v case "Inactive:": - m.Inactive = &val - m.InactiveBytes = &valBytes + m.Inactive = &v case "Active(anon):": - m.ActiveAnon = &val - m.ActiveAnonBytes = &valBytes + m.ActiveAnon = &v case "Inactive(anon):": - m.InactiveAnon = &val - m.InactiveAnonBytes = &valBytes + m.InactiveAnon = &v case "Active(file):": - m.ActiveFile = &val - m.ActiveFileBytes = &valBytes + m.ActiveFile = &v case "Inactive(file):": - m.InactiveFile = &val - m.InactiveFileBytes = &valBytes + m.InactiveFile = &v case "Unevictable:": - m.Unevictable = &val - m.UnevictableBytes = &valBytes + m.Unevictable = &v case "Mlocked:": - m.Mlocked = &val - m.MlockedBytes = &valBytes + m.Mlocked = &v case "SwapTotal:": - m.SwapTotal = &val - m.SwapTotalBytes = &valBytes + m.SwapTotal = &v case "SwapFree:": - m.SwapFree = &val - m.SwapFreeBytes = &valBytes + m.SwapFree = &v case "Dirty:": - m.Dirty = &val - m.DirtyBytes = &valBytes + m.Dirty = &v case "Writeback:": - m.Writeback = &val - m.WritebackBytes = &valBytes + m.Writeback = &v case "AnonPages:": - m.AnonPages = &val - m.AnonPagesBytes = &valBytes + m.AnonPages = &v case "Mapped:": - m.Mapped = &val - m.MappedBytes = &valBytes + m.Mapped = &v case "Shmem:": - m.Shmem = &val - m.ShmemBytes = &valBytes + m.Shmem = &v case "Slab:": - m.Slab = &val - m.SlabBytes = &valBytes + m.Slab = &v case "SReclaimable:": - m.SReclaimable = &val - m.SReclaimableBytes = &valBytes + m.SReclaimable = &v case "SUnreclaim:": - m.SUnreclaim = &val - m.SUnreclaimBytes = &valBytes + m.SUnreclaim = &v case "KernelStack:": - m.KernelStack = &val - m.KernelStackBytes = &valBytes + m.KernelStack = &v case "PageTables:": - m.PageTables = &val - m.PageTablesBytes = &valBytes + m.PageTables = &v case "NFS_Unstable:": - m.NFSUnstable = &val - m.NFSUnstableBytes = &valBytes + m.NFSUnstable = &v case "Bounce:": - m.Bounce = &val - m.BounceBytes = &valBytes + m.Bounce = &v case "WritebackTmp:": - m.WritebackTmp = &val - m.WritebackTmpBytes = &valBytes + m.WritebackTmp = &v case "CommitLimit:": - m.CommitLimit = &val - m.CommitLimitBytes = &valBytes + m.CommitLimit = &v case "Committed_AS:": - m.CommittedAS = &val - m.CommittedASBytes = &valBytes + m.CommittedAS = &v case "VmallocTotal:": - m.VmallocTotal = &val - m.VmallocTotalBytes = &valBytes + m.VmallocTotal = &v case "VmallocUsed:": - m.VmallocUsed = &val - m.VmallocUsedBytes = &valBytes + m.VmallocUsed = &v case "VmallocChunk:": - m.VmallocChunk = &val - m.VmallocChunkBytes = &valBytes - case "Percpu:": - m.Percpu = &val - m.PercpuBytes = &valBytes + m.VmallocChunk = &v case "HardwareCorrupted:": - m.HardwareCorrupted = &val - m.HardwareCorruptedBytes = &valBytes + m.HardwareCorrupted = &v case "AnonHugePages:": - m.AnonHugePages = &val - m.AnonHugePagesBytes = &valBytes + m.AnonHugePages = &v case "ShmemHugePages:": - m.ShmemHugePages = &val - m.ShmemHugePagesBytes = &valBytes + m.ShmemHugePages = &v case "ShmemPmdMapped:": - m.ShmemPmdMapped = &val - m.ShmemPmdMappedBytes = &valBytes + m.ShmemPmdMapped = &v case "CmaTotal:": - m.CmaTotal = &val - m.CmaTotalBytes = &valBytes + m.CmaTotal = &v case "CmaFree:": - m.CmaFree = &val - m.CmaFreeBytes = &valBytes + m.CmaFree = &v case "HugePages_Total:": - m.HugePagesTotal = &val + m.HugePagesTotal = &v case "HugePages_Free:": - m.HugePagesFree = &val + m.HugePagesFree = &v case "HugePages_Rsvd:": - m.HugePagesRsvd = &val + m.HugePagesRsvd = &v case "HugePages_Surp:": - m.HugePagesSurp = &val + m.HugePagesSurp = &v case "Hugepagesize:": - m.Hugepagesize = &val - m.HugepagesizeBytes = &valBytes + m.Hugepagesize = &v case "DirectMap4k:": - m.DirectMap4k = &val - m.DirectMap4kBytes = &valBytes + m.DirectMap4k = &v case "DirectMap2M:": - m.DirectMap2M = &val - m.DirectMap2MBytes = &valBytes + m.DirectMap2M = &v case "DirectMap1G:": - m.DirectMap1G = &val - m.DirectMap1GBytes = &valBytes + m.DirectMap1G = &v } } diff --git a/services/vendor/github.com/prometheus/procfs/mountinfo.go b/services/vendor/github.com/prometheus/procfs/mountinfo.go index a704c5e7..388ebf39 100644 --- a/services/vendor/github.com/prometheus/procfs/mountinfo.go +++ b/services/vendor/github.com/prometheus/procfs/mountinfo.go @@ -109,7 +109,7 @@ func parseMountInfoString(mountString string) (*MountInfo, error) { if mountInfo[6] != "" { mount.OptionalFields, err = mountOptionsParseOptionalFields(mountInfo[6 : mountInfoLength-4]) if err != nil { - return nil, fmt.Errorf("%w: %w", ErrFileParse, err) + return nil, fmt.Errorf("%s: %w", ErrFileParse, err) } } return mount, nil diff --git a/services/vendor/github.com/prometheus/procfs/mountstats.go b/services/vendor/github.com/prometheus/procfs/mountstats.go index 75a3b6c8..9d8af6db 100644 --- a/services/vendor/github.com/prometheus/procfs/mountstats.go +++ b/services/vendor/github.com/prometheus/procfs/mountstats.go @@ -88,7 +88,7 @@ type MountStatsNFS struct { // Statistics broken down by filesystem operation. Operations []NFSOperationStats // Statistics about the NFS RPC transport. - Transport []NFSTransportStats + Transport NFSTransportStats } // mountStats implements MountStats. @@ -194,6 +194,8 @@ type NFSOperationStats struct { CumulativeTotalResponseMilliseconds uint64 // Duration from when a request was enqueued to when it was completely handled. CumulativeTotalRequestMilliseconds uint64 + // The average time from the point the client sends RPC requests until it receives the response. + AverageRTTMilliseconds float64 // The count of operations that complete with tk_status < 0. These statuses usually indicate error conditions. Errors uint64 } @@ -432,7 +434,7 @@ func parseMountStatsNFS(s *bufio.Scanner, statVersion string) (*MountStatsNFS, e return nil, err } - stats.Transport = append(stats.Transport, *tstats) + stats.Transport = *tstats } // When encountering "per-operation statistics", we must break this @@ -580,6 +582,9 @@ func parseNFSOperationStats(s *bufio.Scanner) ([]NFSOperationStats, error) { CumulativeTotalResponseMilliseconds: ns[6], CumulativeTotalRequestMilliseconds: ns[7], } + if ns[0] != 0 { + opStats.AverageRTTMilliseconds = float64(ns[6]) / float64(ns[0]) + } if len(ns) > 8 { opStats.Errors = ns[8] @@ -627,7 +632,7 @@ func parseNFSTransportStats(ss []string, statVersion string) (*NFSTransportStats return nil, fmt.Errorf("%w: invalid NFS transport stats 1.1 statement: %v, protocol: %v", ErrFileParse, ss, protocol) } default: - return nil, fmt.Errorf("%w: Unrecognized NFS transport stats version: %q, protocol: %v", ErrFileParse, statVersion, protocol) + return nil, fmt.Errorf("%s: Unrecognized NFS transport stats version: %q, protocol: %v", ErrFileParse, statVersion, protocol) } // Allocate enough for v1.1 stats since zero value for v1.1 stats will be okay diff --git a/services/vendor/github.com/prometheus/procfs/net_conntrackstat.go b/services/vendor/github.com/prometheus/procfs/net_conntrackstat.go index 316df5fb..fdfa4561 100644 --- a/services/vendor/github.com/prometheus/procfs/net_conntrackstat.go +++ b/services/vendor/github.com/prometheus/procfs/net_conntrackstat.go @@ -58,7 +58,7 @@ func readConntrackStat(path string) ([]ConntrackStatEntry, error) { stat, err := parseConntrackStat(bytes.NewReader(b)) if err != nil { - return nil, fmt.Errorf("%w: Cannot read file: %v: %w", ErrFileRead, path, err) + return nil, fmt.Errorf("%s: Cannot read file: %v: %w", ErrFileRead, path, err) } return stat, nil @@ -86,7 +86,7 @@ func parseConntrackStat(r io.Reader) ([]ConntrackStatEntry, error) { func parseConntrackStatEntry(fields []string) (*ConntrackStatEntry, error) { entries, err := util.ParseHexUint64s(fields) if err != nil { - return nil, fmt.Errorf("%w: Cannot parse entry: %d: %w", ErrFileParse, entries, err) + return nil, fmt.Errorf("%s: Cannot parse entry: %d: %w", ErrFileParse, entries, err) } numEntries := len(entries) if numEntries < 16 || numEntries > 17 { diff --git a/services/vendor/github.com/prometheus/procfs/net_ip_socket.go b/services/vendor/github.com/prometheus/procfs/net_ip_socket.go index b70f1fc7..4da81ea5 100644 --- a/services/vendor/github.com/prometheus/procfs/net_ip_socket.go +++ b/services/vendor/github.com/prometheus/procfs/net_ip_socket.go @@ -50,13 +50,10 @@ type ( // UsedSockets shows the total number of parsed lines representing the // number of used sockets. UsedSockets uint64 - // Drops shows the total number of dropped packets of all UPD sockets. - Drops *uint64 } // netIPSocketLine represents the fields parsed from a single line // in /proc/net/{t,u}dp{,6}. Fields which are not used by IPSocket are skipped. - // Drops is non-nil for udp{,6}, but nil for tcp{,6}. // For the proc file format details, see https://linux.die.net/man/5/proc. netIPSocketLine struct { Sl uint64 @@ -69,7 +66,6 @@ type ( RxQueue uint64 UID uint64 Inode uint64 - Drops *uint64 } ) @@ -81,14 +77,13 @@ func newNetIPSocket(file string) (NetIPSocket, error) { defer f.Close() var netIPSocket NetIPSocket - isUDP := strings.Contains(file, "udp") lr := io.LimitReader(f, readLimit) s := bufio.NewScanner(lr) s.Scan() // skip first line with headers for s.Scan() { fields := strings.Fields(s.Text()) - line, err := parseNetIPSocketLine(fields, isUDP) + line, err := parseNetIPSocketLine(fields) if err != nil { return nil, err } @@ -109,25 +104,19 @@ func newNetIPSocketSummary(file string) (*NetIPSocketSummary, error) { defer f.Close() var netIPSocketSummary NetIPSocketSummary - var udpPacketDrops uint64 - isUDP := strings.Contains(file, "udp") lr := io.LimitReader(f, readLimit) s := bufio.NewScanner(lr) s.Scan() // skip first line with headers for s.Scan() { fields := strings.Fields(s.Text()) - line, err := parseNetIPSocketLine(fields, isUDP) + line, err := parseNetIPSocketLine(fields) if err != nil { return nil, err } netIPSocketSummary.TxQueueLength += line.TxQueue netIPSocketSummary.RxQueueLength += line.RxQueue netIPSocketSummary.UsedSockets++ - if isUDP { - udpPacketDrops += *line.Drops - netIPSocketSummary.Drops = &udpPacketDrops - } } if err := s.Err(); err != nil { return nil, err @@ -141,7 +130,7 @@ func parseIP(hexIP string) (net.IP, error) { var byteIP []byte byteIP, err := hex.DecodeString(hexIP) if err != nil { - return nil, fmt.Errorf("%w: Cannot parse socket field in %q: %w", ErrFileParse, hexIP, err) + return nil, fmt.Errorf("%s: Cannot parse socket field in %q: %w", ErrFileParse, hexIP, err) } switch len(byteIP) { case 4: @@ -155,12 +144,12 @@ func parseIP(hexIP string) (net.IP, error) { } return i, nil default: - return nil, fmt.Errorf("%w: Unable to parse IP %s: %v", ErrFileParse, hexIP, nil) + return nil, fmt.Errorf("%s: Unable to parse IP %s: %w", ErrFileParse, hexIP, nil) } } // parseNetIPSocketLine parses a single line, represented by a list of fields. -func parseNetIPSocketLine(fields []string, isUDP bool) (*netIPSocketLine, error) { +func parseNetIPSocketLine(fields []string) (*netIPSocketLine, error) { line := &netIPSocketLine{} if len(fields) < 10 { return nil, fmt.Errorf( @@ -178,7 +167,7 @@ func parseNetIPSocketLine(fields []string, isUDP bool) (*netIPSocketLine, error) } if line.Sl, err = strconv.ParseUint(s[0], 0, 64); err != nil { - return nil, fmt.Errorf("%w: Unable to parse sl field in %q: %w", ErrFileParse, line.Sl, err) + return nil, fmt.Errorf("%s: Unable to parse sl field in %q: %w", ErrFileParse, line.Sl, err) } // local_address l := strings.Split(fields[1], ":") @@ -189,7 +178,7 @@ func parseNetIPSocketLine(fields []string, isUDP bool) (*netIPSocketLine, error) return nil, err } if line.LocalPort, err = strconv.ParseUint(l[1], 16, 64); err != nil { - return nil, fmt.Errorf("%w: Unable to parse local_address port value line %q: %w", ErrFileParse, line.LocalPort, err) + return nil, fmt.Errorf("%s: Unable to parse local_address port value line %q: %w", ErrFileParse, line.LocalPort, err) } // remote_address @@ -201,12 +190,12 @@ func parseNetIPSocketLine(fields []string, isUDP bool) (*netIPSocketLine, error) return nil, err } if line.RemPort, err = strconv.ParseUint(r[1], 16, 64); err != nil { - return nil, fmt.Errorf("%w: Cannot parse rem_address port value in %q: %w", ErrFileParse, line.RemPort, err) + return nil, fmt.Errorf("%s: Cannot parse rem_address port value in %q: %w", ErrFileParse, line.RemPort, err) } // st if line.St, err = strconv.ParseUint(fields[3], 16, 64); err != nil { - return nil, fmt.Errorf("%w: Cannot parse st value in %q: %w", ErrFileParse, line.St, err) + return nil, fmt.Errorf("%s: Cannot parse st value in %q: %w", ErrFileParse, line.St, err) } // tx_queue and rx_queue @@ -219,29 +208,20 @@ func parseNetIPSocketLine(fields []string, isUDP bool) (*netIPSocketLine, error) ) } if line.TxQueue, err = strconv.ParseUint(q[0], 16, 64); err != nil { - return nil, fmt.Errorf("%w: Cannot parse tx_queue value in %q: %w", ErrFileParse, line.TxQueue, err) + return nil, fmt.Errorf("%s: Cannot parse tx_queue value in %q: %w", ErrFileParse, line.TxQueue, err) } if line.RxQueue, err = strconv.ParseUint(q[1], 16, 64); err != nil { - return nil, fmt.Errorf("%w: Cannot parse trx_queue value in %q: %w", ErrFileParse, line.RxQueue, err) + return nil, fmt.Errorf("%s: Cannot parse trx_queue value in %q: %w", ErrFileParse, line.RxQueue, err) } // uid if line.UID, err = strconv.ParseUint(fields[7], 0, 64); err != nil { - return nil, fmt.Errorf("%w: Cannot parse UID value in %q: %w", ErrFileParse, line.UID, err) + return nil, fmt.Errorf("%s: Cannot parse UID value in %q: %w", ErrFileParse, line.UID, err) } // inode if line.Inode, err = strconv.ParseUint(fields[9], 0, 64); err != nil { - return nil, fmt.Errorf("%w: Cannot parse inode value in %q: %w", ErrFileParse, line.Inode, err) - } - - // drops - if isUDP { - drops, err := strconv.ParseUint(fields[12], 0, 64) - if err != nil { - return nil, fmt.Errorf("%w: Cannot parse drops value in %q: %w", ErrFileParse, drops, err) - } - line.Drops = &drops + return nil, fmt.Errorf("%s: Cannot parse inode value in %q: %w", ErrFileParse, line.Inode, err) } return line, nil diff --git a/services/vendor/github.com/prometheus/procfs/net_sockstat.go b/services/vendor/github.com/prometheus/procfs/net_sockstat.go index fae62b13..360e36af 100644 --- a/services/vendor/github.com/prometheus/procfs/net_sockstat.go +++ b/services/vendor/github.com/prometheus/procfs/net_sockstat.go @@ -69,7 +69,7 @@ func readSockstat(name string) (*NetSockstat, error) { stat, err := parseSockstat(bytes.NewReader(b)) if err != nil { - return nil, fmt.Errorf("%w: sockstats from %q: %w", ErrFileRead, name, err) + return nil, fmt.Errorf("%s: sockstats from %q: %w", ErrFileRead, name, err) } return stat, nil @@ -89,7 +89,7 @@ func parseSockstat(r io.Reader) (*NetSockstat, error) { // The remaining fields are key/value pairs. kvs, err := parseSockstatKVs(fields[1:]) if err != nil { - return nil, fmt.Errorf("%w: sockstat key/value pairs from %q: %w", ErrFileParse, s.Text(), err) + return nil, fmt.Errorf("%s: sockstat key/value pairs from %q: %w", ErrFileParse, s.Text(), err) } // The first field is the protocol. We must trim its colon suffix. diff --git a/services/vendor/github.com/prometheus/procfs/net_softnet.go b/services/vendor/github.com/prometheus/procfs/net_softnet.go index 71c8059f..c7708529 100644 --- a/services/vendor/github.com/prometheus/procfs/net_softnet.go +++ b/services/vendor/github.com/prometheus/procfs/net_softnet.go @@ -64,7 +64,7 @@ func (fs FS) NetSoftnetStat() ([]SoftnetStat, error) { entries, err := parseSoftnet(bytes.NewReader(b)) if err != nil { - return nil, fmt.Errorf("%w: /proc/net/softnet_stat: %w", ErrFileParse, err) + return nil, fmt.Errorf("%s: /proc/net/softnet_stat: %w", ErrFileParse, err) } return entries, nil diff --git a/services/vendor/github.com/prometheus/procfs/net_tls_stat.go b/services/vendor/github.com/prometheus/procfs/net_tls_stat.go deleted file mode 100644 index 13994c17..00000000 --- a/services/vendor/github.com/prometheus/procfs/net_tls_stat.go +++ /dev/null @@ -1,119 +0,0 @@ -// Copyright 2023 Prometheus Team -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package procfs - -import ( - "bufio" - "fmt" - "os" - "strconv" - "strings" -) - -// TLSStat struct represents data in /proc/net/tls_stat. -// See https://docs.kernel.org/networking/tls.html#statistics -type TLSStat struct { - // number of TX sessions currently installed where host handles cryptography - TLSCurrTxSw int - // number of RX sessions currently installed where host handles cryptography - TLSCurrRxSw int - // number of TX sessions currently installed where NIC handles cryptography - TLSCurrTxDevice int - // number of RX sessions currently installed where NIC handles cryptography - TLSCurrRxDevice int - //number of TX sessions opened with host cryptography - TLSTxSw int - //number of RX sessions opened with host cryptography - TLSRxSw int - // number of TX sessions opened with NIC cryptography - TLSTxDevice int - // number of RX sessions opened with NIC cryptography - TLSRxDevice int - // record decryption failed (e.g. due to incorrect authentication tag) - TLSDecryptError int - // number of RX resyncs sent to NICs handling cryptography - TLSRxDeviceResync int - // number of RX records which had to be re-decrypted due to TLS_RX_EXPECT_NO_PAD mis-prediction. Note that this counter will also increment for non-data records. - TLSDecryptRetry int - // number of data RX records which had to be re-decrypted due to TLS_RX_EXPECT_NO_PAD mis-prediction. - TLSRxNoPadViolation int -} - -// NewTLSStat reads the tls_stat statistics. -func NewTLSStat() (TLSStat, error) { - fs, err := NewFS(DefaultMountPoint) - if err != nil { - return TLSStat{}, err - } - - return fs.NewTLSStat() -} - -// NewTLSStat reads the tls_stat statistics. -func (fs FS) NewTLSStat() (TLSStat, error) { - file, err := os.Open(fs.proc.Path("net/tls_stat")) - if err != nil { - return TLSStat{}, err - } - defer file.Close() - - var ( - tlsstat = TLSStat{} - s = bufio.NewScanner(file) - ) - - for s.Scan() { - fields := strings.Fields(s.Text()) - - if len(fields) != 2 { - return TLSStat{}, fmt.Errorf("%w: %q line %q", ErrFileParse, file.Name(), s.Text()) - } - - name := fields[0] - value, err := strconv.Atoi(fields[1]) - if err != nil { - return TLSStat{}, err - } - - switch name { - case "TlsCurrTxSw": - tlsstat.TLSCurrTxSw = value - case "TlsCurrRxSw": - tlsstat.TLSCurrRxSw = value - case "TlsCurrTxDevice": - tlsstat.TLSCurrTxDevice = value - case "TlsCurrRxDevice": - tlsstat.TLSCurrRxDevice = value - case "TlsTxSw": - tlsstat.TLSTxSw = value - case "TlsRxSw": - tlsstat.TLSRxSw = value - case "TlsTxDevice": - tlsstat.TLSTxDevice = value - case "TlsRxDevice": - tlsstat.TLSRxDevice = value - case "TlsDecryptError": - tlsstat.TLSDecryptError = value - case "TlsRxDeviceResync": - tlsstat.TLSRxDeviceResync = value - case "TlsDecryptRetry": - tlsstat.TLSDecryptRetry = value - case "TlsRxNoPadViolation": - tlsstat.TLSRxNoPadViolation = value - } - - } - - return tlsstat, s.Err() -} diff --git a/services/vendor/github.com/prometheus/procfs/net_unix.go b/services/vendor/github.com/prometheus/procfs/net_unix.go index d868cebd..acbbc57e 100644 --- a/services/vendor/github.com/prometheus/procfs/net_unix.go +++ b/services/vendor/github.com/prometheus/procfs/net_unix.go @@ -108,14 +108,14 @@ func parseNetUNIX(r io.Reader) (*NetUNIX, error) { line := s.Text() item, err := nu.parseLine(line, hasInode, minFields) if err != nil { - return nil, fmt.Errorf("%w: /proc/net/unix encountered data %q: %w", ErrFileParse, line, err) + return nil, fmt.Errorf("%s: /proc/net/unix encountered data %q: %w", ErrFileParse, line, err) } nu.Rows = append(nu.Rows, item) } if err := s.Err(); err != nil { - return nil, fmt.Errorf("%w: /proc/net/unix encountered data: %w", ErrFileParse, err) + return nil, fmt.Errorf("%s: /proc/net/unix encountered data: %w", ErrFileParse, err) } return &nu, nil @@ -136,29 +136,29 @@ func (u *NetUNIX) parseLine(line string, hasInode bool, min int) (*NetUNIXLine, users, err := u.parseUsers(fields[1]) if err != nil { - return nil, fmt.Errorf("%w: ref count %q: %w", ErrFileParse, fields[1], err) + return nil, fmt.Errorf("%s: ref count %q: %w", ErrFileParse, fields[1], err) } flags, err := u.parseFlags(fields[3]) if err != nil { - return nil, fmt.Errorf("%w: Unable to parse flags %q: %w", ErrFileParse, fields[3], err) + return nil, fmt.Errorf("%s: Unable to parse flags %q: %w", ErrFileParse, fields[3], err) } typ, err := u.parseType(fields[4]) if err != nil { - return nil, fmt.Errorf("%w: Failed to parse type %q: %w", ErrFileParse, fields[4], err) + return nil, fmt.Errorf("%s: Failed to parse type %q: %w", ErrFileParse, fields[4], err) } state, err := u.parseState(fields[5]) if err != nil { - return nil, fmt.Errorf("%w: Failed to parse state %q: %w", ErrFileParse, fields[5], err) + return nil, fmt.Errorf("%s: Failed to parse state %q: %w", ErrFileParse, fields[5], err) } var inode uint64 if hasInode { inode, err = u.parseInode(fields[6]) if err != nil { - return nil, fmt.Errorf("%w failed to parse inode %q: %w", ErrFileParse, fields[6], err) + return nil, fmt.Errorf("%s failed to parse inode %q: %w", ErrFileParse, fields[6], err) } } diff --git a/services/vendor/github.com/prometheus/procfs/net_wireless.go b/services/vendor/github.com/prometheus/procfs/net_wireless.go index 7c597bc8..7443edca 100644 --- a/services/vendor/github.com/prometheus/procfs/net_wireless.go +++ b/services/vendor/github.com/prometheus/procfs/net_wireless.go @@ -68,7 +68,7 @@ func (fs FS) Wireless() ([]*Wireless, error) { m, err := parseWireless(bytes.NewReader(b)) if err != nil { - return nil, fmt.Errorf("%w: wireless: %w", ErrFileParse, err) + return nil, fmt.Errorf("%s: wireless: %w", ErrFileParse, err) } return m, nil @@ -114,47 +114,47 @@ func parseWireless(r io.Reader) ([]*Wireless, error) { qlink, err := strconv.Atoi(strings.TrimSuffix(stats[1], ".")) if err != nil { - return nil, fmt.Errorf("%w: parse Quality:link as integer %q: %w", ErrFileParse, qlink, err) + return nil, fmt.Errorf("%s: parse Quality:link as integer %q: %w", ErrFileParse, qlink, err) } qlevel, err := strconv.Atoi(strings.TrimSuffix(stats[2], ".")) if err != nil { - return nil, fmt.Errorf("%w: Quality:level as integer %q: %w", ErrFileParse, qlevel, err) + return nil, fmt.Errorf("%s: Quality:level as integer %q: %w", ErrFileParse, qlevel, err) } qnoise, err := strconv.Atoi(strings.TrimSuffix(stats[3], ".")) if err != nil { - return nil, fmt.Errorf("%w: Quality:noise as integer %q: %w", ErrFileParse, qnoise, err) + return nil, fmt.Errorf("%s: Quality:noise as integer %q: %w", ErrFileParse, qnoise, err) } dnwid, err := strconv.Atoi(stats[4]) if err != nil { - return nil, fmt.Errorf("%w: Discarded:nwid as integer %q: %w", ErrFileParse, dnwid, err) + return nil, fmt.Errorf("%s: Discarded:nwid as integer %q: %w", ErrFileParse, dnwid, err) } dcrypt, err := strconv.Atoi(stats[5]) if err != nil { - return nil, fmt.Errorf("%w: Discarded:crypt as integer %q: %w", ErrFileParse, dcrypt, err) + return nil, fmt.Errorf("%s: Discarded:crypt as integer %q: %w", ErrFileParse, dcrypt, err) } dfrag, err := strconv.Atoi(stats[6]) if err != nil { - return nil, fmt.Errorf("%w: Discarded:frag as integer %q: %w", ErrFileParse, dfrag, err) + return nil, fmt.Errorf("%s: Discarded:frag as integer %q: %w", ErrFileParse, dfrag, err) } dretry, err := strconv.Atoi(stats[7]) if err != nil { - return nil, fmt.Errorf("%w: Discarded:retry as integer %q: %w", ErrFileParse, dretry, err) + return nil, fmt.Errorf("%s: Discarded:retry as integer %q: %w", ErrFileParse, dretry, err) } dmisc, err := strconv.Atoi(stats[8]) if err != nil { - return nil, fmt.Errorf("%w: Discarded:misc as integer %q: %w", ErrFileParse, dmisc, err) + return nil, fmt.Errorf("%s: Discarded:misc as integer %q: %w", ErrFileParse, dmisc, err) } mbeacon, err := strconv.Atoi(stats[9]) if err != nil { - return nil, fmt.Errorf("%w: Missed:beacon as integer %q: %w", ErrFileParse, mbeacon, err) + return nil, fmt.Errorf("%s: Missed:beacon as integer %q: %w", ErrFileParse, mbeacon, err) } w := &Wireless{ @@ -175,7 +175,7 @@ func parseWireless(r io.Reader) ([]*Wireless, error) { } if err := scanner.Err(); err != nil { - return nil, fmt.Errorf("%w: Failed to scan /proc/net/wireless: %w", ErrFileRead, err) + return nil, fmt.Errorf("%s: Failed to scan /proc/net/wireless: %w", ErrFileRead, err) } return interfaces, nil diff --git a/services/vendor/github.com/prometheus/procfs/proc.go b/services/vendor/github.com/prometheus/procfs/proc.go index 14279636..d1f71caa 100644 --- a/services/vendor/github.com/prometheus/procfs/proc.go +++ b/services/vendor/github.com/prometheus/procfs/proc.go @@ -111,7 +111,7 @@ func (fs FS) AllProcs() (Procs, error) { names, err := d.Readdirnames(-1) if err != nil { - return Procs{}, fmt.Errorf("%w: Cannot read file: %v: %w", ErrFileRead, names, err) + return Procs{}, fmt.Errorf("%s: Cannot read file: %v: %w", ErrFileRead, names, err) } p := Procs{} @@ -137,7 +137,7 @@ func (p Proc) CmdLine() ([]string, error) { return []string{}, nil } - return strings.Split(string(bytes.TrimRight(data, "\x00")), "\x00"), nil + return strings.Split(string(bytes.TrimRight(data, string("\x00"))), string(byte(0))), nil } // Wchan returns the wchan (wait channel) of a process. @@ -212,7 +212,7 @@ func (p Proc) FileDescriptors() ([]uintptr, error) { for i, n := range names { fd, err := strconv.ParseInt(n, 10, 32) if err != nil { - return nil, fmt.Errorf("%w: Cannot parse line: %v: %w", ErrFileParse, i, err) + return nil, fmt.Errorf("%s: Cannot parse line: %v: %w", ErrFileParse, i, err) } fds[i] = uintptr(fd) } @@ -297,7 +297,7 @@ func (p Proc) fileDescriptors() ([]string, error) { names, err := d.Readdirnames(-1) if err != nil { - return nil, fmt.Errorf("%w: Cannot read file: %v: %w", ErrFileRead, names, err) + return nil, fmt.Errorf("%s: Cannot read file: %v: %w", ErrFileRead, names, err) } return names, nil diff --git a/services/vendor/github.com/prometheus/procfs/proc_limits.go b/services/vendor/github.com/prometheus/procfs/proc_limits.go index 9530b14b..c86d815d 100644 --- a/services/vendor/github.com/prometheus/procfs/proc_limits.go +++ b/services/vendor/github.com/prometheus/procfs/proc_limits.go @@ -154,7 +154,7 @@ func parseUint(s string) (uint64, error) { } i, err := strconv.ParseUint(s, 10, 64) if err != nil { - return 0, fmt.Errorf("%w: couldn't parse value %q: %w", ErrFileParse, s, err) + return 0, fmt.Errorf("%s: couldn't parse value %q: %w", ErrFileParse, s, err) } return i, nil } diff --git a/services/vendor/github.com/prometheus/procfs/proc_ns.go b/services/vendor/github.com/prometheus/procfs/proc_ns.go index 0f8f847f..c2266675 100644 --- a/services/vendor/github.com/prometheus/procfs/proc_ns.go +++ b/services/vendor/github.com/prometheus/procfs/proc_ns.go @@ -40,7 +40,7 @@ func (p Proc) Namespaces() (Namespaces, error) { names, err := d.Readdirnames(-1) if err != nil { - return nil, fmt.Errorf("%w: failed to read contents of ns dir: %w", ErrFileRead, err) + return nil, fmt.Errorf("%s: failed to read contents of ns dir: %w", ErrFileRead, err) } ns := make(Namespaces, len(names)) @@ -58,7 +58,7 @@ func (p Proc) Namespaces() (Namespaces, error) { typ := fields[0] inode, err := strconv.ParseUint(strings.Trim(fields[1], "[]"), 10, 32) if err != nil { - return nil, fmt.Errorf("%w: inode from %q: %w", ErrFileParse, fields[1], err) + return nil, fmt.Errorf("%s: inode from %q: %w", ErrFileParse, fields[1], err) } ns[name] = Namespace{typ, uint32(inode)} diff --git a/services/vendor/github.com/prometheus/procfs/proc_psi.go b/services/vendor/github.com/prometheus/procfs/proc_psi.go index ccd35f15..fe9dbb42 100644 --- a/services/vendor/github.com/prometheus/procfs/proc_psi.go +++ b/services/vendor/github.com/prometheus/procfs/proc_psi.go @@ -61,7 +61,7 @@ type PSIStats struct { func (fs FS) PSIStatsForResource(resource string) (PSIStats, error) { data, err := util.ReadFileNoStat(fs.proc.Path(fmt.Sprintf("%s/%s", "pressure", resource))) if err != nil { - return PSIStats{}, fmt.Errorf("%w: psi_stats: unavailable for %q: %w", ErrFileRead, resource, err) + return PSIStats{}, fmt.Errorf("%s: psi_stats: unavailable for %q: %w", ErrFileRead, resource, err) } return parsePSIStats(bytes.NewReader(data)) diff --git a/services/vendor/github.com/prometheus/procfs/proc_smaps.go b/services/vendor/github.com/prometheus/procfs/proc_smaps.go index 09060e82..ad8785a4 100644 --- a/services/vendor/github.com/prometheus/procfs/proc_smaps.go +++ b/services/vendor/github.com/prometheus/procfs/proc_smaps.go @@ -127,7 +127,7 @@ func (s *ProcSMapsRollup) parseLine(line string) error { } v := strings.TrimSpace(kv[1]) - v = strings.TrimSuffix(v, " kB") + v = strings.TrimRight(v, " kB") vKBytes, err := strconv.ParseUint(v, 10, 64) if err != nil { diff --git a/services/vendor/github.com/prometheus/procfs/proc_stat.go b/services/vendor/github.com/prometheus/procfs/proc_stat.go index 06a8d931..923e5500 100644 --- a/services/vendor/github.com/prometheus/procfs/proc_stat.go +++ b/services/vendor/github.com/prometheus/procfs/proc_stat.go @@ -110,11 +110,6 @@ type ProcStat struct { Policy uint // Aggregated block I/O delays, measured in clock ticks (centiseconds). DelayAcctBlkIOTicks uint64 - // Guest time of the process (time spent running a virtual CPU for a guest - // operating system), measured in clock ticks. - GuestTime int - // Guest time of the process's children, measured in clock ticks. - CGuestTime int proc FS } @@ -194,8 +189,6 @@ func (p Proc) Stat() (ProcStat, error) { &s.RTPriority, &s.Policy, &s.DelayAcctBlkIOTicks, - &s.GuestTime, - &s.CGuestTime, ) if err != nil { return ProcStat{}, err diff --git a/services/vendor/github.com/prometheus/procfs/proc_status.go b/services/vendor/github.com/prometheus/procfs/proc_status.go index a055197c..46307f57 100644 --- a/services/vendor/github.com/prometheus/procfs/proc_status.go +++ b/services/vendor/github.com/prometheus/procfs/proc_status.go @@ -15,7 +15,6 @@ package procfs import ( "bytes" - "math/bits" "sort" "strconv" "strings" @@ -77,9 +76,9 @@ type ProcStatus struct { NonVoluntaryCtxtSwitches uint64 // UIDs of the process (Real, effective, saved set, and filesystem UIDs) - UIDs [4]uint64 + UIDs [4]string // GIDs of the process (Real, effective, saved set, and filesystem GIDs) - GIDs [4]uint64 + GIDs [4]string // CpusAllowedList: List of cpu cores processes are allowed to run on. CpusAllowedList []uint64 @@ -114,37 +113,22 @@ func (p Proc) NewStatus() (ProcStatus, error) { // convert kB to B vBytes := vKBytes * 1024 - err = s.fillStatus(k, v, vKBytes, vBytes) - if err != nil { - return ProcStatus{}, err - } + s.fillStatus(k, v, vKBytes, vBytes) } return s, nil } -func (s *ProcStatus) fillStatus(k string, vString string, vUint uint64, vUintBytes uint64) error { +func (s *ProcStatus) fillStatus(k string, vString string, vUint uint64, vUintBytes uint64) { switch k { case "Tgid": s.TGID = int(vUint) case "Name": s.Name = vString case "Uid": - var err error - for i, v := range strings.Split(vString, "\t") { - s.UIDs[i], err = strconv.ParseUint(v, 10, bits.UintSize) - if err != nil { - return err - } - } + copy(s.UIDs[:], strings.Split(vString, "\t")) case "Gid": - var err error - for i, v := range strings.Split(vString, "\t") { - s.GIDs[i], err = strconv.ParseUint(v, 10, bits.UintSize) - if err != nil { - return err - } - } + copy(s.GIDs[:], strings.Split(vString, "\t")) case "NSpid": s.NSpids = calcNSPidsList(vString) case "VmPeak": @@ -189,7 +173,6 @@ func (s *ProcStatus) fillStatus(k string, vString string, vUint uint64, vUintByt s.CpusAllowedList = calcCpusAllowedList(vString) } - return nil } // TotalCtxtSwitches returns the total context switch. diff --git a/services/vendor/github.com/prometheus/procfs/proc_sys.go b/services/vendor/github.com/prometheus/procfs/proc_sys.go index 5eefbe2e..12c5bf05 100644 --- a/services/vendor/github.com/prometheus/procfs/proc_sys.go +++ b/services/vendor/github.com/prometheus/procfs/proc_sys.go @@ -44,7 +44,7 @@ func (fs FS) SysctlInts(sysctl string) ([]int, error) { vp := util.NewValueParser(f) values[i] = vp.Int() if err := vp.Err(); err != nil { - return nil, fmt.Errorf("%w: field %d in sysctl %s is not a valid int: %w", ErrFileParse, i, sysctl, err) + return nil, fmt.Errorf("%s: field %d in sysctl %s is not a valid int: %w", ErrFileParse, i, sysctl, err) } } return values, nil diff --git a/services/vendor/github.com/prometheus/procfs/softirqs.go b/services/vendor/github.com/prometheus/procfs/softirqs.go index 28708e07..b8fad677 100644 --- a/services/vendor/github.com/prometheus/procfs/softirqs.go +++ b/services/vendor/github.com/prometheus/procfs/softirqs.go @@ -74,7 +74,7 @@ func parseSoftirqs(r io.Reader) (Softirqs, error) { softirqs.Hi = make([]uint64, len(perCPU)) for i, count := range perCPU { if softirqs.Hi[i], err = strconv.ParseUint(count, 10, 64); err != nil { - return Softirqs{}, fmt.Errorf("%w: couldn't parse %q (HI%d): %w", ErrFileParse, count, i, err) + return Softirqs{}, fmt.Errorf("%s: couldn't parse %q (HI%d): %w", ErrFileParse, count, i, err) } } case parts[0] == "TIMER:": @@ -82,7 +82,7 @@ func parseSoftirqs(r io.Reader) (Softirqs, error) { softirqs.Timer = make([]uint64, len(perCPU)) for i, count := range perCPU { if softirqs.Timer[i], err = strconv.ParseUint(count, 10, 64); err != nil { - return Softirqs{}, fmt.Errorf("%w: couldn't parse %q (TIMER%d): %w", ErrFileParse, count, i, err) + return Softirqs{}, fmt.Errorf("%s: couldn't parse %q (TIMER%d): %w", ErrFileParse, count, i, err) } } case parts[0] == "NET_TX:": @@ -90,7 +90,7 @@ func parseSoftirqs(r io.Reader) (Softirqs, error) { softirqs.NetTx = make([]uint64, len(perCPU)) for i, count := range perCPU { if softirqs.NetTx[i], err = strconv.ParseUint(count, 10, 64); err != nil { - return Softirqs{}, fmt.Errorf("%w: couldn't parse %q (NET_TX%d): %w", ErrFileParse, count, i, err) + return Softirqs{}, fmt.Errorf("%s: couldn't parse %q (NET_TX%d): %w", ErrFileParse, count, i, err) } } case parts[0] == "NET_RX:": @@ -98,7 +98,7 @@ func parseSoftirqs(r io.Reader) (Softirqs, error) { softirqs.NetRx = make([]uint64, len(perCPU)) for i, count := range perCPU { if softirqs.NetRx[i], err = strconv.ParseUint(count, 10, 64); err != nil { - return Softirqs{}, fmt.Errorf("%w: couldn't parse %q (NET_RX%d): %w", ErrFileParse, count, i, err) + return Softirqs{}, fmt.Errorf("%s: couldn't parse %q (NET_RX%d): %w", ErrFileParse, count, i, err) } } case parts[0] == "BLOCK:": @@ -106,7 +106,7 @@ func parseSoftirqs(r io.Reader) (Softirqs, error) { softirqs.Block = make([]uint64, len(perCPU)) for i, count := range perCPU { if softirqs.Block[i], err = strconv.ParseUint(count, 10, 64); err != nil { - return Softirqs{}, fmt.Errorf("%w: couldn't parse %q (BLOCK%d): %w", ErrFileParse, count, i, err) + return Softirqs{}, fmt.Errorf("%s: couldn't parse %q (BLOCK%d): %w", ErrFileParse, count, i, err) } } case parts[0] == "IRQ_POLL:": @@ -114,7 +114,7 @@ func parseSoftirqs(r io.Reader) (Softirqs, error) { softirqs.IRQPoll = make([]uint64, len(perCPU)) for i, count := range perCPU { if softirqs.IRQPoll[i], err = strconv.ParseUint(count, 10, 64); err != nil { - return Softirqs{}, fmt.Errorf("%w: couldn't parse %q (IRQ_POLL%d): %w", ErrFileParse, count, i, err) + return Softirqs{}, fmt.Errorf("%s: couldn't parse %q (IRQ_POLL%d): %w", ErrFileParse, count, i, err) } } case parts[0] == "TASKLET:": @@ -122,7 +122,7 @@ func parseSoftirqs(r io.Reader) (Softirqs, error) { softirqs.Tasklet = make([]uint64, len(perCPU)) for i, count := range perCPU { if softirqs.Tasklet[i], err = strconv.ParseUint(count, 10, 64); err != nil { - return Softirqs{}, fmt.Errorf("%w: couldn't parse %q (TASKLET%d): %w", ErrFileParse, count, i, err) + return Softirqs{}, fmt.Errorf("%s: couldn't parse %q (TASKLET%d): %w", ErrFileParse, count, i, err) } } case parts[0] == "SCHED:": @@ -130,7 +130,7 @@ func parseSoftirqs(r io.Reader) (Softirqs, error) { softirqs.Sched = make([]uint64, len(perCPU)) for i, count := range perCPU { if softirqs.Sched[i], err = strconv.ParseUint(count, 10, 64); err != nil { - return Softirqs{}, fmt.Errorf("%w: couldn't parse %q (SCHED%d): %w", ErrFileParse, count, i, err) + return Softirqs{}, fmt.Errorf("%s: couldn't parse %q (SCHED%d): %w", ErrFileParse, count, i, err) } } case parts[0] == "HRTIMER:": @@ -138,7 +138,7 @@ func parseSoftirqs(r io.Reader) (Softirqs, error) { softirqs.HRTimer = make([]uint64, len(perCPU)) for i, count := range perCPU { if softirqs.HRTimer[i], err = strconv.ParseUint(count, 10, 64); err != nil { - return Softirqs{}, fmt.Errorf("%w: couldn't parse %q (HRTIMER%d): %w", ErrFileParse, count, i, err) + return Softirqs{}, fmt.Errorf("%s: couldn't parse %q (HRTIMER%d): %w", ErrFileParse, count, i, err) } } case parts[0] == "RCU:": @@ -146,14 +146,14 @@ func parseSoftirqs(r io.Reader) (Softirqs, error) { softirqs.RCU = make([]uint64, len(perCPU)) for i, count := range perCPU { if softirqs.RCU[i], err = strconv.ParseUint(count, 10, 64); err != nil { - return Softirqs{}, fmt.Errorf("%w: couldn't parse %q (RCU%d): %w", ErrFileParse, count, i, err) + return Softirqs{}, fmt.Errorf("%s: couldn't parse %q (RCU%d): %w", ErrFileParse, count, i, err) } } } } if err := scanner.Err(); err != nil { - return Softirqs{}, fmt.Errorf("%w: couldn't parse softirqs: %w", ErrFileParse, err) + return Softirqs{}, fmt.Errorf("%s: couldn't parse softirqs: %w", ErrFileParse, err) } return softirqs, scanner.Err() diff --git a/services/vendor/github.com/prometheus/procfs/stat.go b/services/vendor/github.com/prometheus/procfs/stat.go index e36b41c1..34fc3ee2 100644 --- a/services/vendor/github.com/prometheus/procfs/stat.go +++ b/services/vendor/github.com/prometheus/procfs/stat.go @@ -93,7 +93,7 @@ func parseCPUStat(line string) (CPUStat, int64, error) { &cpuStat.Guest, &cpuStat.GuestNice) if err != nil && err != io.EOF { - return CPUStat{}, -1, fmt.Errorf("%w: couldn't parse %q (cpu): %w", ErrFileParse, line, err) + return CPUStat{}, -1, fmt.Errorf("%s: couldn't parse %q (cpu): %w", ErrFileParse, line, err) } if count == 0 { return CPUStat{}, -1, fmt.Errorf("%w: couldn't parse %q (cpu): 0 elements parsed", ErrFileParse, line) @@ -116,7 +116,7 @@ func parseCPUStat(line string) (CPUStat, int64, error) { cpuID, err := strconv.ParseInt(cpu[3:], 10, 64) if err != nil { - return CPUStat{}, -1, fmt.Errorf("%w: couldn't parse %q (cpu/cpuid): %w", ErrFileParse, line, err) + return CPUStat{}, -1, fmt.Errorf("%s: couldn't parse %q (cpu/cpuid): %w", ErrFileParse, line, err) } return cpuStat, cpuID, nil @@ -136,7 +136,7 @@ func parseSoftIRQStat(line string) (SoftIRQStat, uint64, error) { &softIRQStat.Hrtimer, &softIRQStat.Rcu) if err != nil { - return SoftIRQStat{}, 0, fmt.Errorf("%w: couldn't parse %q (softirq): %w", ErrFileParse, line, err) + return SoftIRQStat{}, 0, fmt.Errorf("%s: couldn't parse %q (softirq): %w", ErrFileParse, line, err) } return softIRQStat, total, nil @@ -201,34 +201,34 @@ func parseStat(r io.Reader, fileName string) (Stat, error) { switch { case parts[0] == "btime": if stat.BootTime, err = strconv.ParseUint(parts[1], 10, 64); err != nil { - return Stat{}, fmt.Errorf("%w: couldn't parse %q (btime): %w", ErrFileParse, parts[1], err) + return Stat{}, fmt.Errorf("%s: couldn't parse %q (btime): %w", ErrFileParse, parts[1], err) } case parts[0] == "intr": if stat.IRQTotal, err = strconv.ParseUint(parts[1], 10, 64); err != nil { - return Stat{}, fmt.Errorf("%w: couldn't parse %q (intr): %w", ErrFileParse, parts[1], err) + return Stat{}, fmt.Errorf("%s: couldn't parse %q (intr): %w", ErrFileParse, parts[1], err) } numberedIRQs := parts[2:] stat.IRQ = make([]uint64, len(numberedIRQs)) for i, count := range numberedIRQs { if stat.IRQ[i], err = strconv.ParseUint(count, 10, 64); err != nil { - return Stat{}, fmt.Errorf("%w: couldn't parse %q (intr%d): %w", ErrFileParse, count, i, err) + return Stat{}, fmt.Errorf("%s: couldn't parse %q (intr%d): %w", ErrFileParse, count, i, err) } } case parts[0] == "ctxt": if stat.ContextSwitches, err = strconv.ParseUint(parts[1], 10, 64); err != nil { - return Stat{}, fmt.Errorf("%w: couldn't parse %q (ctxt): %w", ErrFileParse, parts[1], err) + return Stat{}, fmt.Errorf("%s: couldn't parse %q (ctxt): %w", ErrFileParse, parts[1], err) } case parts[0] == "processes": if stat.ProcessCreated, err = strconv.ParseUint(parts[1], 10, 64); err != nil { - return Stat{}, fmt.Errorf("%w: couldn't parse %q (processes): %w", ErrFileParse, parts[1], err) + return Stat{}, fmt.Errorf("%s: couldn't parse %q (processes): %w", ErrFileParse, parts[1], err) } case parts[0] == "procs_running": if stat.ProcessesRunning, err = strconv.ParseUint(parts[1], 10, 64); err != nil { - return Stat{}, fmt.Errorf("%w: couldn't parse %q (procs_running): %w", ErrFileParse, parts[1], err) + return Stat{}, fmt.Errorf("%s: couldn't parse %q (procs_running): %w", ErrFileParse, parts[1], err) } case parts[0] == "procs_blocked": if stat.ProcessesBlocked, err = strconv.ParseUint(parts[1], 10, 64); err != nil { - return Stat{}, fmt.Errorf("%w: couldn't parse %q (procs_blocked): %w", ErrFileParse, parts[1], err) + return Stat{}, fmt.Errorf("%s: couldn't parse %q (procs_blocked): %w", ErrFileParse, parts[1], err) } case parts[0] == "softirq": softIRQStats, total, err := parseSoftIRQStat(line) @@ -251,7 +251,7 @@ func parseStat(r io.Reader, fileName string) (Stat, error) { } if err := scanner.Err(); err != nil { - return Stat{}, fmt.Errorf("%w: couldn't parse %q: %w", ErrFileParse, fileName, err) + return Stat{}, fmt.Errorf("%s: couldn't parse %q: %w", ErrFileParse, fileName, err) } return stat, nil diff --git a/services/vendor/github.com/prometheus/procfs/swaps.go b/services/vendor/github.com/prometheus/procfs/swaps.go index 65fec834..fa00f555 100644 --- a/services/vendor/github.com/prometheus/procfs/swaps.go +++ b/services/vendor/github.com/prometheus/procfs/swaps.go @@ -74,15 +74,15 @@ func parseSwapString(swapString string) (*Swap, error) { swap.Size, err = strconv.Atoi(swapFields[2]) if err != nil { - return nil, fmt.Errorf("%w: invalid swap size: %s: %w", ErrFileParse, swapFields[2], err) + return nil, fmt.Errorf("%s: invalid swap size: %s: %w", ErrFileParse, swapFields[2], err) } swap.Used, err = strconv.Atoi(swapFields[3]) if err != nil { - return nil, fmt.Errorf("%w: invalid swap used: %s: %w", ErrFileParse, swapFields[3], err) + return nil, fmt.Errorf("%s: invalid swap used: %s: %w", ErrFileParse, swapFields[3], err) } swap.Priority, err = strconv.Atoi(swapFields[4]) if err != nil { - return nil, fmt.Errorf("%w: invalid swap priority: %s: %w", ErrFileParse, swapFields[4], err) + return nil, fmt.Errorf("%s: invalid swap priority: %s: %w", ErrFileParse, swapFields[4], err) } return swap, nil diff --git a/services/vendor/github.com/prometheus/procfs/thread.go b/services/vendor/github.com/prometheus/procfs/thread.go index 80e0e947..df2215ec 100644 --- a/services/vendor/github.com/prometheus/procfs/thread.go +++ b/services/vendor/github.com/prometheus/procfs/thread.go @@ -45,7 +45,7 @@ func (fs FS) AllThreads(pid int) (Procs, error) { names, err := d.Readdirnames(-1) if err != nil { - return Procs{}, fmt.Errorf("%w: could not read %q: %w", ErrFileRead, d.Name(), err) + return Procs{}, fmt.Errorf("%s: could not read %q: %w", ErrFileRead, d.Name(), err) } t := Procs{} diff --git a/services/vendor/github.com/prometheus/procfs/zoneinfo.go b/services/vendor/github.com/prometheus/procfs/zoneinfo.go index e54d94b0..ce5fefa5 100644 --- a/services/vendor/github.com/prometheus/procfs/zoneinfo.go +++ b/services/vendor/github.com/prometheus/procfs/zoneinfo.go @@ -75,11 +75,11 @@ var nodeZoneRE = regexp.MustCompile(`(\d+), zone\s+(\w+)`) func (fs FS) Zoneinfo() ([]Zoneinfo, error) { data, err := os.ReadFile(fs.proc.Path("zoneinfo")) if err != nil { - return nil, fmt.Errorf("%w: error reading zoneinfo %q: %w", ErrFileRead, fs.proc.Path("zoneinfo"), err) + return nil, fmt.Errorf("%s: error reading zoneinfo %q: %w", ErrFileRead, fs.proc.Path("zoneinfo"), err) } zoneinfo, err := parseZoneinfo(data) if err != nil { - return nil, fmt.Errorf("%w: error parsing zoneinfo %q: %w", ErrFileParse, fs.proc.Path("zoneinfo"), err) + return nil, fmt.Errorf("%s: error parsing zoneinfo %q: %w", ErrFileParse, fs.proc.Path("zoneinfo"), err) } return zoneinfo, nil } diff --git a/services/vendor/golang.org/x/sys/LICENSE b/services/vendor/golang.org/x/sys/LICENSE index 2a7cf70d..6a66aea5 100644 --- a/services/vendor/golang.org/x/sys/LICENSE +++ b/services/vendor/golang.org/x/sys/LICENSE @@ -1,4 +1,4 @@ -Copyright 2009 The Go Authors. +Copyright (c) 2009 The Go Authors. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are @@ -10,7 +10,7 @@ notice, this list of conditions and the following disclaimer. copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. - * Neither the name of Google LLC nor the names of its + * Neither the name of Google Inc. nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. diff --git a/services/vendor/golang.org/x/sys/unix/aliases.go b/services/vendor/golang.org/x/sys/unix/aliases.go index b0e41985..e7d3df4b 100644 --- a/services/vendor/golang.org/x/sys/unix/aliases.go +++ b/services/vendor/golang.org/x/sys/unix/aliases.go @@ -2,7 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. -//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos +//go:build (aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos) && go1.9 package unix diff --git a/services/vendor/golang.org/x/sys/unix/asm_zos_s390x.s b/services/vendor/golang.org/x/sys/unix/asm_zos_s390x.s index 813dfad7..2f67ba86 100644 --- a/services/vendor/golang.org/x/sys/unix/asm_zos_s390x.s +++ b/services/vendor/golang.org/x/sys/unix/asm_zos_s390x.s @@ -9,11 +9,9 @@ #define PSALAA 1208(R0) #define GTAB64(x) 80(x) #define LCA64(x) 88(x) -#define SAVSTACK_ASYNC(x) 336(x) // in the LCA #define CAA(x) 8(x) -#define CEECAATHDID(x) 976(x) // in the CAA -#define EDCHPXV(x) 1016(x) // in the CAA -#define GOCB(x) 1104(x) // in the CAA +#define EDCHPXV(x) 1016(x) // in the CAA +#define SAVSTACK_ASYNC(x) 336(x) // in the LCA // SS_*, where x=SAVSTACK_ASYNC #define SS_LE(x) 0(x) @@ -21,362 +19,405 @@ #define SS_ERRNO(x) 16(x) #define SS_ERRNOJR(x) 20(x) -// Function Descriptor Offsets -#define __errno 0x156*16 -#define __err2ad 0x16C*16 +#define LE_CALL BYTE $0x0D; BYTE $0x76; // BL R7, R6 -// Call Instructions -#define LE_CALL BYTE $0x0D; BYTE $0x76 // BL R7, R6 -#define SVC_LOAD BYTE $0x0A; BYTE $0x08 // SVC 08 LOAD -#define SVC_DELETE BYTE $0x0A; BYTE $0x09 // SVC 09 DELETE - -DATA zosLibVec<>(SB)/8, $0 -GLOBL zosLibVec<>(SB), NOPTR, $8 - -TEXT ·initZosLibVec(SB), NOSPLIT|NOFRAME, $0-0 - MOVW PSALAA, R8 - MOVD LCA64(R8), R8 - MOVD CAA(R8), R8 - MOVD EDCHPXV(R8), R8 - MOVD R8, zosLibVec<>(SB) - RET - -TEXT ·GetZosLibVec(SB), NOSPLIT|NOFRAME, $0-0 - MOVD zosLibVec<>(SB), R8 - MOVD R8, ret+0(FP) - RET - -TEXT ·clearErrno(SB), NOSPLIT, $0-0 - BL addrerrno<>(SB) - MOVD $0, 0(R3) +TEXT ·clearErrno(SB),NOSPLIT,$0-0 + BL addrerrno<>(SB) + MOVD $0, 0(R3) RET // Returns the address of errno in R3. -TEXT addrerrno<>(SB), NOSPLIT|NOFRAME, $0-0 +TEXT addrerrno<>(SB),NOSPLIT|NOFRAME,$0-0 // Get library control area (LCA). - MOVW PSALAA, R8 - MOVD LCA64(R8), R8 + MOVW PSALAA, R8 + MOVD LCA64(R8), R8 // Get __errno FuncDesc. - MOVD CAA(R8), R9 - MOVD EDCHPXV(R9), R9 - ADD $(__errno), R9 - LMG 0(R9), R5, R6 + MOVD CAA(R8), R9 + MOVD EDCHPXV(R9), R9 + ADD $(0x156*16), R9 + LMG 0(R9), R5, R6 // Switch to saved LE stack. - MOVD SAVSTACK_ASYNC(R8), R9 - MOVD 0(R9), R4 - MOVD $0, 0(R9) + MOVD SAVSTACK_ASYNC(R8), R9 + MOVD 0(R9), R4 + MOVD $0, 0(R9) // Call __errno function. LE_CALL NOPH // Switch back to Go stack. - XOR R0, R0 // Restore R0 to $0. - MOVD R4, 0(R9) // Save stack pointer. + XOR R0, R0 // Restore R0 to $0. + MOVD R4, 0(R9) // Save stack pointer. RET -// func svcCall(fnptr unsafe.Pointer, argv *unsafe.Pointer, dsa *uint64) -TEXT ·svcCall(SB), NOSPLIT, $0 - BL runtime·save_g(SB) // Save g and stack pointer - MOVW PSALAA, R8 - MOVD LCA64(R8), R8 - MOVD SAVSTACK_ASYNC(R8), R9 - MOVD R15, 0(R9) +TEXT ·syscall_syscall(SB),NOSPLIT,$0-56 + BL runtime·entersyscall(SB) + MOVD a1+8(FP), R1 + MOVD a2+16(FP), R2 + MOVD a3+24(FP), R3 - MOVD argv+8(FP), R1 // Move function arguments into registers - MOVD dsa+16(FP), g - MOVD fnptr+0(FP), R15 + // Get library control area (LCA). + MOVW PSALAA, R8 + MOVD LCA64(R8), R8 - BYTE $0x0D // Branch to function - BYTE $0xEF + // Get function. + MOVD CAA(R8), R9 + MOVD EDCHPXV(R9), R9 + MOVD trap+0(FP), R5 + SLD $4, R5 + ADD R5, R9 + LMG 0(R9), R5, R6 - BL runtime·load_g(SB) // Restore g and stack pointer - MOVW PSALAA, R8 - MOVD LCA64(R8), R8 - MOVD SAVSTACK_ASYNC(R8), R9 - MOVD 0(R9), R15 + // Restore LE stack. + MOVD SAVSTACK_ASYNC(R8), R9 + MOVD 0(R9), R4 + MOVD $0, 0(R9) + // Call function. + LE_CALL + NOPH + XOR R0, R0 // Restore R0 to $0. + MOVD R4, 0(R9) // Save stack pointer. + + MOVD R3, r1+32(FP) + MOVD R0, r2+40(FP) + MOVD R0, err+48(FP) + MOVW R3, R4 + CMP R4, $-1 + BNE done + BL addrerrno<>(SB) + MOVWZ 0(R3), R3 + MOVD R3, err+48(FP) +done: + BL runtime·exitsyscall(SB) RET -// func svcLoad(name *byte) unsafe.Pointer -TEXT ·svcLoad(SB), NOSPLIT, $0 - MOVD R15, R2 // Save go stack pointer - MOVD name+0(FP), R0 // Move SVC args into registers - MOVD $0x80000000, R1 - MOVD $0, R15 - SVC_LOAD - MOVW R15, R3 // Save return code from SVC - MOVD R2, R15 // Restore go stack pointer - CMP R3, $0 // Check SVC return code - BNE error - - MOVD $-2, R3 // Reset last bit of entry point to zero - AND R0, R3 - MOVD R3, ret+8(FP) // Return entry point returned by SVC - CMP R0, R3 // Check if last bit of entry point was set - BNE done - - MOVD R15, R2 // Save go stack pointer - MOVD $0, R15 // Move SVC args into registers (entry point still in r0 from SVC 08) - SVC_DELETE - MOVD R2, R15 // Restore go stack pointer +TEXT ·syscall_rawsyscall(SB),NOSPLIT,$0-56 + MOVD a1+8(FP), R1 + MOVD a2+16(FP), R2 + MOVD a3+24(FP), R3 -error: - MOVD $0, ret+8(FP) // Return 0 on failure + // Get library control area (LCA). + MOVW PSALAA, R8 + MOVD LCA64(R8), R8 + + // Get function. + MOVD CAA(R8), R9 + MOVD EDCHPXV(R9), R9 + MOVD trap+0(FP), R5 + SLD $4, R5 + ADD R5, R9 + LMG 0(R9), R5, R6 + // Restore LE stack. + MOVD SAVSTACK_ASYNC(R8), R9 + MOVD 0(R9), R4 + MOVD $0, 0(R9) + + // Call function. + LE_CALL + NOPH + XOR R0, R0 // Restore R0 to $0. + MOVD R4, 0(R9) // Save stack pointer. + + MOVD R3, r1+32(FP) + MOVD R0, r2+40(FP) + MOVD R0, err+48(FP) + MOVW R3, R4 + CMP R4, $-1 + BNE done + BL addrerrno<>(SB) + MOVWZ 0(R3), R3 + MOVD R3, err+48(FP) done: - XOR R0, R0 // Reset r0 to 0 RET -// func svcUnload(name *byte, fnptr unsafe.Pointer) int64 -TEXT ·svcUnload(SB), NOSPLIT, $0 - MOVD R15, R2 // Save go stack pointer - MOVD name+0(FP), R0 // Move SVC args into registers - MOVD fnptr+8(FP), R15 - SVC_DELETE - XOR R0, R0 // Reset r0 to 0 - MOVD R15, R1 // Save SVC return code - MOVD R2, R15 // Restore go stack pointer - MOVD R1, ret+16(FP) // Return SVC return code - RET +TEXT ·syscall_syscall6(SB),NOSPLIT,$0-80 + BL runtime·entersyscall(SB) + MOVD a1+8(FP), R1 + MOVD a2+16(FP), R2 + MOVD a3+24(FP), R3 -// func gettid() uint64 -TEXT ·gettid(SB), NOSPLIT, $0 // Get library control area (LCA). - MOVW PSALAA, R8 - MOVD LCA64(R8), R8 + MOVW PSALAA, R8 + MOVD LCA64(R8), R8 - // Get CEECAATHDID - MOVD CAA(R8), R9 - MOVD CEECAATHDID(R9), R9 - MOVD R9, ret+0(FP) + // Get function. + MOVD CAA(R8), R9 + MOVD EDCHPXV(R9), R9 + MOVD trap+0(FP), R5 + SLD $4, R5 + ADD R5, R9 + LMG 0(R9), R5, R6 + // Restore LE stack. + MOVD SAVSTACK_ASYNC(R8), R9 + MOVD 0(R9), R4 + MOVD $0, 0(R9) + + // Fill in parameter list. + MOVD a4+32(FP), R12 + MOVD R12, (2176+24)(R4) + MOVD a5+40(FP), R12 + MOVD R12, (2176+32)(R4) + MOVD a6+48(FP), R12 + MOVD R12, (2176+40)(R4) + + // Call function. + LE_CALL + NOPH + XOR R0, R0 // Restore R0 to $0. + MOVD R4, 0(R9) // Save stack pointer. + + MOVD R3, r1+56(FP) + MOVD R0, r2+64(FP) + MOVD R0, err+72(FP) + MOVW R3, R4 + CMP R4, $-1 + BNE done + BL addrerrno<>(SB) + MOVWZ 0(R3), R3 + MOVD R3, err+72(FP) +done: + BL runtime·exitsyscall(SB) RET -// -// Call LE function, if the return is -1 -// errno and errno2 is retrieved -// -TEXT ·CallLeFuncWithErr(SB), NOSPLIT, $0 - MOVW PSALAA, R8 - MOVD LCA64(R8), R8 - MOVD CAA(R8), R9 - MOVD g, GOCB(R9) +TEXT ·syscall_rawsyscall6(SB),NOSPLIT,$0-80 + MOVD a1+8(FP), R1 + MOVD a2+16(FP), R2 + MOVD a3+24(FP), R3 + + // Get library control area (LCA). + MOVW PSALAA, R8 + MOVD LCA64(R8), R8 + + // Get function. + MOVD CAA(R8), R9 + MOVD EDCHPXV(R9), R9 + MOVD trap+0(FP), R5 + SLD $4, R5 + ADD R5, R9 + LMG 0(R9), R5, R6 // Restore LE stack. - MOVD SAVSTACK_ASYNC(R8), R9 // R9-> LE stack frame saving address - MOVD 0(R9), R4 // R4-> restore previously saved stack frame pointer - - MOVD parms_base+8(FP), R7 // R7 -> argument array - MOVD parms_len+16(FP), R8 // R8 number of arguments - - // arg 1 ---> R1 - CMP R8, $0 - BEQ docall - SUB $1, R8 - MOVD 0(R7), R1 - - // arg 2 ---> R2 - CMP R8, $0 - BEQ docall - SUB $1, R8 - ADD $8, R7 - MOVD 0(R7), R2 - - // arg 3 --> R3 - CMP R8, $0 - BEQ docall - SUB $1, R8 - ADD $8, R7 - MOVD 0(R7), R3 - - CMP R8, $0 - BEQ docall - MOVD $2176+16, R6 // starting LE stack address-8 to store 4th argument - -repeat: - ADD $8, R7 - MOVD 0(R7), R0 // advance arg pointer by 8 byte - ADD $8, R6 // advance LE argument address by 8 byte - MOVD R0, (R4)(R6*1) // copy argument from go-slice to le-frame - SUB $1, R8 - CMP R8, $0 - BNE repeat - -docall: - MOVD funcdesc+0(FP), R8 // R8-> function descriptor - LMG 0(R8), R5, R6 - MOVD $0, 0(R9) // R9 address of SAVSTACK_ASYNC - LE_CALL // balr R7, R6 (return #1) - NOPH - MOVD R3, ret+32(FP) - CMP R3, $-1 // compare result to -1 - BNE done - - // retrieve errno and errno2 - MOVD zosLibVec<>(SB), R8 - ADD $(__errno), R8 - LMG 0(R8), R5, R6 - LE_CALL // balr R7, R6 __errno (return #3) - NOPH - MOVWZ 0(R3), R3 - MOVD R3, err+48(FP) - MOVD zosLibVec<>(SB), R8 - ADD $(__err2ad), R8 - LMG 0(R8), R5, R6 - LE_CALL // balr R7, R6 __err2ad (return #2) + MOVD SAVSTACK_ASYNC(R8), R9 + MOVD 0(R9), R4 + MOVD $0, 0(R9) + + // Fill in parameter list. + MOVD a4+32(FP), R12 + MOVD R12, (2176+24)(R4) + MOVD a5+40(FP), R12 + MOVD R12, (2176+32)(R4) + MOVD a6+48(FP), R12 + MOVD R12, (2176+40)(R4) + + // Call function. + LE_CALL NOPH - MOVW (R3), R2 // retrieve errno2 - MOVD R2, errno2+40(FP) // store in return area - + XOR R0, R0 // Restore R0 to $0. + MOVD R4, 0(R9) // Save stack pointer. + + MOVD R3, r1+56(FP) + MOVD R0, r2+64(FP) + MOVD R0, err+72(FP) + MOVW R3, R4 + CMP R4, $-1 + BNE done + BL ·rrno<>(SB) + MOVWZ 0(R3), R3 + MOVD R3, err+72(FP) done: - MOVD R4, 0(R9) // Save stack pointer. RET -// -// Call LE function, if the return is 0 -// errno and errno2 is retrieved -// -TEXT ·CallLeFuncWithPtrReturn(SB), NOSPLIT, $0 - MOVW PSALAA, R8 - MOVD LCA64(R8), R8 - MOVD CAA(R8), R9 - MOVD g, GOCB(R9) +TEXT ·syscall_syscall9(SB),NOSPLIT,$0 + BL runtime·entersyscall(SB) + MOVD a1+8(FP), R1 + MOVD a2+16(FP), R2 + MOVD a3+24(FP), R3 + + // Get library control area (LCA). + MOVW PSALAA, R8 + MOVD LCA64(R8), R8 + + // Get function. + MOVD CAA(R8), R9 + MOVD EDCHPXV(R9), R9 + MOVD trap+0(FP), R5 + SLD $4, R5 + ADD R5, R9 + LMG 0(R9), R5, R6 // Restore LE stack. - MOVD SAVSTACK_ASYNC(R8), R9 // R9-> LE stack frame saving address - MOVD 0(R9), R4 // R4-> restore previously saved stack frame pointer - - MOVD parms_base+8(FP), R7 // R7 -> argument array - MOVD parms_len+16(FP), R8 // R8 number of arguments - - // arg 1 ---> R1 - CMP R8, $0 - BEQ docall - SUB $1, R8 - MOVD 0(R7), R1 - - // arg 2 ---> R2 - CMP R8, $0 - BEQ docall - SUB $1, R8 - ADD $8, R7 - MOVD 0(R7), R2 - - // arg 3 --> R3 - CMP R8, $0 - BEQ docall - SUB $1, R8 - ADD $8, R7 - MOVD 0(R7), R3 - - CMP R8, $0 - BEQ docall - MOVD $2176+16, R6 // starting LE stack address-8 to store 4th argument - -repeat: - ADD $8, R7 - MOVD 0(R7), R0 // advance arg pointer by 8 byte - ADD $8, R6 // advance LE argument address by 8 byte - MOVD R0, (R4)(R6*1) // copy argument from go-slice to le-frame - SUB $1, R8 - CMP R8, $0 - BNE repeat - -docall: - MOVD funcdesc+0(FP), R8 // R8-> function descriptor - LMG 0(R8), R5, R6 - MOVD $0, 0(R9) // R9 address of SAVSTACK_ASYNC - LE_CALL // balr R7, R6 (return #1) - NOPH - MOVD R3, ret+32(FP) - CMP R3, $0 // compare result to 0 - BNE done - - // retrieve errno and errno2 - MOVD zosLibVec<>(SB), R8 - ADD $(__errno), R8 - LMG 0(R8), R5, R6 - LE_CALL // balr R7, R6 __errno (return #3) + MOVD SAVSTACK_ASYNC(R8), R9 + MOVD 0(R9), R4 + MOVD $0, 0(R9) + + // Fill in parameter list. + MOVD a4+32(FP), R12 + MOVD R12, (2176+24)(R4) + MOVD a5+40(FP), R12 + MOVD R12, (2176+32)(R4) + MOVD a6+48(FP), R12 + MOVD R12, (2176+40)(R4) + MOVD a7+56(FP), R12 + MOVD R12, (2176+48)(R4) + MOVD a8+64(FP), R12 + MOVD R12, (2176+56)(R4) + MOVD a9+72(FP), R12 + MOVD R12, (2176+64)(R4) + + // Call function. + LE_CALL NOPH - MOVWZ 0(R3), R3 - MOVD R3, err+48(FP) - MOVD zosLibVec<>(SB), R8 - ADD $(__err2ad), R8 - LMG 0(R8), R5, R6 - LE_CALL // balr R7, R6 __err2ad (return #2) + XOR R0, R0 // Restore R0 to $0. + MOVD R4, 0(R9) // Save stack pointer. + + MOVD R3, r1+80(FP) + MOVD R0, r2+88(FP) + MOVD R0, err+96(FP) + MOVW R3, R4 + CMP R4, $-1 + BNE done + BL addrerrno<>(SB) + MOVWZ 0(R3), R3 + MOVD R3, err+96(FP) +done: + BL runtime·exitsyscall(SB) + RET + +TEXT ·syscall_rawsyscall9(SB),NOSPLIT,$0 + MOVD a1+8(FP), R1 + MOVD a2+16(FP), R2 + MOVD a3+24(FP), R3 + + // Get library control area (LCA). + MOVW PSALAA, R8 + MOVD LCA64(R8), R8 + + // Get function. + MOVD CAA(R8), R9 + MOVD EDCHPXV(R9), R9 + MOVD trap+0(FP), R5 + SLD $4, R5 + ADD R5, R9 + LMG 0(R9), R5, R6 + + // Restore LE stack. + MOVD SAVSTACK_ASYNC(R8), R9 + MOVD 0(R9), R4 + MOVD $0, 0(R9) + + // Fill in parameter list. + MOVD a4+32(FP), R12 + MOVD R12, (2176+24)(R4) + MOVD a5+40(FP), R12 + MOVD R12, (2176+32)(R4) + MOVD a6+48(FP), R12 + MOVD R12, (2176+40)(R4) + MOVD a7+56(FP), R12 + MOVD R12, (2176+48)(R4) + MOVD a8+64(FP), R12 + MOVD R12, (2176+56)(R4) + MOVD a9+72(FP), R12 + MOVD R12, (2176+64)(R4) + + // Call function. + LE_CALL NOPH - MOVW (R3), R2 // retrieve errno2 - MOVD R2, errno2+40(FP) // store in return area - XOR R2, R2 - MOVWZ R2, (R3) // clear errno2 + XOR R0, R0 // Restore R0 to $0. + MOVD R4, 0(R9) // Save stack pointer. + + MOVD R3, r1+80(FP) + MOVD R0, r2+88(FP) + MOVD R0, err+96(FP) + MOVW R3, R4 + CMP R4, $-1 + BNE done + BL addrerrno<>(SB) + MOVWZ 0(R3), R3 + MOVD R3, err+96(FP) +done: + RET + +// func svcCall(fnptr unsafe.Pointer, argv *unsafe.Pointer, dsa *uint64) +TEXT ·svcCall(SB),NOSPLIT,$0 + BL runtime·save_g(SB) // Save g and stack pointer + MOVW PSALAA, R8 + MOVD LCA64(R8), R8 + MOVD SAVSTACK_ASYNC(R8), R9 + MOVD R15, 0(R9) + + MOVD argv+8(FP), R1 // Move function arguments into registers + MOVD dsa+16(FP), g + MOVD fnptr+0(FP), R15 + + BYTE $0x0D // Branch to function + BYTE $0xEF + + BL runtime·load_g(SB) // Restore g and stack pointer + MOVW PSALAA, R8 + MOVD LCA64(R8), R8 + MOVD SAVSTACK_ASYNC(R8), R9 + MOVD 0(R9), R15 + RET + +// func svcLoad(name *byte) unsafe.Pointer +TEXT ·svcLoad(SB),NOSPLIT,$0 + MOVD R15, R2 // Save go stack pointer + MOVD name+0(FP), R0 // Move SVC args into registers + MOVD $0x80000000, R1 + MOVD $0, R15 + BYTE $0x0A // SVC 08 LOAD + BYTE $0x08 + MOVW R15, R3 // Save return code from SVC + MOVD R2, R15 // Restore go stack pointer + CMP R3, $0 // Check SVC return code + BNE error + + MOVD $-2, R3 // Reset last bit of entry point to zero + AND R0, R3 + MOVD R3, addr+8(FP) // Return entry point returned by SVC + CMP R0, R3 // Check if last bit of entry point was set + BNE done + + MOVD R15, R2 // Save go stack pointer + MOVD $0, R15 // Move SVC args into registers (entry point still in r0 from SVC 08) + BYTE $0x0A // SVC 09 DELETE + BYTE $0x09 + MOVD R2, R15 // Restore go stack pointer + +error: + MOVD $0, addr+8(FP) // Return 0 on failure done: - MOVD R4, 0(R9) // Save stack pointer. + XOR R0, R0 // Reset r0 to 0 RET -// -// function to test if a pointer can be safely dereferenced (content read) -// return 0 for succces -// -TEXT ·ptrtest(SB), NOSPLIT, $0-16 - MOVD arg+0(FP), R10 // test pointer in R10 - - // set up R2 to point to CEECAADMC - BYTE $0xE3; BYTE $0x20; BYTE $0x04; BYTE $0xB8; BYTE $0x00; BYTE $0x17 // llgt 2,1208 - BYTE $0xB9; BYTE $0x17; BYTE $0x00; BYTE $0x22 // llgtr 2,2 - BYTE $0xA5; BYTE $0x26; BYTE $0x7F; BYTE $0xFF // nilh 2,32767 - BYTE $0xE3; BYTE $0x22; BYTE $0x00; BYTE $0x58; BYTE $0x00; BYTE $0x04 // lg 2,88(2) - BYTE $0xE3; BYTE $0x22; BYTE $0x00; BYTE $0x08; BYTE $0x00; BYTE $0x04 // lg 2,8(2) - BYTE $0x41; BYTE $0x22; BYTE $0x03; BYTE $0x68 // la 2,872(2) - - // set up R5 to point to the "shunt" path which set 1 to R3 (failure) - BYTE $0xB9; BYTE $0x82; BYTE $0x00; BYTE $0x33 // xgr 3,3 - BYTE $0xA7; BYTE $0x55; BYTE $0x00; BYTE $0x04 // bras 5,lbl1 - BYTE $0xA7; BYTE $0x39; BYTE $0x00; BYTE $0x01 // lghi 3,1 - - // if r3 is not zero (failed) then branch to finish - BYTE $0xB9; BYTE $0x02; BYTE $0x00; BYTE $0x33 // lbl1 ltgr 3,3 - BYTE $0xA7; BYTE $0x74; BYTE $0x00; BYTE $0x08 // brc b'0111',lbl2 - - // stomic store shunt address in R5 into CEECAADMC - BYTE $0xE3; BYTE $0x52; BYTE $0x00; BYTE $0x00; BYTE $0x00; BYTE $0x24 // stg 5,0(2) - - // now try reading from the test pointer in R10, if it fails it branches to the "lghi" instruction above - BYTE $0xE3; BYTE $0x9A; BYTE $0x00; BYTE $0x00; BYTE $0x00; BYTE $0x04 // lg 9,0(10) - - // finish here, restore 0 into CEECAADMC - BYTE $0xB9; BYTE $0x82; BYTE $0x00; BYTE $0x99 // lbl2 xgr 9,9 - BYTE $0xE3; BYTE $0x92; BYTE $0x00; BYTE $0x00; BYTE $0x00; BYTE $0x24 // stg 9,0(2) - MOVD R3, ret+8(FP) // result in R3 +// func svcUnload(name *byte, fnptr unsafe.Pointer) int64 +TEXT ·svcUnload(SB),NOSPLIT,$0 + MOVD R15, R2 // Save go stack pointer + MOVD name+0(FP), R0 // Move SVC args into registers + MOVD addr+8(FP), R15 + BYTE $0x0A // SVC 09 + BYTE $0x09 + XOR R0, R0 // Reset r0 to 0 + MOVD R15, R1 // Save SVC return code + MOVD R2, R15 // Restore go stack pointer + MOVD R1, rc+0(FP) // Return SVC return code RET -// -// function to test if a untptr can be loaded from a pointer -// return 1: the 8-byte content -// 2: 0 for success, 1 for failure -// -// func safeload(ptr uintptr) ( value uintptr, error uintptr) -TEXT ·safeload(SB), NOSPLIT, $0-24 - MOVD ptr+0(FP), R10 // test pointer in R10 - MOVD $0x0, R6 - BYTE $0xE3; BYTE $0x20; BYTE $0x04; BYTE $0xB8; BYTE $0x00; BYTE $0x17 // llgt 2,1208 - BYTE $0xB9; BYTE $0x17; BYTE $0x00; BYTE $0x22 // llgtr 2,2 - BYTE $0xA5; BYTE $0x26; BYTE $0x7F; BYTE $0xFF // nilh 2,32767 - BYTE $0xE3; BYTE $0x22; BYTE $0x00; BYTE $0x58; BYTE $0x00; BYTE $0x04 // lg 2,88(2) - BYTE $0xE3; BYTE $0x22; BYTE $0x00; BYTE $0x08; BYTE $0x00; BYTE $0x04 // lg 2,8(2) - BYTE $0x41; BYTE $0x22; BYTE $0x03; BYTE $0x68 // la 2,872(2) - BYTE $0xB9; BYTE $0x82; BYTE $0x00; BYTE $0x33 // xgr 3,3 - BYTE $0xA7; BYTE $0x55; BYTE $0x00; BYTE $0x04 // bras 5,lbl1 - BYTE $0xA7; BYTE $0x39; BYTE $0x00; BYTE $0x01 // lghi 3,1 - BYTE $0xB9; BYTE $0x02; BYTE $0x00; BYTE $0x33 // lbl1 ltgr 3,3 - BYTE $0xA7; BYTE $0x74; BYTE $0x00; BYTE $0x08 // brc b'0111',lbl2 - BYTE $0xE3; BYTE $0x52; BYTE $0x00; BYTE $0x00; BYTE $0x00; BYTE $0x24 // stg 5,0(2) - BYTE $0xE3; BYTE $0x6A; BYTE $0x00; BYTE $0x00; BYTE $0x00; BYTE $0x04 // lg 6,0(10) - BYTE $0xB9; BYTE $0x82; BYTE $0x00; BYTE $0x99 // lbl2 xgr 9,9 - BYTE $0xE3; BYTE $0x92; BYTE $0x00; BYTE $0x00; BYTE $0x00; BYTE $0x24 // stg 9,0(2) - MOVD R6, value+8(FP) // result in R6 - MOVD R3, error+16(FP) // error in R3 +// func gettid() uint64 +TEXT ·gettid(SB), NOSPLIT, $0 + // Get library control area (LCA). + MOVW PSALAA, R8 + MOVD LCA64(R8), R8 + + // Get CEECAATHDID + MOVD CAA(R8), R9 + MOVD 0x3D0(R9), R9 + MOVD R9, ret+0(FP) + RET diff --git a/services/vendor/golang.org/x/sys/unix/bpxsvc_zos.go b/services/vendor/golang.org/x/sys/unix/bpxsvc_zos.go deleted file mode 100644 index 39d647d8..00000000 --- a/services/vendor/golang.org/x/sys/unix/bpxsvc_zos.go +++ /dev/null @@ -1,657 +0,0 @@ -// 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 zos - -package unix - -import ( - "bytes" - "fmt" - "unsafe" -) - -//go:noescape -func bpxcall(plist []unsafe.Pointer, bpx_offset int64) - -//go:noescape -func A2e([]byte) - -//go:noescape -func E2a([]byte) - -const ( - BPX4STA = 192 // stat - BPX4FST = 104 // fstat - BPX4LST = 132 // lstat - BPX4OPN = 156 // open - BPX4CLO = 72 // close - BPX4CHR = 500 // chattr - BPX4FCR = 504 // fchattr - BPX4LCR = 1180 // lchattr - BPX4CTW = 492 // cond_timed_wait - BPX4GTH = 1056 // __getthent - BPX4PTQ = 412 // pthread_quiesc - BPX4PTR = 320 // ptrace -) - -const ( - //options - //byte1 - BPX_OPNFHIGH = 0x80 - //byte2 - BPX_OPNFEXEC = 0x80 - //byte3 - BPX_O_NOLARGEFILE = 0x08 - BPX_O_LARGEFILE = 0x04 - BPX_O_ASYNCSIG = 0x02 - BPX_O_SYNC = 0x01 - //byte4 - BPX_O_CREXCL = 0xc0 - BPX_O_CREAT = 0x80 - BPX_O_EXCL = 0x40 - BPX_O_NOCTTY = 0x20 - BPX_O_TRUNC = 0x10 - BPX_O_APPEND = 0x08 - BPX_O_NONBLOCK = 0x04 - BPX_FNDELAY = 0x04 - BPX_O_RDWR = 0x03 - BPX_O_RDONLY = 0x02 - BPX_O_WRONLY = 0x01 - BPX_O_ACCMODE = 0x03 - BPX_O_GETFL = 0x0f - - //mode - // byte1 (file type) - BPX_FT_DIR = 1 - BPX_FT_CHARSPEC = 2 - BPX_FT_REGFILE = 3 - BPX_FT_FIFO = 4 - BPX_FT_SYMLINK = 5 - BPX_FT_SOCKET = 6 - //byte3 - BPX_S_ISUID = 0x08 - BPX_S_ISGID = 0x04 - BPX_S_ISVTX = 0x02 - BPX_S_IRWXU1 = 0x01 - BPX_S_IRUSR = 0x01 - //byte4 - BPX_S_IRWXU2 = 0xc0 - BPX_S_IWUSR = 0x80 - BPX_S_IXUSR = 0x40 - BPX_S_IRWXG = 0x38 - BPX_S_IRGRP = 0x20 - BPX_S_IWGRP = 0x10 - BPX_S_IXGRP = 0x08 - BPX_S_IRWXOX = 0x07 - BPX_S_IROTH = 0x04 - BPX_S_IWOTH = 0x02 - BPX_S_IXOTH = 0x01 - - CW_INTRPT = 1 - CW_CONDVAR = 32 - CW_TIMEOUT = 64 - - PGTHA_NEXT = 2 - PGTHA_CURRENT = 1 - PGTHA_FIRST = 0 - PGTHA_LAST = 3 - PGTHA_PROCESS = 0x80 - PGTHA_CONTTY = 0x40 - PGTHA_PATH = 0x20 - PGTHA_COMMAND = 0x10 - PGTHA_FILEDATA = 0x08 - PGTHA_THREAD = 0x04 - PGTHA_PTAG = 0x02 - PGTHA_COMMANDLONG = 0x01 - PGTHA_THREADFAST = 0x80 - PGTHA_FILEPATH = 0x40 - PGTHA_THDSIGMASK = 0x20 - // thread quiece mode - QUIESCE_TERM int32 = 1 - QUIESCE_FORCE int32 = 2 - QUIESCE_QUERY int32 = 3 - QUIESCE_FREEZE int32 = 4 - QUIESCE_UNFREEZE int32 = 5 - FREEZE_THIS_THREAD int32 = 6 - FREEZE_EXIT int32 = 8 - QUIESCE_SRB int32 = 9 -) - -type Pgtha struct { - Pid uint32 // 0 - Tid0 uint32 // 4 - Tid1 uint32 - Accesspid byte // C - Accesstid byte // D - Accessasid uint16 // E - Loginname [8]byte // 10 - Flag1 byte // 18 - Flag1b2 byte // 19 -} - -type Bpxystat_t struct { // DSECT BPXYSTAT - St_id [4]uint8 // 0 - St_length uint16 // 0x4 - St_version uint16 // 0x6 - St_mode uint32 // 0x8 - St_ino uint32 // 0xc - St_dev uint32 // 0x10 - St_nlink uint32 // 0x14 - St_uid uint32 // 0x18 - St_gid uint32 // 0x1c - St_size uint64 // 0x20 - St_atime uint32 // 0x28 - St_mtime uint32 // 0x2c - St_ctime uint32 // 0x30 - St_rdev uint32 // 0x34 - St_auditoraudit uint32 // 0x38 - St_useraudit uint32 // 0x3c - St_blksize uint32 // 0x40 - St_createtime uint32 // 0x44 - St_auditid [4]uint32 // 0x48 - St_res01 uint32 // 0x58 - Ft_ccsid uint16 // 0x5c - Ft_flags uint16 // 0x5e - St_res01a [2]uint32 // 0x60 - St_res02 uint32 // 0x68 - St_blocks uint32 // 0x6c - St_opaque [3]uint8 // 0x70 - St_visible uint8 // 0x73 - St_reftime uint32 // 0x74 - St_fid uint64 // 0x78 - St_filefmt uint8 // 0x80 - St_fspflag2 uint8 // 0x81 - St_res03 [2]uint8 // 0x82 - St_ctimemsec uint32 // 0x84 - St_seclabel [8]uint8 // 0x88 - St_res04 [4]uint8 // 0x90 - // end of version 1 - _ uint32 // 0x94 - St_atime64 uint64 // 0x98 - St_mtime64 uint64 // 0xa0 - St_ctime64 uint64 // 0xa8 - St_createtime64 uint64 // 0xb0 - St_reftime64 uint64 // 0xb8 - _ uint64 // 0xc0 - St_res05 [16]uint8 // 0xc8 - // end of version 2 -} - -type BpxFilestatus struct { - Oflag1 byte - Oflag2 byte - Oflag3 byte - Oflag4 byte -} - -type BpxMode struct { - Ftype byte - Mode1 byte - Mode2 byte - Mode3 byte -} - -// Thr attribute structure for extended attributes -type Bpxyatt_t struct { // DSECT BPXYATT - Att_id [4]uint8 - Att_version uint16 - Att_res01 [2]uint8 - Att_setflags1 uint8 - Att_setflags2 uint8 - Att_setflags3 uint8 - Att_setflags4 uint8 - Att_mode uint32 - Att_uid uint32 - Att_gid uint32 - Att_opaquemask [3]uint8 - Att_visblmaskres uint8 - Att_opaque [3]uint8 - Att_visibleres uint8 - Att_size_h uint32 - Att_size_l uint32 - Att_atime uint32 - Att_mtime uint32 - Att_auditoraudit uint32 - Att_useraudit uint32 - Att_ctime uint32 - Att_reftime uint32 - // end of version 1 - Att_filefmt uint8 - Att_res02 [3]uint8 - Att_filetag uint32 - Att_res03 [8]uint8 - // end of version 2 - Att_atime64 uint64 - Att_mtime64 uint64 - Att_ctime64 uint64 - Att_reftime64 uint64 - Att_seclabel [8]uint8 - Att_ver3res02 [8]uint8 - // end of version 3 -} - -func BpxOpen(name string, options *BpxFilestatus, mode *BpxMode) (rv int32, rc int32, rn int32) { - if len(name) < 1024 { - var namebuf [1024]byte - sz := int32(copy(namebuf[:], name)) - A2e(namebuf[:sz]) - var parms [7]unsafe.Pointer - parms[0] = unsafe.Pointer(&sz) - parms[1] = unsafe.Pointer(&namebuf[0]) - parms[2] = unsafe.Pointer(options) - parms[3] = unsafe.Pointer(mode) - parms[4] = unsafe.Pointer(&rv) - parms[5] = unsafe.Pointer(&rc) - parms[6] = unsafe.Pointer(&rn) - bpxcall(parms[:], BPX4OPN) - return rv, rc, rn - } - return -1, -1, -1 -} - -func BpxClose(fd int32) (rv int32, rc int32, rn int32) { - var parms [4]unsafe.Pointer - parms[0] = unsafe.Pointer(&fd) - parms[1] = unsafe.Pointer(&rv) - parms[2] = unsafe.Pointer(&rc) - parms[3] = unsafe.Pointer(&rn) - bpxcall(parms[:], BPX4CLO) - return rv, rc, rn -} - -func BpxFileFStat(fd int32, st *Bpxystat_t) (rv int32, rc int32, rn int32) { - st.St_id = [4]uint8{0xe2, 0xe3, 0xc1, 0xe3} - st.St_version = 2 - stat_sz := uint32(unsafe.Sizeof(*st)) - var parms [6]unsafe.Pointer - parms[0] = unsafe.Pointer(&fd) - parms[1] = unsafe.Pointer(&stat_sz) - parms[2] = unsafe.Pointer(st) - parms[3] = unsafe.Pointer(&rv) - parms[4] = unsafe.Pointer(&rc) - parms[5] = unsafe.Pointer(&rn) - bpxcall(parms[:], BPX4FST) - return rv, rc, rn -} - -func BpxFileStat(name string, st *Bpxystat_t) (rv int32, rc int32, rn int32) { - if len(name) < 1024 { - var namebuf [1024]byte - sz := int32(copy(namebuf[:], name)) - A2e(namebuf[:sz]) - st.St_id = [4]uint8{0xe2, 0xe3, 0xc1, 0xe3} - st.St_version = 2 - stat_sz := uint32(unsafe.Sizeof(*st)) - var parms [7]unsafe.Pointer - parms[0] = unsafe.Pointer(&sz) - parms[1] = unsafe.Pointer(&namebuf[0]) - parms[2] = unsafe.Pointer(&stat_sz) - parms[3] = unsafe.Pointer(st) - parms[4] = unsafe.Pointer(&rv) - parms[5] = unsafe.Pointer(&rc) - parms[6] = unsafe.Pointer(&rn) - bpxcall(parms[:], BPX4STA) - return rv, rc, rn - } - return -1, -1, -1 -} - -func BpxFileLStat(name string, st *Bpxystat_t) (rv int32, rc int32, rn int32) { - if len(name) < 1024 { - var namebuf [1024]byte - sz := int32(copy(namebuf[:], name)) - A2e(namebuf[:sz]) - st.St_id = [4]uint8{0xe2, 0xe3, 0xc1, 0xe3} - st.St_version = 2 - stat_sz := uint32(unsafe.Sizeof(*st)) - var parms [7]unsafe.Pointer - parms[0] = unsafe.Pointer(&sz) - parms[1] = unsafe.Pointer(&namebuf[0]) - parms[2] = unsafe.Pointer(&stat_sz) - parms[3] = unsafe.Pointer(st) - parms[4] = unsafe.Pointer(&rv) - parms[5] = unsafe.Pointer(&rc) - parms[6] = unsafe.Pointer(&rn) - bpxcall(parms[:], BPX4LST) - return rv, rc, rn - } - return -1, -1, -1 -} - -func BpxChattr(path string, attr *Bpxyatt_t) (rv int32, rc int32, rn int32) { - if len(path) >= 1024 { - return -1, -1, -1 - } - var namebuf [1024]byte - sz := int32(copy(namebuf[:], path)) - A2e(namebuf[:sz]) - attr_sz := uint32(unsafe.Sizeof(*attr)) - var parms [7]unsafe.Pointer - parms[0] = unsafe.Pointer(&sz) - parms[1] = unsafe.Pointer(&namebuf[0]) - parms[2] = unsafe.Pointer(&attr_sz) - parms[3] = unsafe.Pointer(attr) - parms[4] = unsafe.Pointer(&rv) - parms[5] = unsafe.Pointer(&rc) - parms[6] = unsafe.Pointer(&rn) - bpxcall(parms[:], BPX4CHR) - return rv, rc, rn -} - -func BpxLchattr(path string, attr *Bpxyatt_t) (rv int32, rc int32, rn int32) { - if len(path) >= 1024 { - return -1, -1, -1 - } - var namebuf [1024]byte - sz := int32(copy(namebuf[:], path)) - A2e(namebuf[:sz]) - attr_sz := uint32(unsafe.Sizeof(*attr)) - var parms [7]unsafe.Pointer - parms[0] = unsafe.Pointer(&sz) - parms[1] = unsafe.Pointer(&namebuf[0]) - parms[2] = unsafe.Pointer(&attr_sz) - parms[3] = unsafe.Pointer(attr) - parms[4] = unsafe.Pointer(&rv) - parms[5] = unsafe.Pointer(&rc) - parms[6] = unsafe.Pointer(&rn) - bpxcall(parms[:], BPX4LCR) - return rv, rc, rn -} - -func BpxFchattr(fd int32, attr *Bpxyatt_t) (rv int32, rc int32, rn int32) { - attr_sz := uint32(unsafe.Sizeof(*attr)) - var parms [6]unsafe.Pointer - parms[0] = unsafe.Pointer(&fd) - parms[1] = unsafe.Pointer(&attr_sz) - parms[2] = unsafe.Pointer(attr) - parms[3] = unsafe.Pointer(&rv) - parms[4] = unsafe.Pointer(&rc) - parms[5] = unsafe.Pointer(&rn) - bpxcall(parms[:], BPX4FCR) - return rv, rc, rn -} - -func BpxCondTimedWait(sec uint32, nsec uint32, events uint32, secrem *uint32, nsecrem *uint32) (rv int32, rc int32, rn int32) { - var parms [8]unsafe.Pointer - parms[0] = unsafe.Pointer(&sec) - parms[1] = unsafe.Pointer(&nsec) - parms[2] = unsafe.Pointer(&events) - parms[3] = unsafe.Pointer(secrem) - parms[4] = unsafe.Pointer(nsecrem) - parms[5] = unsafe.Pointer(&rv) - parms[6] = unsafe.Pointer(&rc) - parms[7] = unsafe.Pointer(&rn) - bpxcall(parms[:], BPX4CTW) - return rv, rc, rn -} -func BpxGetthent(in *Pgtha, outlen *uint32, out unsafe.Pointer) (rv int32, rc int32, rn int32) { - var parms [7]unsafe.Pointer - inlen := uint32(26) // nothing else will work. Go says Pgtha is 28-byte because of alignment, but Pgtha is "packed" and must be 26-byte - parms[0] = unsafe.Pointer(&inlen) - parms[1] = unsafe.Pointer(&in) - parms[2] = unsafe.Pointer(outlen) - parms[3] = unsafe.Pointer(&out) - parms[4] = unsafe.Pointer(&rv) - parms[5] = unsafe.Pointer(&rc) - parms[6] = unsafe.Pointer(&rn) - bpxcall(parms[:], BPX4GTH) - return rv, rc, rn -} -func ZosJobname() (jobname string, err error) { - var pgtha Pgtha - pgtha.Pid = uint32(Getpid()) - pgtha.Accesspid = PGTHA_CURRENT - pgtha.Flag1 = PGTHA_PROCESS - var out [256]byte - var outlen uint32 - outlen = 256 - rv, rc, rn := BpxGetthent(&pgtha, &outlen, unsafe.Pointer(&out[0])) - if rv == 0 { - gthc := []byte{0x87, 0xa3, 0x88, 0x83} // 'gthc' in ebcdic - ix := bytes.Index(out[:], gthc) - if ix == -1 { - err = fmt.Errorf("BPX4GTH: gthc return data not found") - return - } - jn := out[ix+80 : ix+88] // we didn't declare Pgthc, but jobname is 8-byte at offset 80 - E2a(jn) - jobname = string(bytes.TrimRight(jn, " ")) - - } else { - err = fmt.Errorf("BPX4GTH: rc=%d errno=%d reason=code=0x%x", rv, rc, rn) - } - return -} -func Bpx4ptq(code int32, data string) (rv int32, rc int32, rn int32) { - var userdata [8]byte - var parms [5]unsafe.Pointer - copy(userdata[:], data+" ") - A2e(userdata[:]) - parms[0] = unsafe.Pointer(&code) - parms[1] = unsafe.Pointer(&userdata[0]) - parms[2] = unsafe.Pointer(&rv) - parms[3] = unsafe.Pointer(&rc) - parms[4] = unsafe.Pointer(&rn) - bpxcall(parms[:], BPX4PTQ) - return rv, rc, rn -} - -const ( - PT_TRACE_ME = 0 // Debug this process - PT_READ_I = 1 // Read a full word - PT_READ_D = 2 // Read a full word - PT_READ_U = 3 // Read control info - PT_WRITE_I = 4 //Write a full word - PT_WRITE_D = 5 //Write a full word - PT_CONTINUE = 7 //Continue the process - PT_KILL = 8 //Terminate the process - PT_READ_GPR = 11 // Read GPR, CR, PSW - PT_READ_FPR = 12 // Read FPR - PT_READ_VR = 13 // Read VR - PT_WRITE_GPR = 14 // Write GPR, CR, PSW - PT_WRITE_FPR = 15 // Write FPR - PT_WRITE_VR = 16 // Write VR - PT_READ_BLOCK = 17 // Read storage - PT_WRITE_BLOCK = 19 // Write storage - PT_READ_GPRH = 20 // Read GPRH - PT_WRITE_GPRH = 21 // Write GPRH - PT_REGHSET = 22 // Read all GPRHs - PT_ATTACH = 30 // Attach to a process - PT_DETACH = 31 // Detach from a process - PT_REGSET = 32 // Read all GPRs - PT_REATTACH = 33 // Reattach to a process - PT_LDINFO = 34 // Read loader info - PT_MULTI = 35 // Multi process mode - PT_LD64INFO = 36 // RMODE64 Info Area - PT_BLOCKREQ = 40 // Block request - PT_THREAD_INFO = 60 // Read thread info - PT_THREAD_MODIFY = 61 - PT_THREAD_READ_FOCUS = 62 - PT_THREAD_WRITE_FOCUS = 63 - PT_THREAD_HOLD = 64 - PT_THREAD_SIGNAL = 65 - PT_EXPLAIN = 66 - PT_EVENTS = 67 - PT_THREAD_INFO_EXTENDED = 68 - PT_REATTACH2 = 71 - PT_CAPTURE = 72 - PT_UNCAPTURE = 73 - PT_GET_THREAD_TCB = 74 - PT_GET_ALET = 75 - PT_SWAPIN = 76 - PT_EXTENDED_EVENT = 98 - PT_RECOVER = 99 // Debug a program check - PT_GPR0 = 0 // General purpose register 0 - PT_GPR1 = 1 // General purpose register 1 - PT_GPR2 = 2 // General purpose register 2 - PT_GPR3 = 3 // General purpose register 3 - PT_GPR4 = 4 // General purpose register 4 - PT_GPR5 = 5 // General purpose register 5 - PT_GPR6 = 6 // General purpose register 6 - PT_GPR7 = 7 // General purpose register 7 - PT_GPR8 = 8 // General purpose register 8 - PT_GPR9 = 9 // General purpose register 9 - PT_GPR10 = 10 // General purpose register 10 - PT_GPR11 = 11 // General purpose register 11 - PT_GPR12 = 12 // General purpose register 12 - PT_GPR13 = 13 // General purpose register 13 - PT_GPR14 = 14 // General purpose register 14 - PT_GPR15 = 15 // General purpose register 15 - PT_FPR0 = 16 // Floating point register 0 - PT_FPR1 = 17 // Floating point register 1 - PT_FPR2 = 18 // Floating point register 2 - PT_FPR3 = 19 // Floating point register 3 - PT_FPR4 = 20 // Floating point register 4 - PT_FPR5 = 21 // Floating point register 5 - PT_FPR6 = 22 // Floating point register 6 - PT_FPR7 = 23 // Floating point register 7 - PT_FPR8 = 24 // Floating point register 8 - PT_FPR9 = 25 // Floating point register 9 - PT_FPR10 = 26 // Floating point register 10 - PT_FPR11 = 27 // Floating point register 11 - PT_FPR12 = 28 // Floating point register 12 - PT_FPR13 = 29 // Floating point register 13 - PT_FPR14 = 30 // Floating point register 14 - PT_FPR15 = 31 // Floating point register 15 - PT_FPC = 32 // Floating point control register - PT_PSW = 40 // PSW - PT_PSW0 = 40 // Left half of the PSW - PT_PSW1 = 41 // Right half of the PSW - PT_CR0 = 42 // Control register 0 - PT_CR1 = 43 // Control register 1 - PT_CR2 = 44 // Control register 2 - PT_CR3 = 45 // Control register 3 - PT_CR4 = 46 // Control register 4 - PT_CR5 = 47 // Control register 5 - PT_CR6 = 48 // Control register 6 - PT_CR7 = 49 // Control register 7 - PT_CR8 = 50 // Control register 8 - PT_CR9 = 51 // Control register 9 - PT_CR10 = 52 // Control register 10 - PT_CR11 = 53 // Control register 11 - PT_CR12 = 54 // Control register 12 - PT_CR13 = 55 // Control register 13 - PT_CR14 = 56 // Control register 14 - PT_CR15 = 57 // Control register 15 - PT_GPRH0 = 58 // GP High register 0 - PT_GPRH1 = 59 // GP High register 1 - PT_GPRH2 = 60 // GP High register 2 - PT_GPRH3 = 61 // GP High register 3 - PT_GPRH4 = 62 // GP High register 4 - PT_GPRH5 = 63 // GP High register 5 - PT_GPRH6 = 64 // GP High register 6 - PT_GPRH7 = 65 // GP High register 7 - PT_GPRH8 = 66 // GP High register 8 - PT_GPRH9 = 67 // GP High register 9 - PT_GPRH10 = 68 // GP High register 10 - PT_GPRH11 = 69 // GP High register 11 - PT_GPRH12 = 70 // GP High register 12 - PT_GPRH13 = 71 // GP High register 13 - PT_GPRH14 = 72 // GP High register 14 - PT_GPRH15 = 73 // GP High register 15 - PT_VR0 = 74 // Vector register 0 - PT_VR1 = 75 // Vector register 1 - PT_VR2 = 76 // Vector register 2 - PT_VR3 = 77 // Vector register 3 - PT_VR4 = 78 // Vector register 4 - PT_VR5 = 79 // Vector register 5 - PT_VR6 = 80 // Vector register 6 - PT_VR7 = 81 // Vector register 7 - PT_VR8 = 82 // Vector register 8 - PT_VR9 = 83 // Vector register 9 - PT_VR10 = 84 // Vector register 10 - PT_VR11 = 85 // Vector register 11 - PT_VR12 = 86 // Vector register 12 - PT_VR13 = 87 // Vector register 13 - PT_VR14 = 88 // Vector register 14 - PT_VR15 = 89 // Vector register 15 - PT_VR16 = 90 // Vector register 16 - PT_VR17 = 91 // Vector register 17 - PT_VR18 = 92 // Vector register 18 - PT_VR19 = 93 // Vector register 19 - PT_VR20 = 94 // Vector register 20 - PT_VR21 = 95 // Vector register 21 - PT_VR22 = 96 // Vector register 22 - PT_VR23 = 97 // Vector register 23 - PT_VR24 = 98 // Vector register 24 - PT_VR25 = 99 // Vector register 25 - PT_VR26 = 100 // Vector register 26 - PT_VR27 = 101 // Vector register 27 - PT_VR28 = 102 // Vector register 28 - PT_VR29 = 103 // Vector register 29 - PT_VR30 = 104 // Vector register 30 - PT_VR31 = 105 // Vector register 31 - PT_PSWG = 106 // PSWG - PT_PSWG0 = 106 // Bytes 0-3 - PT_PSWG1 = 107 // Bytes 4-7 - PT_PSWG2 = 108 // Bytes 8-11 (IA high word) - PT_PSWG3 = 109 // Bytes 12-15 (IA low word) -) - -func Bpx4ptr(request int32, pid int32, addr unsafe.Pointer, data unsafe.Pointer, buffer unsafe.Pointer) (rv int32, rc int32, rn int32) { - var parms [8]unsafe.Pointer - parms[0] = unsafe.Pointer(&request) - parms[1] = unsafe.Pointer(&pid) - parms[2] = unsafe.Pointer(&addr) - parms[3] = unsafe.Pointer(&data) - parms[4] = unsafe.Pointer(&buffer) - parms[5] = unsafe.Pointer(&rv) - parms[6] = unsafe.Pointer(&rc) - parms[7] = unsafe.Pointer(&rn) - bpxcall(parms[:], BPX4PTR) - return rv, rc, rn -} - -func copyU8(val uint8, dest []uint8) int { - if len(dest) < 1 { - return 0 - } - dest[0] = val - return 1 -} - -func copyU8Arr(src, dest []uint8) int { - if len(dest) < len(src) { - return 0 - } - for i, v := range src { - dest[i] = v - } - return len(src) -} - -func copyU16(val uint16, dest []uint16) int { - if len(dest) < 1 { - return 0 - } - dest[0] = val - return 1 -} - -func copyU32(val uint32, dest []uint32) int { - if len(dest) < 1 { - return 0 - } - dest[0] = val - return 1 -} - -func copyU32Arr(src, dest []uint32) int { - if len(dest) < len(src) { - return 0 - } - for i, v := range src { - dest[i] = v - } - return len(src) -} - -func copyU64(val uint64, dest []uint64) int { - if len(dest) < 1 { - return 0 - } - dest[0] = val - return 1 -} diff --git a/services/vendor/golang.org/x/sys/unix/bpxsvc_zos.s b/services/vendor/golang.org/x/sys/unix/bpxsvc_zos.s deleted file mode 100644 index 4bd4a179..00000000 --- a/services/vendor/golang.org/x/sys/unix/bpxsvc_zos.s +++ /dev/null @@ -1,192 +0,0 @@ -// 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. - -#include "go_asm.h" -#include "textflag.h" - -// function to call USS assembly language services -// -// doc: https://www.ibm.com/support/knowledgecenter/en/SSLTBW_3.1.0/com.ibm.zos.v3r1.bpxb100/bit64env.htm -// -// arg1 unsafe.Pointer array that ressembles an OS PLIST -// -// arg2 function offset as in -// doc: https://www.ibm.com/support/knowledgecenter/en/SSLTBW_3.1.0/com.ibm.zos.v3r1.bpxb100/bpx2cr_List_of_offsets.htm -// -// func bpxcall(plist []unsafe.Pointer, bpx_offset int64) - -TEXT ·bpxcall(SB), NOSPLIT|NOFRAME, $0 - MOVD plist_base+0(FP), R1 // r1 points to plist - MOVD bpx_offset+24(FP), R2 // r2 offset to BPX vector table - MOVD R14, R7 // save r14 - MOVD R15, R8 // save r15 - MOVWZ 16(R0), R9 - MOVWZ 544(R9), R9 - MOVWZ 24(R9), R9 // call vector in r9 - ADD R2, R9 // add offset to vector table - MOVWZ (R9), R9 // r9 points to entry point - BYTE $0x0D // BL R14,R9 --> basr r14,r9 - BYTE $0xE9 // clobbers 0,1,14,15 - MOVD R8, R15 // restore 15 - JMP R7 // return via saved return address - -// func A2e(arr [] byte) -// code page conversion from 819 to 1047 -TEXT ·A2e(SB), NOSPLIT|NOFRAME, $0 - MOVD arg_base+0(FP), R2 // pointer to arry of characters - MOVD arg_len+8(FP), R3 // count - XOR R0, R0 - XOR R1, R1 - BYTE $0xA7; BYTE $0x15; BYTE $0x00; BYTE $0x82 // BRAS 1,(2+(256/2)) - - // ASCII -> EBCDIC conversion table: - BYTE $0x00; BYTE $0x01; BYTE $0x02; BYTE $0x03 - BYTE $0x37; BYTE $0x2d; BYTE $0x2e; BYTE $0x2f - BYTE $0x16; BYTE $0x05; BYTE $0x15; BYTE $0x0b - BYTE $0x0c; BYTE $0x0d; BYTE $0x0e; BYTE $0x0f - BYTE $0x10; BYTE $0x11; BYTE $0x12; BYTE $0x13 - BYTE $0x3c; BYTE $0x3d; BYTE $0x32; BYTE $0x26 - BYTE $0x18; BYTE $0x19; BYTE $0x3f; BYTE $0x27 - BYTE $0x1c; BYTE $0x1d; BYTE $0x1e; BYTE $0x1f - BYTE $0x40; BYTE $0x5a; BYTE $0x7f; BYTE $0x7b - BYTE $0x5b; BYTE $0x6c; BYTE $0x50; BYTE $0x7d - BYTE $0x4d; BYTE $0x5d; BYTE $0x5c; BYTE $0x4e - BYTE $0x6b; BYTE $0x60; BYTE $0x4b; BYTE $0x61 - BYTE $0xf0; BYTE $0xf1; BYTE $0xf2; BYTE $0xf3 - BYTE $0xf4; BYTE $0xf5; BYTE $0xf6; BYTE $0xf7 - BYTE $0xf8; BYTE $0xf9; BYTE $0x7a; BYTE $0x5e - BYTE $0x4c; BYTE $0x7e; BYTE $0x6e; BYTE $0x6f - BYTE $0x7c; BYTE $0xc1; BYTE $0xc2; BYTE $0xc3 - BYTE $0xc4; BYTE $0xc5; BYTE $0xc6; BYTE $0xc7 - BYTE $0xc8; BYTE $0xc9; BYTE $0xd1; BYTE $0xd2 - BYTE $0xd3; BYTE $0xd4; BYTE $0xd5; BYTE $0xd6 - BYTE $0xd7; BYTE $0xd8; BYTE $0xd9; BYTE $0xe2 - BYTE $0xe3; BYTE $0xe4; BYTE $0xe5; BYTE $0xe6 - BYTE $0xe7; BYTE $0xe8; BYTE $0xe9; BYTE $0xad - BYTE $0xe0; BYTE $0xbd; BYTE $0x5f; BYTE $0x6d - BYTE $0x79; BYTE $0x81; BYTE $0x82; BYTE $0x83 - BYTE $0x84; BYTE $0x85; BYTE $0x86; BYTE $0x87 - BYTE $0x88; BYTE $0x89; BYTE $0x91; BYTE $0x92 - BYTE $0x93; BYTE $0x94; BYTE $0x95; BYTE $0x96 - BYTE $0x97; BYTE $0x98; BYTE $0x99; BYTE $0xa2 - BYTE $0xa3; BYTE $0xa4; BYTE $0xa5; BYTE $0xa6 - BYTE $0xa7; BYTE $0xa8; BYTE $0xa9; BYTE $0xc0 - BYTE $0x4f; BYTE $0xd0; BYTE $0xa1; BYTE $0x07 - BYTE $0x20; BYTE $0x21; BYTE $0x22; BYTE $0x23 - BYTE $0x24; BYTE $0x25; BYTE $0x06; BYTE $0x17 - BYTE $0x28; BYTE $0x29; BYTE $0x2a; BYTE $0x2b - BYTE $0x2c; BYTE $0x09; BYTE $0x0a; BYTE $0x1b - BYTE $0x30; BYTE $0x31; BYTE $0x1a; BYTE $0x33 - BYTE $0x34; BYTE $0x35; BYTE $0x36; BYTE $0x08 - BYTE $0x38; BYTE $0x39; BYTE $0x3a; BYTE $0x3b - BYTE $0x04; BYTE $0x14; BYTE $0x3e; BYTE $0xff - BYTE $0x41; BYTE $0xaa; BYTE $0x4a; BYTE $0xb1 - BYTE $0x9f; BYTE $0xb2; BYTE $0x6a; BYTE $0xb5 - BYTE $0xbb; BYTE $0xb4; BYTE $0x9a; BYTE $0x8a - BYTE $0xb0; BYTE $0xca; BYTE $0xaf; BYTE $0xbc - BYTE $0x90; BYTE $0x8f; BYTE $0xea; BYTE $0xfa - BYTE $0xbe; BYTE $0xa0; BYTE $0xb6; BYTE $0xb3 - BYTE $0x9d; BYTE $0xda; BYTE $0x9b; BYTE $0x8b - BYTE $0xb7; BYTE $0xb8; BYTE $0xb9; BYTE $0xab - BYTE $0x64; BYTE $0x65; BYTE $0x62; BYTE $0x66 - BYTE $0x63; BYTE $0x67; BYTE $0x9e; BYTE $0x68 - BYTE $0x74; BYTE $0x71; BYTE $0x72; BYTE $0x73 - BYTE $0x78; BYTE $0x75; BYTE $0x76; BYTE $0x77 - BYTE $0xac; BYTE $0x69; BYTE $0xed; BYTE $0xee - BYTE $0xeb; BYTE $0xef; BYTE $0xec; BYTE $0xbf - BYTE $0x80; BYTE $0xfd; BYTE $0xfe; BYTE $0xfb - BYTE $0xfc; BYTE $0xba; BYTE $0xae; BYTE $0x59 - BYTE $0x44; BYTE $0x45; BYTE $0x42; BYTE $0x46 - BYTE $0x43; BYTE $0x47; BYTE $0x9c; BYTE $0x48 - BYTE $0x54; BYTE $0x51; BYTE $0x52; BYTE $0x53 - BYTE $0x58; BYTE $0x55; BYTE $0x56; BYTE $0x57 - BYTE $0x8c; BYTE $0x49; BYTE $0xcd; BYTE $0xce - BYTE $0xcb; BYTE $0xcf; BYTE $0xcc; BYTE $0xe1 - BYTE $0x70; BYTE $0xdd; BYTE $0xde; BYTE $0xdb - BYTE $0xdc; BYTE $0x8d; BYTE $0x8e; BYTE $0xdf - -retry: - WORD $0xB9931022 // TROO 2,2,b'0001' - BVS retry - RET - -// func e2a(arr [] byte) -// code page conversion from 1047 to 819 -TEXT ·E2a(SB), NOSPLIT|NOFRAME, $0 - MOVD arg_base+0(FP), R2 // pointer to arry of characters - MOVD arg_len+8(FP), R3 // count - XOR R0, R0 - XOR R1, R1 - BYTE $0xA7; BYTE $0x15; BYTE $0x00; BYTE $0x82 // BRAS 1,(2+(256/2)) - - // EBCDIC -> ASCII conversion table: - BYTE $0x00; BYTE $0x01; BYTE $0x02; BYTE $0x03 - BYTE $0x9c; BYTE $0x09; BYTE $0x86; BYTE $0x7f - BYTE $0x97; BYTE $0x8d; BYTE $0x8e; BYTE $0x0b - BYTE $0x0c; BYTE $0x0d; BYTE $0x0e; BYTE $0x0f - BYTE $0x10; BYTE $0x11; BYTE $0x12; BYTE $0x13 - BYTE $0x9d; BYTE $0x0a; BYTE $0x08; BYTE $0x87 - BYTE $0x18; BYTE $0x19; BYTE $0x92; BYTE $0x8f - BYTE $0x1c; BYTE $0x1d; BYTE $0x1e; BYTE $0x1f - BYTE $0x80; BYTE $0x81; BYTE $0x82; BYTE $0x83 - BYTE $0x84; BYTE $0x85; BYTE $0x17; BYTE $0x1b - BYTE $0x88; BYTE $0x89; BYTE $0x8a; BYTE $0x8b - BYTE $0x8c; BYTE $0x05; BYTE $0x06; BYTE $0x07 - BYTE $0x90; BYTE $0x91; BYTE $0x16; BYTE $0x93 - BYTE $0x94; BYTE $0x95; BYTE $0x96; BYTE $0x04 - BYTE $0x98; BYTE $0x99; BYTE $0x9a; BYTE $0x9b - BYTE $0x14; BYTE $0x15; BYTE $0x9e; BYTE $0x1a - BYTE $0x20; BYTE $0xa0; BYTE $0xe2; BYTE $0xe4 - BYTE $0xe0; BYTE $0xe1; BYTE $0xe3; BYTE $0xe5 - BYTE $0xe7; BYTE $0xf1; BYTE $0xa2; BYTE $0x2e - BYTE $0x3c; BYTE $0x28; BYTE $0x2b; BYTE $0x7c - BYTE $0x26; BYTE $0xe9; BYTE $0xea; BYTE $0xeb - BYTE $0xe8; BYTE $0xed; BYTE $0xee; BYTE $0xef - BYTE $0xec; BYTE $0xdf; BYTE $0x21; BYTE $0x24 - BYTE $0x2a; BYTE $0x29; BYTE $0x3b; BYTE $0x5e - BYTE $0x2d; BYTE $0x2f; BYTE $0xc2; BYTE $0xc4 - BYTE $0xc0; BYTE $0xc1; BYTE $0xc3; BYTE $0xc5 - BYTE $0xc7; BYTE $0xd1; BYTE $0xa6; BYTE $0x2c - BYTE $0x25; BYTE $0x5f; BYTE $0x3e; BYTE $0x3f - BYTE $0xf8; BYTE $0xc9; BYTE $0xca; BYTE $0xcb - BYTE $0xc8; BYTE $0xcd; BYTE $0xce; BYTE $0xcf - BYTE $0xcc; BYTE $0x60; BYTE $0x3a; BYTE $0x23 - BYTE $0x40; BYTE $0x27; BYTE $0x3d; BYTE $0x22 - BYTE $0xd8; BYTE $0x61; BYTE $0x62; BYTE $0x63 - BYTE $0x64; BYTE $0x65; BYTE $0x66; BYTE $0x67 - BYTE $0x68; BYTE $0x69; BYTE $0xab; BYTE $0xbb - BYTE $0xf0; BYTE $0xfd; BYTE $0xfe; BYTE $0xb1 - BYTE $0xb0; BYTE $0x6a; BYTE $0x6b; BYTE $0x6c - BYTE $0x6d; BYTE $0x6e; BYTE $0x6f; BYTE $0x70 - BYTE $0x71; BYTE $0x72; BYTE $0xaa; BYTE $0xba - BYTE $0xe6; BYTE $0xb8; BYTE $0xc6; BYTE $0xa4 - BYTE $0xb5; BYTE $0x7e; BYTE $0x73; BYTE $0x74 - BYTE $0x75; BYTE $0x76; BYTE $0x77; BYTE $0x78 - BYTE $0x79; BYTE $0x7a; BYTE $0xa1; BYTE $0xbf - BYTE $0xd0; BYTE $0x5b; BYTE $0xde; BYTE $0xae - BYTE $0xac; BYTE $0xa3; BYTE $0xa5; BYTE $0xb7 - BYTE $0xa9; BYTE $0xa7; BYTE $0xb6; BYTE $0xbc - BYTE $0xbd; BYTE $0xbe; BYTE $0xdd; BYTE $0xa8 - BYTE $0xaf; BYTE $0x5d; BYTE $0xb4; BYTE $0xd7 - BYTE $0x7b; BYTE $0x41; BYTE $0x42; BYTE $0x43 - BYTE $0x44; BYTE $0x45; BYTE $0x46; BYTE $0x47 - BYTE $0x48; BYTE $0x49; BYTE $0xad; BYTE $0xf4 - BYTE $0xf6; BYTE $0xf2; BYTE $0xf3; BYTE $0xf5 - BYTE $0x7d; BYTE $0x4a; BYTE $0x4b; BYTE $0x4c - BYTE $0x4d; BYTE $0x4e; BYTE $0x4f; BYTE $0x50 - BYTE $0x51; BYTE $0x52; BYTE $0xb9; BYTE $0xfb - BYTE $0xfc; BYTE $0xf9; BYTE $0xfa; BYTE $0xff - BYTE $0x5c; BYTE $0xf7; BYTE $0x53; BYTE $0x54 - BYTE $0x55; BYTE $0x56; BYTE $0x57; BYTE $0x58 - BYTE $0x59; BYTE $0x5a; BYTE $0xb2; BYTE $0xd4 - BYTE $0xd6; BYTE $0xd2; BYTE $0xd3; BYTE $0xd5 - BYTE $0x30; BYTE $0x31; BYTE $0x32; BYTE $0x33 - BYTE $0x34; BYTE $0x35; BYTE $0x36; BYTE $0x37 - BYTE $0x38; BYTE $0x39; BYTE $0xb3; BYTE $0xdb - BYTE $0xdc; BYTE $0xd9; BYTE $0xda; BYTE $0x9f - -retry: - WORD $0xB9931022 // TROO 2,2,b'0001' - BVS retry - RET diff --git a/services/vendor/golang.org/x/sys/unix/epoll_zos.go b/services/vendor/golang.org/x/sys/unix/epoll_zos.go new file mode 100644 index 00000000..7753fdde --- /dev/null +++ b/services/vendor/golang.org/x/sys/unix/epoll_zos.go @@ -0,0 +1,220 @@ +// Copyright 2020 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 zos && s390x + +package unix + +import ( + "sync" +) + +// This file simulates epoll on z/OS using poll. + +// Analogous to epoll_event on Linux. +// TODO(neeilan): Pad is because the Linux kernel expects a 96-bit struct. We never pass this to the kernel; remove? +type EpollEvent struct { + Events uint32 + Fd int32 + Pad int32 +} + +const ( + EPOLLERR = 0x8 + EPOLLHUP = 0x10 + EPOLLIN = 0x1 + EPOLLMSG = 0x400 + EPOLLOUT = 0x4 + EPOLLPRI = 0x2 + EPOLLRDBAND = 0x80 + EPOLLRDNORM = 0x40 + EPOLLWRBAND = 0x200 + EPOLLWRNORM = 0x100 + EPOLL_CTL_ADD = 0x1 + EPOLL_CTL_DEL = 0x2 + EPOLL_CTL_MOD = 0x3 + // The following constants are part of the epoll API, but represent + // currently unsupported functionality on z/OS. + // EPOLL_CLOEXEC = 0x80000 + // EPOLLET = 0x80000000 + // EPOLLONESHOT = 0x40000000 + // EPOLLRDHUP = 0x2000 // Typically used with edge-triggered notis + // EPOLLEXCLUSIVE = 0x10000000 // Exclusive wake-up mode + // EPOLLWAKEUP = 0x20000000 // Relies on Linux's BLOCK_SUSPEND capability +) + +// TODO(neeilan): We can eliminate these epToPoll / pToEpoll calls by using identical mask values for POLL/EPOLL +// constants where possible The lower 16 bits of epoll events (uint32) can fit any system poll event (int16). + +// epToPollEvt converts epoll event field to poll equivalent. +// In epoll, Events is a 32-bit field, while poll uses 16 bits. +func epToPollEvt(events uint32) int16 { + var ep2p = map[uint32]int16{ + EPOLLIN: POLLIN, + EPOLLOUT: POLLOUT, + EPOLLHUP: POLLHUP, + EPOLLPRI: POLLPRI, + EPOLLERR: POLLERR, + } + + var pollEvts int16 = 0 + for epEvt, pEvt := range ep2p { + if (events & epEvt) != 0 { + pollEvts |= pEvt + } + } + + return pollEvts +} + +// pToEpollEvt converts 16 bit poll event bitfields to 32-bit epoll event fields. +func pToEpollEvt(revents int16) uint32 { + var p2ep = map[int16]uint32{ + POLLIN: EPOLLIN, + POLLOUT: EPOLLOUT, + POLLHUP: EPOLLHUP, + POLLPRI: EPOLLPRI, + POLLERR: EPOLLERR, + } + + var epollEvts uint32 = 0 + for pEvt, epEvt := range p2ep { + if (revents & pEvt) != 0 { + epollEvts |= epEvt + } + } + + return epollEvts +} + +// Per-process epoll implementation. +type epollImpl struct { + mu sync.Mutex + epfd2ep map[int]*eventPoll + nextEpfd int +} + +// eventPoll holds a set of file descriptors being watched by the process. A process can have multiple epoll instances. +// On Linux, this is an in-kernel data structure accessed through a fd. +type eventPoll struct { + mu sync.Mutex + fds map[int]*EpollEvent +} + +// epoll impl for this process. +var impl epollImpl = epollImpl{ + epfd2ep: make(map[int]*eventPoll), + nextEpfd: 0, +} + +func (e *epollImpl) epollcreate(size int) (epfd int, err error) { + e.mu.Lock() + defer e.mu.Unlock() + epfd = e.nextEpfd + e.nextEpfd++ + + e.epfd2ep[epfd] = &eventPoll{ + fds: make(map[int]*EpollEvent), + } + return epfd, nil +} + +func (e *epollImpl) epollcreate1(flag int) (fd int, err error) { + return e.epollcreate(4) +} + +func (e *epollImpl) epollctl(epfd int, op int, fd int, event *EpollEvent) (err error) { + e.mu.Lock() + defer e.mu.Unlock() + + ep, ok := e.epfd2ep[epfd] + if !ok { + + return EBADF + } + + switch op { + case EPOLL_CTL_ADD: + // TODO(neeilan): When we make epfds and fds disjoint, detect epoll + // loops here (instances watching each other) and return ELOOP. + if _, ok := ep.fds[fd]; ok { + return EEXIST + } + ep.fds[fd] = event + case EPOLL_CTL_MOD: + if _, ok := ep.fds[fd]; !ok { + return ENOENT + } + ep.fds[fd] = event + case EPOLL_CTL_DEL: + if _, ok := ep.fds[fd]; !ok { + return ENOENT + } + delete(ep.fds, fd) + + } + return nil +} + +// Must be called while holding ep.mu +func (ep *eventPoll) getFds() []int { + fds := make([]int, len(ep.fds)) + for fd := range ep.fds { + fds = append(fds, fd) + } + return fds +} + +func (e *epollImpl) epollwait(epfd int, events []EpollEvent, msec int) (n int, err error) { + e.mu.Lock() // in [rare] case of concurrent epollcreate + epollwait + ep, ok := e.epfd2ep[epfd] + + if !ok { + e.mu.Unlock() + return 0, EBADF + } + + pollfds := make([]PollFd, 4) + for fd, epollevt := range ep.fds { + pollfds = append(pollfds, PollFd{Fd: int32(fd), Events: epToPollEvt(epollevt.Events)}) + } + e.mu.Unlock() + + n, err = Poll(pollfds, msec) + if err != nil { + return n, err + } + + i := 0 + for _, pFd := range pollfds { + if pFd.Revents != 0 { + events[i] = EpollEvent{Fd: pFd.Fd, Events: pToEpollEvt(pFd.Revents)} + i++ + } + + if i == n { + break + } + } + + return n, nil +} + +func EpollCreate(size int) (fd int, err error) { + return impl.epollcreate(size) +} + +func EpollCreate1(flag int) (fd int, err error) { + return impl.epollcreate1(flag) +} + +func EpollCtl(epfd int, op int, fd int, event *EpollEvent) (err error) { + return impl.epollctl(epfd, op, fd, event) +} + +// Because EpollWait mutates events, the caller is expected to coordinate +// concurrent access if calling with the same epfd from multiple goroutines. +func EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error) { + return impl.epollwait(epfd, events, msec) +} diff --git a/services/vendor/golang.org/x/sys/unix/fstatfs_zos.go b/services/vendor/golang.org/x/sys/unix/fstatfs_zos.go new file mode 100644 index 00000000..c8bde601 --- /dev/null +++ b/services/vendor/golang.org/x/sys/unix/fstatfs_zos.go @@ -0,0 +1,163 @@ +// Copyright 2020 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 zos && s390x + +package unix + +import ( + "unsafe" +) + +// This file simulates fstatfs on z/OS using fstatvfs and w_getmntent. + +func Fstatfs(fd int, stat *Statfs_t) (err error) { + var stat_v Statvfs_t + err = Fstatvfs(fd, &stat_v) + if err == nil { + // populate stat + stat.Type = 0 + stat.Bsize = stat_v.Bsize + stat.Blocks = stat_v.Blocks + stat.Bfree = stat_v.Bfree + stat.Bavail = stat_v.Bavail + stat.Files = stat_v.Files + stat.Ffree = stat_v.Ffree + stat.Fsid = stat_v.Fsid + stat.Namelen = stat_v.Namemax + stat.Frsize = stat_v.Frsize + stat.Flags = stat_v.Flag + for passn := 0; passn < 5; passn++ { + switch passn { + case 0: + err = tryGetmntent64(stat) + break + case 1: + err = tryGetmntent128(stat) + break + case 2: + err = tryGetmntent256(stat) + break + case 3: + err = tryGetmntent512(stat) + break + case 4: + err = tryGetmntent1024(stat) + break + default: + break + } + //proceed to return if: err is nil (found), err is nonnil but not ERANGE (another error occurred) + if err == nil || err != nil && err != ERANGE { + break + } + } + } + return err +} + +func tryGetmntent64(stat *Statfs_t) (err error) { + var mnt_ent_buffer struct { + header W_Mnth + filesys_info [64]W_Mntent + } + var buffer_size int = int(unsafe.Sizeof(mnt_ent_buffer)) + fs_count, err := W_Getmntent((*byte)(unsafe.Pointer(&mnt_ent_buffer)), buffer_size) + if err != nil { + return err + } + err = ERANGE //return ERANGE if no match is found in this batch + for i := 0; i < fs_count; i++ { + if stat.Fsid == uint64(mnt_ent_buffer.filesys_info[i].Dev) { + stat.Type = uint32(mnt_ent_buffer.filesys_info[i].Fstname[0]) + err = nil + break + } + } + return err +} + +func tryGetmntent128(stat *Statfs_t) (err error) { + var mnt_ent_buffer struct { + header W_Mnth + filesys_info [128]W_Mntent + } + var buffer_size int = int(unsafe.Sizeof(mnt_ent_buffer)) + fs_count, err := W_Getmntent((*byte)(unsafe.Pointer(&mnt_ent_buffer)), buffer_size) + if err != nil { + return err + } + err = ERANGE //return ERANGE if no match is found in this batch + for i := 0; i < fs_count; i++ { + if stat.Fsid == uint64(mnt_ent_buffer.filesys_info[i].Dev) { + stat.Type = uint32(mnt_ent_buffer.filesys_info[i].Fstname[0]) + err = nil + break + } + } + return err +} + +func tryGetmntent256(stat *Statfs_t) (err error) { + var mnt_ent_buffer struct { + header W_Mnth + filesys_info [256]W_Mntent + } + var buffer_size int = int(unsafe.Sizeof(mnt_ent_buffer)) + fs_count, err := W_Getmntent((*byte)(unsafe.Pointer(&mnt_ent_buffer)), buffer_size) + if err != nil { + return err + } + err = ERANGE //return ERANGE if no match is found in this batch + for i := 0; i < fs_count; i++ { + if stat.Fsid == uint64(mnt_ent_buffer.filesys_info[i].Dev) { + stat.Type = uint32(mnt_ent_buffer.filesys_info[i].Fstname[0]) + err = nil + break + } + } + return err +} + +func tryGetmntent512(stat *Statfs_t) (err error) { + var mnt_ent_buffer struct { + header W_Mnth + filesys_info [512]W_Mntent + } + var buffer_size int = int(unsafe.Sizeof(mnt_ent_buffer)) + fs_count, err := W_Getmntent((*byte)(unsafe.Pointer(&mnt_ent_buffer)), buffer_size) + if err != nil { + return err + } + err = ERANGE //return ERANGE if no match is found in this batch + for i := 0; i < fs_count; i++ { + if stat.Fsid == uint64(mnt_ent_buffer.filesys_info[i].Dev) { + stat.Type = uint32(mnt_ent_buffer.filesys_info[i].Fstname[0]) + err = nil + break + } + } + return err +} + +func tryGetmntent1024(stat *Statfs_t) (err error) { + var mnt_ent_buffer struct { + header W_Mnth + filesys_info [1024]W_Mntent + } + var buffer_size int = int(unsafe.Sizeof(mnt_ent_buffer)) + fs_count, err := W_Getmntent((*byte)(unsafe.Pointer(&mnt_ent_buffer)), buffer_size) + if err != nil { + return err + } + err = ERANGE //return ERANGE if no match is found in this batch + for i := 0; i < fs_count; i++ { + if stat.Fsid == uint64(mnt_ent_buffer.filesys_info[i].Dev) { + stat.Type = uint32(mnt_ent_buffer.filesys_info[i].Fstname[0]) + err = nil + break + } + } + return err +} diff --git a/services/vendor/golang.org/x/sys/unix/mkerrors.sh b/services/vendor/golang.org/x/sys/unix/mkerrors.sh index d07dd09e..fdcaa974 100644 --- a/services/vendor/golang.org/x/sys/unix/mkerrors.sh +++ b/services/vendor/golang.org/x/sys/unix/mkerrors.sh @@ -58,7 +58,6 @@ includes_Darwin=' #define _DARWIN_USE_64_BIT_INODE #define __APPLE_USE_RFC_3542 #include -#include #include #include #include @@ -264,7 +263,6 @@ struct ltchars { #include #include #include -#include #include #include #include @@ -551,7 +549,6 @@ ccflags="$@" $2 !~ "NLA_TYPE_MASK" && $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 ~ /^FIORDCHK$/ || $2 ~ /^SIOC/ || $2 ~ /^TIOC/ || diff --git a/services/vendor/golang.org/x/sys/unix/mmap_nomremap.go b/services/vendor/golang.org/x/sys/unix/mmap_nomremap.go index 7f602ffd..4b68e597 100644 --- a/services/vendor/golang.org/x/sys/unix/mmap_nomremap.go +++ b/services/vendor/golang.org/x/sys/unix/mmap_nomremap.go @@ -2,7 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. -//go:build aix || darwin || dragonfly || freebsd || openbsd || solaris || zos +//go:build aix || darwin || dragonfly || freebsd || openbsd || solaris package unix diff --git a/services/vendor/golang.org/x/sys/unix/mremap.go b/services/vendor/golang.org/x/sys/unix/mremap.go index 3a5e776f..fd45fe52 100644 --- a/services/vendor/golang.org/x/sys/unix/mremap.go +++ b/services/vendor/golang.org/x/sys/unix/mremap.go @@ -50,8 +50,3 @@ func (m *mremapMmapper) Mremap(oldData []byte, newLength int, flags int) (data [ func Mremap(oldData []byte, newLength int, flags int) (data []byte, err error) { return mapper.Mremap(oldData, newLength, flags) } - -func MremapPtr(oldAddr unsafe.Pointer, oldSize uintptr, newAddr unsafe.Pointer, newSize uintptr, flags int) (ret unsafe.Pointer, err error) { - xaddr, err := mapper.mremap(uintptr(oldAddr), oldSize, newSize, flags, uintptr(newAddr)) - return unsafe.Pointer(xaddr), err -} diff --git a/services/vendor/golang.org/x/sys/unix/pagesize_unix.go b/services/vendor/golang.org/x/sys/unix/pagesize_unix.go index 0482408d..4d0a3430 100644 --- a/services/vendor/golang.org/x/sys/unix/pagesize_unix.go +++ b/services/vendor/golang.org/x/sys/unix/pagesize_unix.go @@ -2,7 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. -//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos +//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris // For Unix, get the pagesize from the runtime. diff --git a/services/vendor/golang.org/x/sys/unix/readdirent_getdirentries.go b/services/vendor/golang.org/x/sys/unix/readdirent_getdirentries.go index b903c006..130398b6 100644 --- a/services/vendor/golang.org/x/sys/unix/readdirent_getdirentries.go +++ b/services/vendor/golang.org/x/sys/unix/readdirent_getdirentries.go @@ -2,7 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. -//go:build darwin || zos +//go:build darwin package unix diff --git a/services/vendor/golang.org/x/sys/unix/sockcmsg_zos.go b/services/vendor/golang.org/x/sys/unix/sockcmsg_zos.go deleted file mode 100644 index 3e53dbc0..00000000 --- a/services/vendor/golang.org/x/sys/unix/sockcmsg_zos.go +++ /dev/null @@ -1,58 +0,0 @@ -// 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. - -// Socket control messages - -package unix - -import "unsafe" - -// UnixCredentials encodes credentials into a socket control message -// for sending to another process. This can be used for -// authentication. -func UnixCredentials(ucred *Ucred) []byte { - b := make([]byte, CmsgSpace(SizeofUcred)) - h := (*Cmsghdr)(unsafe.Pointer(&b[0])) - h.Level = SOL_SOCKET - h.Type = SCM_CREDENTIALS - h.SetLen(CmsgLen(SizeofUcred)) - *(*Ucred)(h.data(0)) = *ucred - return b -} - -// ParseUnixCredentials decodes a socket control message that contains -// credentials in a Ucred structure. To receive such a message, the -// SO_PASSCRED option must be enabled on the socket. -func ParseUnixCredentials(m *SocketControlMessage) (*Ucred, error) { - if m.Header.Level != SOL_SOCKET { - return nil, EINVAL - } - if m.Header.Type != SCM_CREDENTIALS { - return nil, EINVAL - } - ucred := *(*Ucred)(unsafe.Pointer(&m.Data[0])) - return &ucred, nil -} - -// PktInfo4 encodes Inet4Pktinfo into a socket control message of type IP_PKTINFO. -func PktInfo4(info *Inet4Pktinfo) []byte { - b := make([]byte, CmsgSpace(SizeofInet4Pktinfo)) - h := (*Cmsghdr)(unsafe.Pointer(&b[0])) - h.Level = SOL_IP - h.Type = IP_PKTINFO - h.SetLen(CmsgLen(SizeofInet4Pktinfo)) - *(*Inet4Pktinfo)(h.data(0)) = *info - return b -} - -// PktInfo6 encodes Inet6Pktinfo into a socket control message of type IPV6_PKTINFO. -func PktInfo6(info *Inet6Pktinfo) []byte { - b := make([]byte, CmsgSpace(SizeofInet6Pktinfo)) - h := (*Cmsghdr)(unsafe.Pointer(&b[0])) - h.Level = SOL_IPV6 - h.Type = IPV6_PKTINFO - h.SetLen(CmsgLen(SizeofInet6Pktinfo)) - *(*Inet6Pktinfo)(h.data(0)) = *info - return b -} diff --git a/services/vendor/golang.org/x/sys/unix/symaddr_zos_s390x.s b/services/vendor/golang.org/x/sys/unix/symaddr_zos_s390x.s deleted file mode 100644 index 3c4f33cb..00000000 --- a/services/vendor/golang.org/x/sys/unix/symaddr_zos_s390x.s +++ /dev/null @@ -1,75 +0,0 @@ -// 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 zos && s390x && gc - -#include "textflag.h" - -// provide the address of function variable to be fixed up. - -TEXT ·getPipe2Addr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·Pipe2(SB), R8 - MOVD R8, ret+0(FP) - RET - -TEXT ·get_FlockAddr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·Flock(SB), R8 - MOVD R8, ret+0(FP) - RET - -TEXT ·get_GetxattrAddr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·Getxattr(SB), R8 - MOVD R8, ret+0(FP) - RET - -TEXT ·get_NanosleepAddr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·Nanosleep(SB), R8 - MOVD R8, ret+0(FP) - RET - -TEXT ·get_SetxattrAddr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·Setxattr(SB), R8 - MOVD R8, ret+0(FP) - RET - -TEXT ·get_Wait4Addr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·Wait4(SB), R8 - MOVD R8, ret+0(FP) - RET - -TEXT ·get_MountAddr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·Mount(SB), R8 - MOVD R8, ret+0(FP) - RET - -TEXT ·get_UnmountAddr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·Unmount(SB), R8 - MOVD R8, ret+0(FP) - RET - -TEXT ·get_UtimesNanoAtAddr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·UtimesNanoAt(SB), R8 - MOVD R8, ret+0(FP) - RET - -TEXT ·get_UtimesNanoAddr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·UtimesNano(SB), R8 - MOVD R8, ret+0(FP) - RET - -TEXT ·get_MkfifoatAddr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·Mkfifoat(SB), R8 - MOVD R8, ret+0(FP) - RET - -TEXT ·get_ChtagAddr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·Chtag(SB), R8 - MOVD R8, ret+0(FP) - RET - -TEXT ·get_ReadlinkatAddr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·Readlinkat(SB), R8 - MOVD R8, ret+0(FP) - RET - diff --git a/services/vendor/golang.org/x/sys/unix/syscall_darwin.go b/services/vendor/golang.org/x/sys/unix/syscall_darwin.go index 2d15200a..59542a89 100644 --- a/services/vendor/golang.org/x/sys/unix/syscall_darwin.go +++ b/services/vendor/golang.org/x/sys/unix/syscall_darwin.go @@ -402,18 +402,6 @@ func IoctlSetIfreqMTU(fd int, ifreq *IfreqMTU) error { return ioctlPtr(fd, SIOCSIFMTU, unsafe.Pointer(ifreq)) } -//sys renamexNp(from string, to string, flag uint32) (err error) - -func RenamexNp(from string, to string, flag uint32) (err error) { - return renamexNp(from, to, flag) -} - -//sys renameatxNp(fromfd int, from string, tofd int, to string, flag uint32) (err error) - -func RenameatxNp(fromfd int, from string, tofd int, to string, flag uint32) (err error) { - return renameatxNp(fromfd, from, tofd, to, flag) -} - //sys sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) = SYS_SYSCTL func Uname(uname *Utsname) error { @@ -554,18 +542,6 @@ func SysctlKinfoProcSlice(name string, args ...int) ([]KinfoProc, error) { } } -//sys pthread_chdir_np(path string) (err error) - -func PthreadChdir(path string) (err error) { - return pthread_chdir_np(path) -} - -//sys pthread_fchdir_np(fd int) (err error) - -func PthreadFchdir(fd int) (err error) { - return pthread_fchdir_np(fd) -} - //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/services/vendor/golang.org/x/sys/unix/syscall_darwin_libSystem.go b/services/vendor/golang.org/x/sys/unix/syscall_darwin_libSystem.go index 2f0fa76e..16dc6993 100644 --- a/services/vendor/golang.org/x/sys/unix/syscall_darwin_libSystem.go +++ b/services/vendor/golang.org/x/sys/unix/syscall_darwin_libSystem.go @@ -2,7 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. -//go:build darwin +//go:build darwin && go1.12 package unix diff --git a/services/vendor/golang.org/x/sys/unix/syscall_freebsd.go b/services/vendor/golang.org/x/sys/unix/syscall_freebsd.go index 2b57e0f7..64d1bb4d 100644 --- a/services/vendor/golang.org/x/sys/unix/syscall_freebsd.go +++ b/services/vendor/golang.org/x/sys/unix/syscall_freebsd.go @@ -13,7 +13,6 @@ package unix import ( - "errors" "sync" "unsafe" ) @@ -170,26 +169,25 @@ func Getfsstat(buf []Statfs_t, flags int) (n int, err error) { func Uname(uname *Utsname) error { mib := []_C_int{CTL_KERN, KERN_OSTYPE} n := unsafe.Sizeof(uname.Sysname) - // Suppress ENOMEM errors to be compatible with the C library __xuname() implementation. - if err := sysctl(mib, &uname.Sysname[0], &n, nil, 0); err != nil && !errors.Is(err, ENOMEM) { + if err := sysctl(mib, &uname.Sysname[0], &n, nil, 0); err != nil { return err } mib = []_C_int{CTL_KERN, KERN_HOSTNAME} n = unsafe.Sizeof(uname.Nodename) - if err := sysctl(mib, &uname.Nodename[0], &n, nil, 0); err != nil && !errors.Is(err, ENOMEM) { + if err := sysctl(mib, &uname.Nodename[0], &n, nil, 0); err != nil { return err } mib = []_C_int{CTL_KERN, KERN_OSRELEASE} n = unsafe.Sizeof(uname.Release) - if err := sysctl(mib, &uname.Release[0], &n, nil, 0); err != nil && !errors.Is(err, ENOMEM) { + if err := sysctl(mib, &uname.Release[0], &n, nil, 0); err != nil { return err } mib = []_C_int{CTL_KERN, KERN_VERSION} n = unsafe.Sizeof(uname.Version) - if err := sysctl(mib, &uname.Version[0], &n, nil, 0); err != nil && !errors.Is(err, ENOMEM) { + if err := sysctl(mib, &uname.Version[0], &n, nil, 0); err != nil { return err } @@ -207,7 +205,7 @@ func Uname(uname *Utsname) error { mib = []_C_int{CTL_HW, HW_MACHINE} n = unsafe.Sizeof(uname.Machine) - if err := sysctl(mib, &uname.Machine[0], &n, nil, 0); err != nil && !errors.Is(err, ENOMEM) { + if err := sysctl(mib, &uname.Machine[0], &n, nil, 0); err != nil { return err } diff --git a/services/vendor/golang.org/x/sys/unix/syscall_linux.go b/services/vendor/golang.org/x/sys/unix/syscall_linux.go index 3f1d3d4c..0f85e29e 100644 --- a/services/vendor/golang.org/x/sys/unix/syscall_linux.go +++ b/services/vendor/golang.org/x/sys/unix/syscall_linux.go @@ -1849,105 +1849,6 @@ func Dup2(oldfd, newfd int) error { //sys Fsmount(fd int, flags int, mountAttrs int) (fsfd int, err error) //sys Fsopen(fsName string, flags int) (fd int, err error) //sys Fspick(dirfd int, pathName string, flags int) (fd int, err error) - -//sys fsconfig(fd int, cmd uint, key *byte, value *byte, aux int) (err error) - -func fsconfigCommon(fd int, cmd uint, key string, value *byte, aux int) (err error) { - var keyp *byte - if keyp, err = BytePtrFromString(key); err != nil { - return - } - return fsconfig(fd, cmd, keyp, value, aux) -} - -// FsconfigSetFlag is equivalent to fsconfig(2) called -// with cmd == FSCONFIG_SET_FLAG. -// -// fd is the filesystem context to act upon. -// key the parameter key to set. -func FsconfigSetFlag(fd int, key string) (err error) { - return fsconfigCommon(fd, FSCONFIG_SET_FLAG, key, nil, 0) -} - -// FsconfigSetString is equivalent to fsconfig(2) called -// with cmd == FSCONFIG_SET_STRING. -// -// fd is the filesystem context to act upon. -// key the parameter key to set. -// value is the parameter value to set. -func FsconfigSetString(fd int, key string, value string) (err error) { - var valuep *byte - if valuep, err = BytePtrFromString(value); err != nil { - return - } - return fsconfigCommon(fd, FSCONFIG_SET_STRING, key, valuep, 0) -} - -// FsconfigSetBinary is equivalent to fsconfig(2) called -// with cmd == FSCONFIG_SET_BINARY. -// -// fd is the filesystem context to act upon. -// key the parameter key to set. -// value is the parameter value to set. -func FsconfigSetBinary(fd int, key string, value []byte) (err error) { - if len(value) == 0 { - return EINVAL - } - return fsconfigCommon(fd, FSCONFIG_SET_BINARY, key, &value[0], len(value)) -} - -// FsconfigSetPath is equivalent to fsconfig(2) called -// with cmd == FSCONFIG_SET_PATH. -// -// fd is the filesystem context to act upon. -// key the parameter key to set. -// path is a non-empty path for specified key. -// atfd is a file descriptor at which to start lookup from or AT_FDCWD. -func FsconfigSetPath(fd int, key string, path string, atfd int) (err error) { - var valuep *byte - if valuep, err = BytePtrFromString(path); err != nil { - return - } - return fsconfigCommon(fd, FSCONFIG_SET_PATH, key, valuep, atfd) -} - -// FsconfigSetPathEmpty is equivalent to fsconfig(2) called -// with cmd == FSCONFIG_SET_PATH_EMPTY. The same as -// FconfigSetPath but with AT_PATH_EMPTY implied. -func FsconfigSetPathEmpty(fd int, key string, path string, atfd int) (err error) { - var valuep *byte - if valuep, err = BytePtrFromString(path); err != nil { - return - } - return fsconfigCommon(fd, FSCONFIG_SET_PATH_EMPTY, key, valuep, atfd) -} - -// FsconfigSetFd is equivalent to fsconfig(2) called -// with cmd == FSCONFIG_SET_FD. -// -// fd is the filesystem context to act upon. -// key the parameter key to set. -// value is a file descriptor to be assigned to specified key. -func FsconfigSetFd(fd int, key string, value int) (err error) { - return fsconfigCommon(fd, FSCONFIG_SET_FD, key, nil, value) -} - -// FsconfigCreate is equivalent to fsconfig(2) called -// with cmd == FSCONFIG_CMD_CREATE. -// -// fd is the filesystem context to act upon. -func FsconfigCreate(fd int) (err error) { - return fsconfig(fd, FSCONFIG_CMD_CREATE, nil, nil, 0) -} - -// FsconfigReconfigure is equivalent to fsconfig(2) called -// with cmd == FSCONFIG_CMD_RECONFIGURE. -// -// fd is the filesystem context to act upon. -func FsconfigReconfigure(fd int) (err error) { - return fsconfig(fd, FSCONFIG_CMD_RECONFIGURE, nil, nil, 0) -} - //sys Getdents(fd int, buf []byte) (n int, err error) = SYS_GETDENTS64 //sysnb Getpgid(pid int) (pgid int, err error) @@ -2592,4 +2493,3 @@ func SchedGetAttr(pid int, flags uint) (*SchedAttr, error) { } //sys Cachestat(fd uint, crange *CachestatRange, cstat *Cachestat_t, flags uint) (err error) -//sys Mseal(b []byte, flags uint) (err error) diff --git a/services/vendor/golang.org/x/sys/unix/syscall_openbsd.go b/services/vendor/golang.org/x/sys/unix/syscall_openbsd.go index b86ded54..b25343c7 100644 --- a/services/vendor/golang.org/x/sys/unix/syscall_openbsd.go +++ b/services/vendor/golang.org/x/sys/unix/syscall_openbsd.go @@ -293,7 +293,6 @@ func Uname(uname *Utsname) error { //sys Mkfifoat(dirfd int, path string, mode uint32) (err error) //sys Mknod(path string, mode uint32, dev int) (err error) //sys Mknodat(dirfd int, path string, mode uint32, dev int) (err error) -//sys Mount(fsType string, dir string, flags int, data unsafe.Pointer) (err error) //sys Nanosleep(time *Timespec, leftover *Timespec) (err error) //sys Open(path string, mode int, perm uint32) (fd int, err error) //sys Openat(dirfd int, path string, mode int, perm uint32) (fd int, err error) diff --git a/services/vendor/golang.org/x/sys/unix/syscall_unix.go b/services/vendor/golang.org/x/sys/unix/syscall_unix.go index 4e92e5aa..77081de8 100644 --- a/services/vendor/golang.org/x/sys/unix/syscall_unix.go +++ b/services/vendor/golang.org/x/sys/unix/syscall_unix.go @@ -154,15 +154,6 @@ 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) -} - func Read(fd int, p []byte) (n int, err error) { n, err = read(fd, p) if raceenabled { diff --git a/services/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go b/services/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go index 312ae6ac..b473038c 100644 --- a/services/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go +++ b/services/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go @@ -4,21 +4,11 @@ //go:build zos && s390x -// Many of the following syscalls are not available on all versions of z/OS. -// Some missing calls have legacy implementations/simulations but others -// will be missing completely. To achieve consistent failing behaviour on -// legacy systems, we first test the function pointer via a safeloading -// mechanism to see if the function exists on a given system. Then execution -// is branched to either continue the function call, or return an error. - package unix import ( "bytes" "fmt" - "os" - "reflect" - "regexp" "runtime" "sort" "strings" @@ -27,205 +17,17 @@ import ( "unsafe" ) -//go:noescape -func initZosLibVec() - -//go:noescape -func GetZosLibVec() uintptr - -func init() { - initZosLibVec() - r0, _, _ := CallLeFuncWithPtrReturn(GetZosLibVec()+SYS_____GETENV_A<<4, uintptr(unsafe.Pointer(&([]byte("__ZOS_XSYSTRACE\x00"))[0]))) - if r0 != 0 { - n, _, _ := CallLeFuncWithPtrReturn(GetZosLibVec()+SYS___ATOI_A<<4, r0) - ZosTraceLevel = int(n) - r0, _, _ := CallLeFuncWithPtrReturn(GetZosLibVec()+SYS_____GETENV_A<<4, uintptr(unsafe.Pointer(&([]byte("__ZOS_XSYSTRACEFD\x00"))[0]))) - if r0 != 0 { - fd, _, _ := CallLeFuncWithPtrReturn(GetZosLibVec()+SYS___ATOI_A<<4, r0) - f := os.NewFile(fd, "zostracefile") - if f != nil { - ZosTracefile = f - } - } - - } -} - -//go:noescape -func CallLeFuncWithErr(funcdesc uintptr, parms ...uintptr) (ret, errno2 uintptr, err Errno) - -//go:noescape -func CallLeFuncWithPtrReturn(funcdesc uintptr, parms ...uintptr) (ret, errno2 uintptr, err Errno) - -// ------------------------------- -// pointer validity test -// good pointer returns 0 -// bad pointer returns 1 -// -//go:nosplit -func ptrtest(uintptr) uint64 - -// Load memory at ptr location with error handling if the location is invalid -// -//go:noescape -func safeload(ptr uintptr) (value uintptr, error uintptr) - const ( - entrypointLocationOffset = 8 // From function descriptor - - xplinkEyecatcher = 0x00c300c500c500f1 // ".C.E.E.1" - eyecatcherOffset = 16 // From function entrypoint (negative) - ppa1LocationOffset = 8 // From function entrypoint (negative) - - nameLenOffset = 0x14 // From PPA1 start - nameOffset = 0x16 // From PPA1 start + O_CLOEXEC = 0 // Dummy value (not supported). + AF_LOCAL = AF_UNIX // AF_LOCAL is an alias for AF_UNIX ) -func getPpaOffset(funcptr uintptr) int64 { - entrypoint, err := safeload(funcptr + entrypointLocationOffset) - if err != 0 { - return -1 - } - - // XPLink functions have ".C.E.E.1" as the first 8 bytes (EBCDIC) - val, err := safeload(entrypoint - eyecatcherOffset) - if err != 0 { - return -1 - } - if val != xplinkEyecatcher { - return -1 - } - - ppaoff, err := safeload(entrypoint - ppa1LocationOffset) - if err != 0 { - return -1 - } - - ppaoff >>= 32 - return int64(ppaoff) -} - -//------------------------------- -// function descriptor pointer validity test -// good pointer returns 0 -// bad pointer returns 1 - -// TODO: currently mksyscall_zos_s390x.go generate empty string for funcName -// have correct funcName pass to the funcptrtest function -func funcptrtest(funcptr uintptr, funcName string) uint64 { - entrypoint, err := safeload(funcptr + entrypointLocationOffset) - if err != 0 { - return 1 - } - - ppaoff := getPpaOffset(funcptr) - if ppaoff == -1 { - return 1 - } - - // PPA1 offset value is from the start of the entire function block, not the entrypoint - ppa1 := (entrypoint - eyecatcherOffset) + uintptr(ppaoff) - - nameLen, err := safeload(ppa1 + nameLenOffset) - if err != 0 { - return 1 - } - - nameLen >>= 48 - if nameLen > 128 { - return 1 - } - - // no function name input to argument end here - if funcName == "" { - return 0 - } - - var funcname [128]byte - for i := 0; i < int(nameLen); i += 8 { - v, err := safeload(ppa1 + nameOffset + uintptr(i)) - if err != 0 { - return 1 - } - funcname[i] = byte(v >> 56) - funcname[i+1] = byte(v >> 48) - funcname[i+2] = byte(v >> 40) - funcname[i+3] = byte(v >> 32) - funcname[i+4] = byte(v >> 24) - funcname[i+5] = byte(v >> 16) - funcname[i+6] = byte(v >> 8) - funcname[i+7] = byte(v) - } - - runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS___E2A_L<<4, // __e2a_l - []uintptr{uintptr(unsafe.Pointer(&funcname[0])), nameLen}) - - name := string(funcname[:nameLen]) - if name != funcName { - return 1 - } - - return 0 -} - -// For detection of capabilities on a system. -// Is function descriptor f a valid function? -func isValidLeFunc(f uintptr) error { - ret := funcptrtest(f, "") - if ret != 0 { - return fmt.Errorf("Bad pointer, not an LE function ") - } - return nil -} - -// Retrieve function name from descriptor -func getLeFuncName(f uintptr) (string, error) { - // assume it has been checked, only check ppa1 validity here - entry := ((*[2]uintptr)(unsafe.Pointer(f)))[1] - preamp := ((*[4]uint32)(unsafe.Pointer(entry - eyecatcherOffset))) - - offsetPpa1 := preamp[2] - if offsetPpa1 > 0x0ffff { - return "", fmt.Errorf("PPA1 offset seems too big 0x%x\n", offsetPpa1) - } - - ppa1 := uintptr(unsafe.Pointer(preamp)) + uintptr(offsetPpa1) - res := ptrtest(ppa1) - if res != 0 { - return "", fmt.Errorf("PPA1 address not valid") - } - - size := *(*uint16)(unsafe.Pointer(ppa1 + nameLenOffset)) - if size > 128 { - return "", fmt.Errorf("Function name seems too long, length=%d\n", size) - } - - var name [128]byte - funcname := (*[128]byte)(unsafe.Pointer(ppa1 + nameOffset)) - copy(name[0:size], funcname[0:size]) - - runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS___E2A_L<<4, // __e2a_l - []uintptr{uintptr(unsafe.Pointer(&name[0])), uintptr(size)}) - - return string(name[:size]), nil -} - -// Check z/OS version -func zosLeVersion() (version, release uint32) { - p1 := (*(*uintptr)(unsafe.Pointer(uintptr(1208)))) >> 32 - p1 = *(*uintptr)(unsafe.Pointer(uintptr(p1 + 88))) - p1 = *(*uintptr)(unsafe.Pointer(uintptr(p1 + 8))) - p1 = *(*uintptr)(unsafe.Pointer(uintptr(p1 + 984))) - vrm := *(*uint32)(unsafe.Pointer(p1 + 80)) - version = (vrm & 0x00ff0000) >> 16 - release = (vrm & 0x0000ff00) >> 8 - return -} - -// returns a zos C FILE * for stdio fd 0, 1, 2 -func ZosStdioFilep(fd int32) uintptr { - return uintptr(*(*uint64)(unsafe.Pointer(uintptr(*(*uint64)(unsafe.Pointer(uintptr(*(*uint64)(unsafe.Pointer(uintptr(uint64(*(*uint32)(unsafe.Pointer(uintptr(1208)))) + 80))) + uint64((fd+2)<<3)))))))) -} +func syscall_syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno) +func syscall_rawsyscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno) +func syscall_syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno) +func syscall_rawsyscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno) +func syscall_syscall9(trap, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err Errno) +func syscall_rawsyscall9(trap, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err Errno) func copyStat(stat *Stat_t, statLE *Stat_LE_t) { stat.Dev = uint64(statLE.Dev) @@ -263,21 +65,6 @@ func (d *Dirent) NameString() string { } } -func DecodeData(dest []byte, sz int, val uint64) { - for i := 0; i < sz; i++ { - dest[sz-1-i] = byte((val >> (uint64(i * 8))) & 0xff) - } -} - -func EncodeData(data []byte) uint64 { - var value uint64 - sz := len(data) - for i := 0; i < sz; i++ { - value |= uint64(data[i]) << uint64(((sz - i - 1) * 8)) - } - return value -} - func (sa *SockaddrInet4) sockaddr() (unsafe.Pointer, _Socklen, error) { if sa.Port < 0 || sa.Port > 0xFFFF { return nil, 0, EINVAL @@ -287,9 +74,7 @@ func (sa *SockaddrInet4) sockaddr() (unsafe.Pointer, _Socklen, error) { p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port)) p[0] = byte(sa.Port >> 8) p[1] = byte(sa.Port) - for i := 0; i < len(sa.Addr); i++ { - sa.raw.Addr[i] = sa.Addr[i] - } + sa.raw.Addr = sa.Addr return unsafe.Pointer(&sa.raw), _Socklen(sa.raw.Len), nil } @@ -303,9 +88,7 @@ func (sa *SockaddrInet6) sockaddr() (unsafe.Pointer, _Socklen, error) { p[0] = byte(sa.Port >> 8) p[1] = byte(sa.Port) sa.raw.Scope_id = sa.ZoneId - for i := 0; i < len(sa.Addr); i++ { - sa.raw.Addr[i] = sa.Addr[i] - } + sa.raw.Addr = sa.Addr return unsafe.Pointer(&sa.raw), _Socklen(sa.raw.Len), nil } @@ -363,9 +146,7 @@ func anyToSockaddr(_ int, rsa *RawSockaddrAny) (Sockaddr, error) { sa := new(SockaddrInet4) p := (*[2]byte)(unsafe.Pointer(&pp.Port)) sa.Port = int(p[0])<<8 + int(p[1]) - for i := 0; i < len(sa.Addr); i++ { - sa.Addr[i] = pp.Addr[i] - } + sa.Addr = pp.Addr return sa, nil case AF_INET6: @@ -374,9 +155,7 @@ func anyToSockaddr(_ int, rsa *RawSockaddrAny) (Sockaddr, error) { p := (*[2]byte)(unsafe.Pointer(&pp.Port)) sa.Port = int(p[0])<<8 + int(p[1]) sa.ZoneId = pp.Scope_id - for i := 0; i < len(sa.Addr); i++ { - sa.Addr[i] = pp.Addr[i] - } + sa.Addr = pp.Addr return sa, nil } return nil, EAFNOSUPPORT @@ -398,43 +177,6 @@ func Accept(fd int) (nfd int, sa Sockaddr, err error) { return } -func Accept4(fd int, flags int) (nfd int, sa Sockaddr, err error) { - var rsa RawSockaddrAny - var len _Socklen = SizeofSockaddrAny - nfd, err = accept4(fd, &rsa, &len, flags) - if err != nil { - return - } - if len > SizeofSockaddrAny { - panic("RawSockaddrAny too small") - } - // TODO(neeilan): Remove 0 in call - sa, err = anyToSockaddr(0, &rsa) - if err != nil { - Close(nfd) - nfd = 0 - } - return -} - -func Ctermid() (tty string, err error) { - var termdev [1025]byte - runtime.EnterSyscall() - r0, err2, err1 := CallLeFuncWithPtrReturn(GetZosLibVec()+SYS___CTERMID_A<<4, uintptr(unsafe.Pointer(&termdev[0]))) - runtime.ExitSyscall() - if r0 == 0 { - return "", fmt.Errorf("%s (errno2=0x%x)\n", err1.Error(), err2) - } - s := string(termdev[:]) - idx := strings.Index(s, string(rune(0))) - if idx == -1 { - tty = s - } else { - tty = s[:idx] - } - return -} - func (iov *Iovec) SetLen(length int) { iov.Len = uint64(length) } @@ -448,16 +190,10 @@ func (cmsg *Cmsghdr) SetLen(length int) { } //sys fcntl(fd int, cmd int, arg int) (val int, err error) -//sys Flistxattr(fd int, dest []byte) (sz int, err error) = SYS___FLISTXATTR_A -//sys Fremovexattr(fd int, attr string) (err error) = SYS___FREMOVEXATTR_A //sys read(fd int, p []byte) (n int, err error) //sys write(fd int, p []byte) (n int, err error) -//sys Fgetxattr(fd int, attr string, dest []byte) (sz int, err error) = SYS___FGETXATTR_A -//sys Fsetxattr(fd int, attr string, data []byte, flag int) (err error) = SYS___FSETXATTR_A - //sys accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) = SYS___ACCEPT_A -//sys accept4(s int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (fd int, err error) = SYS___ACCEPT4_A //sys bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) = SYS___BIND_A //sys connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) = SYS___CONNECT_A //sysnb getgroups(n int, list *_Gid_t) (nn int, err error) @@ -468,7 +204,6 @@ func (cmsg *Cmsghdr) SetLen(length int) { //sysnb socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) //sysnb getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) = SYS___GETPEERNAME_A //sysnb getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) = SYS___GETSOCKNAME_A -//sys Removexattr(path string, attr string) (err error) = SYS___REMOVEXATTR_A //sys recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error) = SYS___RECVFROM_A //sys sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) = SYS___SENDTO_A //sys recvmsg(s int, msg *Msghdr, flags int) (n int, err error) = SYS___RECVMSG_A @@ -477,10 +212,6 @@ func (cmsg *Cmsghdr) SetLen(length int) { //sys munmap(addr uintptr, length uintptr) (err error) = SYS_MUNMAP //sys ioctl(fd int, req int, arg uintptr) (err error) = SYS_IOCTL //sys ioctlPtr(fd int, req int, arg unsafe.Pointer) (err error) = SYS_IOCTL -//sys shmat(id int, addr uintptr, flag int) (ret uintptr, err error) = SYS_SHMAT -//sys shmctl(id int, cmd int, buf *SysvShmDesc) (result int, err error) = SYS_SHMCTL64 -//sys shmdt(addr uintptr) (err error) = SYS_SHMDT -//sys shmget(key int, size int, flag int) (id int, err error) = SYS_SHMGET //sys Access(path string, mode uint32) (err error) = SYS___ACCESS_A //sys Chdir(path string) (err error) = SYS___CHDIR_A @@ -489,31 +220,14 @@ func (cmsg *Cmsghdr) SetLen(length int) { //sys Creat(path string, mode uint32) (fd int, err error) = SYS___CREAT_A //sys Dup(oldfd int) (fd int, err error) //sys Dup2(oldfd int, newfd int) (err error) -//sys Dup3(oldfd int, newfd int, flags int) (err error) = SYS_DUP3 -//sys Dirfd(dirp uintptr) (fd int, err error) = SYS_DIRFD -//sys EpollCreate(size int) (fd int, err error) = SYS_EPOLL_CREATE -//sys EpollCreate1(flags int) (fd int, err error) = SYS_EPOLL_CREATE1 -//sys EpollCtl(epfd int, op int, fd int, event *EpollEvent) (err error) = SYS_EPOLL_CTL -//sys EpollPwait(epfd int, events []EpollEvent, msec int, sigmask *int) (n int, err error) = SYS_EPOLL_PWAIT -//sys EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error) = SYS_EPOLL_WAIT //sys Errno2() (er2 int) = SYS___ERRNO2 -//sys Eventfd(initval uint, flags int) (fd int, err error) = SYS_EVENTFD +//sys Err2ad() (eadd *int) = SYS___ERR2AD //sys Exit(code int) -//sys Faccessat(dirfd int, path string, mode uint32, flags int) (err error) = SYS___FACCESSAT_A - -func Faccessat2(dirfd int, path string, mode uint32, flags int) (err error) { - return Faccessat(dirfd, path, mode, flags) -} - //sys Fchdir(fd int) (err error) //sys Fchmod(fd int, mode uint32) (err error) -//sys Fchmodat(dirfd int, path string, mode uint32, flags int) (err error) = SYS___FCHMODAT_A //sys Fchown(fd int, uid int, gid int) (err error) -//sys Fchownat(fd int, path string, uid int, gid int, flags int) (err error) = SYS___FCHOWNAT_A //sys FcntlInt(fd uintptr, cmd int, arg int) (retval int, err error) = SYS_FCNTL -//sys Fdatasync(fd int) (err error) = SYS_FDATASYNC //sys fstat(fd int, stat *Stat_LE_t) (err error) -//sys fstatat(dirfd int, path string, stat *Stat_LE_t, flags int) (err error) = SYS___FSTATAT_A func Fstat(fd int, stat *Stat_t) (err error) { var statLE Stat_LE_t @@ -522,208 +236,28 @@ func Fstat(fd int, stat *Stat_t) (err error) { return } -func Fstatat(dirfd int, path string, stat *Stat_t, flags int) (err error) { - var statLE Stat_LE_t - err = fstatat(dirfd, path, &statLE, flags) - copyStat(stat, &statLE) - return -} - -func impl_Getxattr(path string, attr string, dest []byte) (sz int, err error) { - var _p0 *byte - _p0, err = BytePtrFromString(path) - if err != nil { - return - } - var _p1 *byte - _p1, err = BytePtrFromString(attr) - if err != nil { - return - } - var _p2 unsafe.Pointer - if len(dest) > 0 { - _p2 = unsafe.Pointer(&dest[0]) - } else { - _p2 = unsafe.Pointer(&_zero) - } - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___GETXATTR_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(_p2), uintptr(len(dest))) - sz = int(r0) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -//go:nosplit -func get_GetxattrAddr() *(func(path string, attr string, dest []byte) (sz int, err error)) - -var Getxattr = enter_Getxattr - -func enter_Getxattr(path string, attr string, dest []byte) (sz int, err error) { - funcref := get_GetxattrAddr() - if validGetxattr() { - *funcref = impl_Getxattr - } else { - *funcref = error_Getxattr - } - return (*funcref)(path, attr, dest) -} - -func error_Getxattr(path string, attr string, dest []byte) (sz int, err error) { - return -1, ENOSYS -} - -func validGetxattr() bool { - if funcptrtest(GetZosLibVec()+SYS___GETXATTR_A<<4, "") == 0 { - if name, err := getLeFuncName(GetZosLibVec() + SYS___GETXATTR_A<<4); err == nil { - return name == "__getxattr_a" - } - } - return false -} - -//sys Lgetxattr(link string, attr string, dest []byte) (sz int, err error) = SYS___LGETXATTR_A -//sys Lsetxattr(path string, attr string, data []byte, flags int) (err error) = SYS___LSETXATTR_A - -func impl_Setxattr(path string, attr string, data []byte, flags int) (err error) { - var _p0 *byte - _p0, err = BytePtrFromString(path) - if err != nil { - return - } - var _p1 *byte - _p1, err = BytePtrFromString(attr) - if err != nil { - return - } - var _p2 unsafe.Pointer - if len(data) > 0 { - _p2 = unsafe.Pointer(&data[0]) - } else { - _p2 = unsafe.Pointer(&_zero) - } - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___SETXATTR_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(_p2), uintptr(len(data)), uintptr(flags)) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -//go:nosplit -func get_SetxattrAddr() *(func(path string, attr string, data []byte, flags int) (err error)) - -var Setxattr = enter_Setxattr - -func enter_Setxattr(path string, attr string, data []byte, flags int) (err error) { - funcref := get_SetxattrAddr() - if validSetxattr() { - *funcref = impl_Setxattr - } else { - *funcref = error_Setxattr - } - return (*funcref)(path, attr, data, flags) -} - -func error_Setxattr(path string, attr string, data []byte, flags int) (err error) { - return ENOSYS -} - -func validSetxattr() bool { - if funcptrtest(GetZosLibVec()+SYS___SETXATTR_A<<4, "") == 0 { - if name, err := getLeFuncName(GetZosLibVec() + SYS___SETXATTR_A<<4); err == nil { - return name == "__setxattr_a" - } - } - return false -} - -//sys Fstatfs(fd int, buf *Statfs_t) (err error) = SYS_FSTATFS //sys Fstatvfs(fd int, stat *Statvfs_t) (err error) = SYS_FSTATVFS //sys Fsync(fd int) (err error) -//sys Futimes(fd int, tv []Timeval) (err error) = SYS_FUTIMES -//sys Futimesat(dirfd int, path string, tv []Timeval) (err error) = SYS___FUTIMESAT_A //sys Ftruncate(fd int, length int64) (err error) -//sys Getrandom(buf []byte, flags int) (n int, err error) = SYS_GETRANDOM -//sys InotifyInit() (fd int, err error) = SYS_INOTIFY_INIT -//sys InotifyInit1(flags int) (fd int, err error) = SYS_INOTIFY_INIT1 -//sys InotifyAddWatch(fd int, pathname string, mask uint32) (watchdesc int, err error) = SYS___INOTIFY_ADD_WATCH_A -//sys InotifyRmWatch(fd int, watchdesc uint32) (success int, err error) = SYS_INOTIFY_RM_WATCH -//sys Listxattr(path string, dest []byte) (sz int, err error) = SYS___LISTXATTR_A -//sys Llistxattr(path string, dest []byte) (sz int, err error) = SYS___LLISTXATTR_A -//sys Lremovexattr(path string, attr string) (err error) = SYS___LREMOVEXATTR_A -//sys Lutimes(path string, tv []Timeval) (err error) = SYS___LUTIMES_A +//sys Getpagesize() (pgsize int) = SYS_GETPAGESIZE //sys Mprotect(b []byte, prot int) (err error) = SYS_MPROTECT //sys Msync(b []byte, flags int) (err error) = SYS_MSYNC -//sys Console2(cmsg *ConsMsg2, modstr *byte, concmd *uint32) (err error) = SYS___CONSOLE2 - -// Pipe2 begin - -//go:nosplit -func getPipe2Addr() *(func([]int, int) error) - -var Pipe2 = pipe2Enter - -func pipe2Enter(p []int, flags int) (err error) { - if funcptrtest(GetZosLibVec()+SYS_PIPE2<<4, "") == 0 { - *getPipe2Addr() = pipe2Impl - } else { - *getPipe2Addr() = pipe2Error - } - return (*getPipe2Addr())(p, flags) -} - -func pipe2Impl(p []int, flags int) (err error) { - var pp [2]_C_int - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_PIPE2<<4, uintptr(unsafe.Pointer(&pp[0])), uintptr(flags)) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } else { - p[0] = int(pp[0]) - p[1] = int(pp[1]) - } - return -} -func pipe2Error(p []int, flags int) (err error) { - return fmt.Errorf("Pipe2 is not available on this system") -} - -// Pipe2 end - //sys Poll(fds []PollFd, timeout int) (n int, err error) = SYS_POLL - -func Readdir(dir uintptr) (dirent *Dirent, err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___READDIR_A<<4, uintptr(dir)) - runtime.ExitSyscall() - dirent = (*Dirent)(unsafe.Pointer(r0)) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -//sys Readdir_r(dirp uintptr, entry *direntLE, result **direntLE) (err error) = SYS___READDIR_R_A -//sys Statfs(path string, buf *Statfs_t) (err error) = SYS___STATFS_A -//sys Syncfs(fd int) (err error) = SYS_SYNCFS //sys Times(tms *Tms) (ticks uintptr, err error) = SYS_TIMES //sys W_Getmntent(buff *byte, size int) (lastsys int, err error) = SYS_W_GETMNTENT //sys W_Getmntent_A(buff *byte, size int) (lastsys int, err error) = SYS___W_GETMNTENT_A //sys mount_LE(path string, filesystem string, fstype string, mtm uint32, parmlen int32, parm string) (err error) = SYS___MOUNT_A -//sys unmount_LE(filesystem string, mtm int) (err error) = SYS___UMOUNT_A +//sys unmount(filesystem string, mtm int) (err error) = SYS___UMOUNT_A //sys Chroot(path string) (err error) = SYS___CHROOT_A //sys Select(nmsgsfds int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (ret int, err error) = SYS_SELECT -//sysnb Uname(buf *Utsname) (err error) = SYS_____OSNAME_A -//sys Unshare(flags int) (err error) = SYS_UNSHARE +//sysnb Uname(buf *Utsname) (err error) = SYS___UNAME_A func Ptsname(fd int) (name string, err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithPtrReturn(GetZosLibVec()+SYS___PTSNAME_A<<4, uintptr(fd)) - runtime.ExitSyscall() - if r0 == 0 { - err = errnoErr2(e1, e2) - } else { - name = u2s(unsafe.Pointer(r0)) + r0, _, e1 := syscall_syscall(SYS___PTSNAME_A, uintptr(fd), 0, 0) + name = u2s(unsafe.Pointer(r0)) + if e1 != 0 { + err = errnoErr(e1) } return } @@ -738,19 +272,13 @@ func u2s(cstr unsafe.Pointer) string { } func Close(fd int) (err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_CLOSE<<4, uintptr(fd)) - runtime.ExitSyscall() + _, _, e1 := syscall_syscall(SYS_CLOSE, uintptr(fd), 0, 0) for i := 0; e1 == EAGAIN && i < 10; i++ { - runtime.EnterSyscall() - CallLeFuncWithErr(GetZosLibVec()+SYS_USLEEP<<4, uintptr(10)) - runtime.ExitSyscall() - runtime.EnterSyscall() - r0, e2, e1 = CallLeFuncWithErr(GetZosLibVec()+SYS_CLOSE<<4, uintptr(fd)) - runtime.ExitSyscall() + _, _, _ = syscall_syscall(SYS_USLEEP, uintptr(10), 0, 0) + _, _, e1 = syscall_syscall(SYS_CLOSE, uintptr(fd), 0, 0) } - if r0 != 0 { - err = errnoErr2(e1, e2) + if e1 != 0 { + err = errnoErr(e1) } return } @@ -760,15 +288,9 @@ func Madvise(b []byte, advice int) (err error) { return } -func Mmap(fd int, offset int64, length int, prot int, flags int) (data []byte, err error) { - return mapper.Mmap(fd, offset, length, prot, flags) -} - -func Munmap(b []byte) (err error) { - return mapper.Munmap(b) -} - //sys Gethostname(buf []byte) (err error) = SYS___GETHOSTNAME_A +//sysnb Getegid() (egid int) +//sysnb Geteuid() (uid int) //sysnb Getgid() (gid int) //sysnb Getpid() (pid int) //sysnb Getpgid(pid int) (pgid int, err error) = SYS_GETPGID @@ -795,14 +317,11 @@ func Getrusage(who int, rusage *Rusage) (err error) { return } -//sys Getegid() (egid int) = SYS_GETEGID -//sys Geteuid() (euid int) = SYS_GETEUID //sysnb Getsid(pid int) (sid int, err error) = SYS_GETSID //sysnb Getuid() (uid int) //sysnb Kill(pid int, sig Signal) (err error) //sys Lchown(path string, uid int, gid int) (err error) = SYS___LCHOWN_A //sys Link(path string, link string) (err error) = SYS___LINK_A -//sys Linkat(oldDirFd int, oldPath string, newDirFd int, newPath string, flags int) (err error) = SYS___LINKAT_A //sys Listen(s int, n int) (err error) //sys lstat(path string, stat *Stat_LE_t) (err error) = SYS___LSTAT_A @@ -813,150 +332,15 @@ func Lstat(path string, stat *Stat_t) (err error) { return } -// 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', '/'}} - - var i, j int - for i = 0; i < len(special); i++ { - for j = 0; j < len(special[i]); j++ { - if path[j] != special[i][j] { - break - } - } - if j == len(special[i]) { - return true - } - } - return false -} - -func realpath(srcpath string, abspath []byte) (pathlen int, errno int) { - var source [1024]byte - copy(source[:], srcpath) - source[len(srcpath)] = 0 - ret := runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS___REALPATH_A<<4, //__realpath_a() - []uintptr{uintptr(unsafe.Pointer(&source[0])), - uintptr(unsafe.Pointer(&abspath[0]))}) - if ret != 0 { - index := bytes.IndexByte(abspath[:], byte(0)) - if index != -1 { - return index, 0 - } - } else { - errptr := (*int)(unsafe.Pointer(runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS___ERRNO<<4, []uintptr{}))) //__errno() - return 0, *errptr - } - return 0, 245 // EBADDATA 245 -} - -func Readlink(path string, buf []byte) (n int, err error) { - var _p0 *byte - _p0, err = BytePtrFromString(path) - if err != nil { - return - } - var _p1 unsafe.Pointer - if len(buf) > 0 { - _p1 = unsafe.Pointer(&buf[0]) - } else { - _p1 = unsafe.Pointer(&_zero) - } - n = int(runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS___READLINK_A<<4, - []uintptr{uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf))})) - runtime.KeepAlive(unsafe.Pointer(_p0)) - if n == -1 { - value := *(*int32)(unsafe.Pointer(runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS___ERRNO<<4, []uintptr{}))) - err = errnoErr(Errno(value)) - } else { - if buf[0] == '$' { - if isSpecialPath(buf[1:9]) { - cnt, err1 := realpath(path, buf) - if err1 == 0 { - n = cnt - } - } - } - } - return -} - -func impl_Readlinkat(dirfd int, path string, buf []byte) (n int, err error) { - var _p0 *byte - _p0, err = BytePtrFromString(path) - if err != nil { - return - } - var _p1 unsafe.Pointer - if len(buf) > 0 { - _p1 = unsafe.Pointer(&buf[0]) - } else { - _p1 = unsafe.Pointer(&_zero) - } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___READLINKAT_A<<4, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf))) - runtime.ExitSyscall() - n = int(r0) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - return n, err - } else { - if buf[0] == '$' { - if isSpecialPath(buf[1:9]) { - cnt, err1 := realpath(path, buf) - if err1 == 0 { - n = cnt - } - } - } - } - return -} - -//go:nosplit -func get_ReadlinkatAddr() *(func(dirfd int, path string, buf []byte) (n int, err error)) - -var Readlinkat = enter_Readlinkat - -func enter_Readlinkat(dirfd int, path string, buf []byte) (n int, err error) { - funcref := get_ReadlinkatAddr() - if funcptrtest(GetZosLibVec()+SYS___READLINKAT_A<<4, "") == 0 { - *funcref = impl_Readlinkat - } else { - *funcref = error_Readlinkat - } - return (*funcref)(dirfd, path, buf) -} - -func error_Readlinkat(dirfd int, path string, buf []byte) (n int, err error) { - n = -1 - err = ENOSYS - return -} - //sys Mkdir(path string, mode uint32) (err error) = SYS___MKDIR_A -//sys Mkdirat(dirfd int, path string, mode uint32) (err error) = SYS___MKDIRAT_A //sys Mkfifo(path string, mode uint32) (err error) = SYS___MKFIFO_A //sys Mknod(path string, mode uint32, dev int) (err error) = SYS___MKNOD_A -//sys Mknodat(dirfd int, path string, mode uint32, dev int) (err error) = SYS___MKNODAT_A -//sys PivotRoot(newroot string, oldroot string) (err error) = SYS___PIVOT_ROOT_A //sys Pread(fd int, p []byte, offset int64) (n int, err error) //sys Pwrite(fd int, p []byte, offset int64) (n int, err error) -//sys Prctl(option int, arg2 uintptr, arg3 uintptr, arg4 uintptr, arg5 uintptr) (err error) = SYS___PRCTL_A -//sysnb Prlimit(pid int, resource int, newlimit *Rlimit, old *Rlimit) (err error) = SYS_PRLIMIT +//sys Readlink(path string, buf []byte) (n int, err error) = SYS___READLINK_A //sys Rename(from string, to string) (err error) = SYS___RENAME_A -//sys Renameat(olddirfd int, oldpath string, newdirfd int, newpath string) (err error) = SYS___RENAMEAT_A -//sys Renameat2(olddirfd int, oldpath string, newdirfd int, newpath string, flags uint) (err error) = SYS___RENAMEAT2_A //sys Rmdir(path string) (err error) = SYS___RMDIR_A //sys Seek(fd int, offset int64, whence int) (off int64, err error) = SYS_LSEEK -//sys Setegid(egid int) (err error) = SYS_SETEGID -//sys Seteuid(euid int) (err error) = SYS_SETEUID -//sys Sethostname(p []byte) (err error) = SYS___SETHOSTNAME_A -//sys Setns(fd int, nstype int) (err error) = SYS_SETNS //sys Setpriority(which int, who int, prio int) (err error) //sysnb Setpgid(pid int, pgid int) (err error) = SYS_SETPGID //sysnb Setrlimit(resource int, lim *Rlimit) (err error) @@ -976,57 +360,32 @@ func Stat(path string, sta *Stat_t) (err error) { } //sys Symlink(path string, link string) (err error) = SYS___SYMLINK_A -//sys Symlinkat(oldPath string, dirfd int, newPath string) (err error) = SYS___SYMLINKAT_A //sys Sync() = SYS_SYNC //sys Truncate(path string, length int64) (err error) = SYS___TRUNCATE_A //sys Tcgetattr(fildes int, termptr *Termios) (err error) = SYS_TCGETATTR //sys Tcsetattr(fildes int, when int, termptr *Termios) (err error) = SYS_TCSETATTR //sys Umask(mask int) (oldmask int) //sys Unlink(path string) (err error) = SYS___UNLINK_A -//sys Unlinkat(dirfd int, path string, flags int) (err error) = SYS___UNLINKAT_A //sys Utime(path string, utim *Utimbuf) (err error) = SYS___UTIME_A //sys open(path string, mode int, perm uint32) (fd int, err error) = SYS___OPEN_A func Open(path string, mode int, perm uint32) (fd int, err error) { - if mode&O_ACCMODE == 0 { - mode |= O_RDONLY - } return open(path, mode, perm) } -//sys openat(dirfd int, path string, flags int, mode uint32) (fd int, err error) = SYS___OPENAT_A - -func Openat(dirfd int, path string, flags int, mode uint32) (fd int, err error) { - if flags&O_ACCMODE == 0 { - flags |= O_RDONLY +func Mkfifoat(dirfd int, path string, mode uint32) (err error) { + wd, err := Getwd() + if err != nil { + return err } - return openat(dirfd, path, flags, mode) -} -//sys openat2(dirfd int, path string, open_how *OpenHow, size int) (fd int, err error) = SYS___OPENAT2_A - -func Openat2(dirfd int, path string, how *OpenHow) (fd int, err error) { - if how.Flags&O_ACCMODE == 0 { - how.Flags |= O_RDONLY + if err := Fchdir(dirfd); err != nil { + return err } - return openat2(dirfd, path, how, SizeofOpenHow) -} + defer Chdir(wd) -func ZosFdToPath(dirfd int) (path string, err error) { - var buffer [1024]byte - runtime.EnterSyscall() - ret, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_W_IOCTL<<4, uintptr(dirfd), 17, 1024, uintptr(unsafe.Pointer(&buffer[0]))) - runtime.ExitSyscall() - if ret == 0 { - zb := bytes.IndexByte(buffer[:], 0) - if zb == -1 { - zb = len(buffer) - } - CallLeFuncWithErr(GetZosLibVec()+SYS___E2A_L<<4, uintptr(unsafe.Pointer(&buffer[0])), uintptr(zb)) - return string(buffer[:zb]), nil - } - return "", errnoErr2(e1, e2) + return Mkfifo(path, mode) } //sys remove(path string) (err error) @@ -1044,12 +403,10 @@ func Getcwd(buf []byte) (n int, err error) { } else { p = unsafe.Pointer(&_zero) } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithPtrReturn(GetZosLibVec()+SYS___GETCWD_A<<4, uintptr(p), uintptr(len(buf))) - runtime.ExitSyscall() + _, _, e := syscall_syscall(SYS___GETCWD_A, uintptr(p), uintptr(len(buf)), 0) n = clen(buf) + 1 - if r0 == 0 { - err = errnoErr2(e1, e2) + if e != 0 { + err = errnoErr(e) } return } @@ -1163,41 +520,9 @@ func (w WaitStatus) StopSignal() Signal { func (w WaitStatus) TrapCause() int { return -1 } -//sys waitid(idType int, id int, info *Siginfo, options int) (err error) - -func Waitid(idType int, id int, info *Siginfo, options int, rusage *Rusage) (err error) { - return waitid(idType, id, info, options) -} - //sys waitpid(pid int, wstatus *_C_int, options int) (wpid int, err error) -func impl_Wait4(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (wpid int, err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_WAIT4<<4, uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options), uintptr(unsafe.Pointer(rusage))) - runtime.ExitSyscall() - wpid = int(r0) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -//go:nosplit -func get_Wait4Addr() *(func(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (wpid int, err error)) - -var Wait4 = enter_Wait4 - -func enter_Wait4(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (wpid int, err error) { - funcref := get_Wait4Addr() - if funcptrtest(GetZosLibVec()+SYS_WAIT4<<4, "") == 0 { - *funcref = impl_Wait4 - } else { - *funcref = legacyWait4 - } - return (*funcref)(pid, wstatus, options, rusage) -} - -func legacyWait4(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (wpid int, err error) { +func Wait4(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (wpid int, err error) { // TODO(mundaym): z/OS doesn't have wait4. I don't think getrusage does what we want. // At the moment rusage will not be touched. var status _C_int @@ -1246,62 +571,23 @@ func Pipe(p []int) (err error) { } var pp [2]_C_int err = pipe(&pp) - p[0] = int(pp[0]) - p[1] = int(pp[1]) + if err == nil { + p[0] = int(pp[0]) + p[1] = int(pp[1]) + } return } //sys utimes(path string, timeval *[2]Timeval) (err error) = SYS___UTIMES_A func Utimes(path string, tv []Timeval) (err error) { - if tv == nil { - return utimes(path, nil) - } if len(tv) != 2 { return EINVAL } return utimes(path, (*[2]Timeval)(unsafe.Pointer(&tv[0]))) } -//sys utimensat(dirfd int, path string, ts *[2]Timespec, flags int) (err error) = SYS___UTIMENSAT_A - -func validUtimensat() bool { - if funcptrtest(GetZosLibVec()+SYS___UTIMENSAT_A<<4, "") == 0 { - if name, err := getLeFuncName(GetZosLibVec() + SYS___UTIMENSAT_A<<4); err == nil { - return name == "__utimensat_a" - } - } - return false -} - -// Begin UtimesNano - -//go:nosplit -func get_UtimesNanoAddr() *(func(path string, ts []Timespec) (err error)) - -var UtimesNano = enter_UtimesNano - -func enter_UtimesNano(path string, ts []Timespec) (err error) { - funcref := get_UtimesNanoAddr() - if validUtimensat() { - *funcref = utimesNanoImpl - } else { - *funcref = legacyUtimesNano - } - return (*funcref)(path, ts) -} - -func utimesNanoImpl(path string, ts []Timespec) (err error) { - if ts == nil { - return utimensat(AT_FDCWD, path, nil, 0) - } - if len(ts) != 2 { - return EINVAL - } - return utimensat(AT_FDCWD, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), 0) -} - -func legacyUtimesNano(path string, ts []Timespec) (err error) { +func UtimesNano(path string, ts []Timespec) error { if len(ts) != 2 { return EINVAL } @@ -1314,70 +600,6 @@ func legacyUtimesNano(path string, ts []Timespec) (err error) { return utimes(path, (*[2]Timeval)(unsafe.Pointer(&tv[0]))) } -// End UtimesNano - -// Begin UtimesNanoAt - -//go:nosplit -func get_UtimesNanoAtAddr() *(func(dirfd int, path string, ts []Timespec, flags int) (err error)) - -var UtimesNanoAt = enter_UtimesNanoAt - -func enter_UtimesNanoAt(dirfd int, path string, ts []Timespec, flags int) (err error) { - funcref := get_UtimesNanoAtAddr() - if validUtimensat() { - *funcref = utimesNanoAtImpl - } else { - *funcref = legacyUtimesNanoAt - } - return (*funcref)(dirfd, path, ts, flags) -} - -func utimesNanoAtImpl(dirfd int, path string, ts []Timespec, flags int) (err error) { - if ts == nil { - return utimensat(dirfd, path, nil, flags) - } - if len(ts) != 2 { - return EINVAL - } - return utimensat(dirfd, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), flags) -} - -func legacyUtimesNanoAt(dirfd int, path string, ts []Timespec, flags int) (err error) { - if path[0] != '/' { - dirPath, err := ZosFdToPath(dirfd) - if err != nil { - return err - } - path = dirPath + "/" + path - } - if flags == AT_SYMLINK_NOFOLLOW { - if len(ts) != 2 { - return EINVAL - } - - if ts[0].Nsec >= 5e8 { - ts[0].Sec++ - } - ts[0].Nsec = 0 - if ts[1].Nsec >= 5e8 { - ts[1].Sec++ - } - ts[1].Nsec = 0 - - // Not as efficient as it could be because Timespec and - // Timeval have different types in the different OSes - tv := []Timeval{ - NsecToTimeval(TimespecToNsec(ts[0])), - NsecToTimeval(TimespecToNsec(ts[1])), - } - return Lutimes(path, tv) - } - return UtimesNano(path, ts) -} - -// End UtimesNanoAt - func Getsockname(fd int) (sa Sockaddr, err error) { var rsa RawSockaddrAny var len _Socklen = SizeofSockaddrAny @@ -1969,41 +1191,62 @@ func Opendir(name string) (uintptr, error) { if err != nil { return 0, err } - err = nil - runtime.EnterSyscall() - dir, e2, e1 := CallLeFuncWithPtrReturn(GetZosLibVec()+SYS___OPENDIR_A<<4, uintptr(unsafe.Pointer(p))) - runtime.ExitSyscall() - runtime.KeepAlive(unsafe.Pointer(p)) - if dir == 0 { - err = errnoErr2(e1, e2) + dir, _, e := syscall_syscall(SYS___OPENDIR_A, uintptr(unsafe.Pointer(p)), 0, 0) + runtime.KeepAlive(unsafe.Pointer(p)) + if e != 0 { + err = errnoErr(e) + } + return dir, err +} + +// clearsyscall.Errno resets the errno value to 0. +func clearErrno() + +func Readdir(dir uintptr) (*Dirent, error) { + var ent Dirent + var res uintptr + // __readdir_r_a returns errno at the end of the directory stream, rather than 0. + // Therefore to avoid false positives we clear errno before calling it. + + // TODO(neeilan): Commented this out to get sys/unix compiling on z/OS. Uncomment and fix. Error: "undefined: clearsyscall" + //clearsyscall.Errno() // TODO(mundaym): check pre-emption rules. + + e, _, _ := syscall_syscall(SYS___READDIR_R_A, dir, uintptr(unsafe.Pointer(&ent)), uintptr(unsafe.Pointer(&res))) + var err error + if e != 0 { + err = errnoErr(Errno(e)) + } + if res == 0 { + return nil, err } - return dir, err + return &ent, err } -// clearsyscall.Errno resets the errno value to 0. -func clearErrno() +func readdir_r(dirp uintptr, entry *direntLE, result **direntLE) (err error) { + r0, _, e1 := syscall_syscall(SYS___READDIR_R_A, dirp, uintptr(unsafe.Pointer(entry)), uintptr(unsafe.Pointer(result))) + if int64(r0) == -1 { + err = errnoErr(Errno(e1)) + } + return +} func Closedir(dir uintptr) error { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_CLOSEDIR<<4, dir) - runtime.ExitSyscall() - if r0 != 0 { - return errnoErr2(e1, e2) + _, _, e := syscall_syscall(SYS_CLOSEDIR, dir, 0, 0) + if e != 0 { + return errnoErr(e) } return nil } func Seekdir(dir uintptr, pos int) { - runtime.EnterSyscall() - CallLeFuncWithErr(GetZosLibVec()+SYS_SEEKDIR<<4, dir, uintptr(pos)) - runtime.ExitSyscall() + _, _, _ = syscall_syscall(SYS_SEEKDIR, dir, uintptr(pos), 0) } func Telldir(dir uintptr) (int, error) { - p, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_TELLDIR<<4, dir) + p, _, e := syscall_syscall(SYS_TELLDIR, dir, 0, 0) pos := int(p) - if int64(p) == -1 { - return pos, errnoErr2(e1, e2) + if pos == -1 { + return pos, errnoErr(e) } return pos, nil } @@ -2018,55 +1261,19 @@ func FcntlFlock(fd uintptr, cmd int, lk *Flock_t) error { *(*int64)(unsafe.Pointer(&flock[4])) = lk.Start *(*int64)(unsafe.Pointer(&flock[12])) = lk.Len *(*int32)(unsafe.Pointer(&flock[20])) = lk.Pid - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_FCNTL<<4, fd, uintptr(cmd), uintptr(unsafe.Pointer(&flock))) - runtime.ExitSyscall() + _, _, errno := syscall_syscall(SYS_FCNTL, fd, uintptr(cmd), uintptr(unsafe.Pointer(&flock))) lk.Type = *(*int16)(unsafe.Pointer(&flock[0])) lk.Whence = *(*int16)(unsafe.Pointer(&flock[2])) lk.Start = *(*int64)(unsafe.Pointer(&flock[4])) lk.Len = *(*int64)(unsafe.Pointer(&flock[12])) lk.Pid = *(*int32)(unsafe.Pointer(&flock[20])) - if r0 == 0 { + if errno == 0 { return nil } - return errnoErr2(e1, e2) -} - -func impl_Flock(fd int, how int) (err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_FLOCK<<4, uintptr(fd), uintptr(how)) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -//go:nosplit -func get_FlockAddr() *(func(fd int, how int) (err error)) - -var Flock = enter_Flock - -func validFlock(fp uintptr) bool { - if funcptrtest(GetZosLibVec()+SYS_FLOCK<<4, "") == 0 { - if name, err := getLeFuncName(GetZosLibVec() + SYS_FLOCK<<4); err == nil { - return name == "flock" - } - } - return false -} - -func enter_Flock(fd int, how int) (err error) { - funcref := get_FlockAddr() - if validFlock(GetZosLibVec() + SYS_FLOCK<<4) { - *funcref = impl_Flock - } else { - *funcref = legacyFlock - } - return (*funcref)(fd, how) + return errno } -func legacyFlock(fd int, how int) error { +func Flock(fd int, how int) error { var flock_type int16 var fcntl_cmd int @@ -2100,51 +1307,41 @@ func legacyFlock(fd int, how int) error { } func Mlock(b []byte) (err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___MLOCKALL<<4, _BPX_NONSWAP) - runtime.ExitSyscall() - if r0 != 0 { - err = errnoErr2(e1, e2) + _, _, e1 := syscall_syscall(SYS___MLOCKALL, _BPX_NONSWAP, 0, 0) + if e1 != 0 { + err = errnoErr(e1) } return } func Mlock2(b []byte, flags int) (err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___MLOCKALL<<4, _BPX_NONSWAP) - runtime.ExitSyscall() - if r0 != 0 { - err = errnoErr2(e1, e2) + _, _, e1 := syscall_syscall(SYS___MLOCKALL, _BPX_NONSWAP, 0, 0) + if e1 != 0 { + err = errnoErr(e1) } return } func Mlockall(flags int) (err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___MLOCKALL<<4, _BPX_NONSWAP) - runtime.ExitSyscall() - if r0 != 0 { - err = errnoErr2(e1, e2) + _, _, e1 := syscall_syscall(SYS___MLOCKALL, _BPX_NONSWAP, 0, 0) + if e1 != 0 { + err = errnoErr(e1) } return } func Munlock(b []byte) (err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___MLOCKALL<<4, _BPX_SWAP) - runtime.ExitSyscall() - if r0 != 0 { - err = errnoErr2(e1, e2) + _, _, e1 := syscall_syscall(SYS___MLOCKALL, _BPX_SWAP, 0, 0) + if e1 != 0 { + err = errnoErr(e1) } return } func Munlockall() (err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___MLOCKALL<<4, _BPX_SWAP) - runtime.ExitSyscall() - if r0 != 0 { - err = errnoErr2(e1, e2) + _, _, e1 := syscall_syscall(SYS___MLOCKALL, _BPX_SWAP, 0, 0) + if e1 != 0 { + err = errnoErr(e1) } return } @@ -2175,104 +1372,15 @@ func ClockGettime(clockid int32, ts *Timespec) error { return nil } -// Chtag - -//go:nosplit -func get_ChtagAddr() *(func(path string, ccsid uint64, textbit uint64) error) - -var Chtag = enter_Chtag - -func enter_Chtag(path string, ccsid uint64, textbit uint64) error { - funcref := get_ChtagAddr() - if validSetxattr() { - *funcref = impl_Chtag - } else { - *funcref = legacy_Chtag - } - return (*funcref)(path, ccsid, textbit) -} - -func legacy_Chtag(path string, ccsid uint64, textbit uint64) error { - tag := ccsid<<16 | textbit<<15 - var tag_buff [8]byte - DecodeData(tag_buff[:], 8, tag) - return Setxattr(path, "filetag", tag_buff[:], XATTR_REPLACE) -} - -func impl_Chtag(path string, ccsid uint64, textbit uint64) error { - tag := ccsid<<16 | textbit<<15 - var tag_buff [4]byte - DecodeData(tag_buff[:], 4, tag) - return Setxattr(path, "system.filetag", tag_buff[:], XATTR_REPLACE) -} - -// End of Chtag - -// Nanosleep - -//go:nosplit -func get_NanosleepAddr() *(func(time *Timespec, leftover *Timespec) error) - -var Nanosleep = enter_Nanosleep - -func enter_Nanosleep(time *Timespec, leftover *Timespec) error { - funcref := get_NanosleepAddr() - if funcptrtest(GetZosLibVec()+SYS_NANOSLEEP<<4, "") == 0 { - *funcref = impl_Nanosleep - } else { - *funcref = legacyNanosleep - } - return (*funcref)(time, leftover) -} - -func impl_Nanosleep(time *Timespec, leftover *Timespec) error { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_NANOSLEEP<<4, uintptr(unsafe.Pointer(time)), uintptr(unsafe.Pointer(leftover))) - runtime.ExitSyscall() - if int64(r0) == -1 { - return errnoErr2(e1, e2) - } - return nil -} - -func legacyNanosleep(time *Timespec, leftover *Timespec) error { - t0 := runtime.Nanotime1() - var secrem uint32 - var nsecrem uint32 - total := time.Sec*1000000000 + time.Nsec - elapsed := runtime.Nanotime1() - t0 - var rv int32 - var rc int32 - var err error - // repeatedly sleep for 1 second until less than 1 second left - for total-elapsed > 1000000000 { - rv, rc, _ = BpxCondTimedWait(uint32(1), uint32(0), uint32(CW_CONDVAR), &secrem, &nsecrem) - if rv != 0 && rc != 112 { // 112 is EAGAIN - if leftover != nil && rc == 120 { // 120 is EINTR - leftover.Sec = int64(secrem) - leftover.Nsec = int64(nsecrem) - } - err = Errno(rc) - return err - } - elapsed = runtime.Nanotime1() - t0 - } - // sleep the remainder - if total > elapsed { - rv, rc, _ = BpxCondTimedWait(uint32(0), uint32(total-elapsed), uint32(CW_CONDVAR), &secrem, &nsecrem) - } - if leftover != nil && rc == 120 { - leftover.Sec = int64(secrem) - leftover.Nsec = int64(nsecrem) - } - if rv != 0 && rc != 112 { - err = Errno(rc) +func Statfs(path string, stat *Statfs_t) (err error) { + fd, err := open(path, O_RDONLY, 0) + defer Close(fd) + if err != nil { + return err } - return err + return Fstatfs(fd, stat) } -// End of Nanosleep - var ( Stdin = 0 Stdout = 1 @@ -2287,9 +1395,6 @@ var ( errENOENT error = syscall.ENOENT ) -var ZosTraceLevel int -var ZosTracefile *os.File - var ( signalNameMapOnce sync.Once signalNameMap map[string]syscall.Signal @@ -2311,56 +1416,6 @@ func errnoErr(e Errno) error { return e } -var reg *regexp.Regexp - -// enhanced with zos specific errno2 -func errnoErr2(e Errno, e2 uintptr) error { - switch e { - case 0: - return nil - case EAGAIN: - return errEAGAIN - /* - Allow the retrieval of errno2 for EINVAL and ENOENT on zos - case EINVAL: - return errEINVAL - case ENOENT: - return errENOENT - */ - } - if ZosTraceLevel > 0 { - var name string - if reg == nil { - reg = regexp.MustCompile("(^unix\\.[^/]+$|.*\\/unix\\.[^/]+$)") - } - i := 1 - pc, file, line, ok := runtime.Caller(i) - if ok { - name = runtime.FuncForPC(pc).Name() - } - for ok && reg.MatchString(runtime.FuncForPC(pc).Name()) { - i += 1 - pc, file, line, ok = runtime.Caller(i) - } - if ok { - if ZosTracefile == nil { - ZosConsolePrintf("From %s:%d\n", file, line) - ZosConsolePrintf("%s: %s (errno2=0x%x)\n", name, e.Error(), e2) - } else { - fmt.Fprintf(ZosTracefile, "From %s:%d\n", file, line) - fmt.Fprintf(ZosTracefile, "%s: %s (errno2=0x%x)\n", name, e.Error(), e2) - } - } else { - if ZosTracefile == nil { - ZosConsolePrintf("%s (errno2=0x%x)\n", e.Error(), e2) - } else { - fmt.Fprintf(ZosTracefile, "%s (errno2=0x%x)\n", e.Error(), e2) - } - } - } - return e -} - // ErrnoName returns the error name for error number e. func ErrnoName(e Errno) string { i := sort.Search(len(errorList), func(i int) bool { @@ -2419,9 +1474,6 @@ func (m *mmapper) Mmap(fd int, offset int64, length int, prot int, flags int) (d return nil, EINVAL } - // Set __MAP_64 by default - flags |= __MAP_64 - // Map the requested memory. addr, errno := m.mmap(0, uintptr(length), prot, flags, fd, offset) if errno != nil { @@ -2726,170 +1778,83 @@ func Exec(argv0 string, argv []string, envv []string) error { return syscall.Exec(argv0, argv, envv) } -func Getag(path string) (ccsid uint16, flag uint16, err error) { - var val [8]byte - sz, err := Getxattr(path, "ccsid", val[:]) - if err != nil { - return - } - ccsid = uint16(EncodeData(val[0:sz])) - sz, err = Getxattr(path, "flags", val[:]) - if err != nil { - return - } - flag = uint16(EncodeData(val[0:sz]) >> 15) - return -} - -// Mount begin -func impl_Mount(source string, target string, fstype string, flags uintptr, data string) (err error) { - var _p0 *byte - _p0, err = BytePtrFromString(source) - if err != nil { - return - } - var _p1 *byte - _p1, err = BytePtrFromString(target) - if err != nil { - return - } - var _p2 *byte - _p2, err = BytePtrFromString(fstype) - if err != nil { - return - } - var _p3 *byte - _p3, err = BytePtrFromString(data) - if err != nil { - return - } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___MOUNT1_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(unsafe.Pointer(_p2)), uintptr(flags), uintptr(unsafe.Pointer(_p3))) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -//go:nosplit -func get_MountAddr() *(func(source string, target string, fstype string, flags uintptr, data string) (err error)) - -var Mount = enter_Mount - -func enter_Mount(source string, target string, fstype string, flags uintptr, data string) (err error) { - funcref := get_MountAddr() - if validMount() { - *funcref = impl_Mount - } else { - *funcref = legacyMount - } - return (*funcref)(source, target, fstype, flags, data) -} - -func legacyMount(source string, target string, fstype string, flags uintptr, data string) (err error) { +func Mount(source string, target string, fstype string, flags uintptr, data string) (err error) { if needspace := 8 - len(fstype); needspace <= 0 { - fstype = fstype[0:8] + fstype = fstype[:8] } else { - fstype += " "[0:needspace] + fstype += " "[:needspace] } return mount_LE(target, source, fstype, uint32(flags), int32(len(data)), data) } -func validMount() bool { - if funcptrtest(GetZosLibVec()+SYS___MOUNT1_A<<4, "") == 0 { - if name, err := getLeFuncName(GetZosLibVec() + SYS___MOUNT1_A<<4); err == nil { - return name == "__mount1_a" - } - } - return false -} - -// Mount end - -// Unmount begin -func impl_Unmount(target string, flags int) (err error) { - var _p0 *byte - _p0, err = BytePtrFromString(target) - if err != nil { - return - } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___UMOUNT2_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(flags)) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -//go:nosplit -func get_UnmountAddr() *(func(target string, flags int) (err error)) - -var Unmount = enter_Unmount - -func enter_Unmount(target string, flags int) (err error) { - funcref := get_UnmountAddr() - if funcptrtest(GetZosLibVec()+SYS___UMOUNT2_A<<4, "") == 0 { - *funcref = impl_Unmount - } else { - *funcref = legacyUnmount - } - return (*funcref)(target, flags) -} - -func legacyUnmount(name string, mtm int) (err error) { +func Unmount(name string, mtm int) (err error) { // mountpoint is always a full path and starts with a '/' // check if input string is not a mountpoint but a filesystem name if name[0] != '/' { - return unmount_LE(name, mtm) + return unmount(name, mtm) } // treat name as mountpoint b2s := func(arr []byte) string { - var str string - for i := 0; i < len(arr); i++ { - if arr[i] == 0 { - str = string(arr[:i]) - break - } + nulli := bytes.IndexByte(arr, 0) + if nulli == -1 { + return string(arr) + } else { + return string(arr[:nulli]) } - return str } var buffer struct { header W_Mnth fsinfo [64]W_Mntent } - fs_count, err := W_Getmntent_A((*byte)(unsafe.Pointer(&buffer)), int(unsafe.Sizeof(buffer))) - if err == nil { - err = EINVAL - for i := 0; i < fs_count; i++ { - if b2s(buffer.fsinfo[i].Mountpoint[:]) == name { - err = unmount_LE(b2s(buffer.fsinfo[i].Fsname[:]), mtm) - break - } + fsCount, err := W_Getmntent_A((*byte)(unsafe.Pointer(&buffer)), int(unsafe.Sizeof(buffer))) + if err != nil { + return err + } + if fsCount == 0 { + return EINVAL + } + for i := 0; i < fsCount; i++ { + if b2s(buffer.fsinfo[i].Mountpoint[:]) == name { + err = unmount(b2s(buffer.fsinfo[i].Fsname[:]), mtm) + break } - } else if fs_count == 0 { - err = EINVAL } return err } -// Unmount end - -func direntIno(buf []byte) (uint64, bool) { - return readInt(buf, unsafe.Offsetof(Dirent{}.Ino), unsafe.Sizeof(Dirent{}.Ino)) -} - -func direntReclen(buf []byte) (uint64, bool) { - return readInt(buf, unsafe.Offsetof(Dirent{}.Reclen), unsafe.Sizeof(Dirent{}.Reclen)) -} - -func direntNamlen(buf []byte) (uint64, bool) { - reclen, ok := direntReclen(buf) - if !ok { - return 0, false +func fdToPath(dirfd int) (path string, err error) { + var buffer [1024]byte + // w_ctrl() + ret := runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS_W_IOCTL<<4, + []uintptr{uintptr(dirfd), 17, 1024, uintptr(unsafe.Pointer(&buffer[0]))}) + if ret == 0 { + zb := bytes.IndexByte(buffer[:], 0) + if zb == -1 { + zb = len(buffer) + } + // __e2a_l() + runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS___E2A_L<<4, + []uintptr{uintptr(unsafe.Pointer(&buffer[0])), uintptr(zb)}) + return string(buffer[:zb]), nil + } + // __errno() + errno := int(*(*int32)(unsafe.Pointer(runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS___ERRNO<<4, + []uintptr{})))) + // __errno2() + errno2 := int(runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS___ERRNO2<<4, + []uintptr{})) + // strerror_r() + ret = runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS_STRERROR_R<<4, + []uintptr{uintptr(errno), uintptr(unsafe.Pointer(&buffer[0])), 1024}) + if ret == 0 { + zb := bytes.IndexByte(buffer[:], 0) + if zb == -1 { + zb = len(buffer) + } + return "", fmt.Errorf("%s (errno2=0x%x)", buffer[:zb], errno2) + } else { + return "", fmt.Errorf("fdToPath errno %d (errno2=0x%x)", errno, errno2) } - return reclen - uint64(unsafe.Offsetof(Dirent{}.Name)), true } func direntLeToDirentUnix(dirent *direntLE, dir uintptr, path string) (Dirent, error) { @@ -2931,7 +1896,7 @@ func Getdirentries(fd int, buf []byte, basep *uintptr) (n int, err error) { } // Get path from fd to avoid unavailable call (fdopendir) - path, err := ZosFdToPath(fd) + path, err := fdToPath(fd) if err != nil { return 0, err } @@ -2945,7 +1910,7 @@ func Getdirentries(fd int, buf []byte, basep *uintptr) (n int, err error) { for { var entryLE direntLE var entrypLE *direntLE - e := Readdir_r(d, &entryLE, &entrypLE) + e := readdir_r(d, &entryLE, &entrypLE) if e != nil { return n, e } @@ -2991,127 +1956,23 @@ func Getdirentries(fd int, buf []byte, basep *uintptr) (n int, err error) { return n, nil } -func Err2ad() (eadd *int) { - r0, _, _ := CallLeFuncWithErr(GetZosLibVec() + SYS___ERR2AD<<4) - eadd = (*int)(unsafe.Pointer(r0)) - return -} - -func ZosConsolePrintf(format string, v ...interface{}) (int, error) { - type __cmsg struct { - _ uint16 - _ [2]uint8 - __msg_length uint32 - __msg uintptr - _ [4]uint8 - } - msg := fmt.Sprintf(format, v...) - strptr := unsafe.Pointer((*reflect.StringHeader)(unsafe.Pointer(&msg)).Data) - len := (*reflect.StringHeader)(unsafe.Pointer(&msg)).Len - cmsg := __cmsg{__msg_length: uint32(len), __msg: uintptr(strptr)} - cmd := uint32(0) - runtime.EnterSyscall() - rc, err2, err1 := CallLeFuncWithErr(GetZosLibVec()+SYS_____CONSOLE_A<<4, uintptr(unsafe.Pointer(&cmsg)), 0, uintptr(unsafe.Pointer(&cmd))) - runtime.ExitSyscall() - if rc != 0 { - return 0, fmt.Errorf("%s (errno2=0x%x)\n", err1.Error(), err2) - } - return 0, nil -} -func ZosStringToEbcdicBytes(str string, nullterm bool) (ebcdicBytes []byte) { - if nullterm { - ebcdicBytes = []byte(str + "\x00") - } else { - ebcdicBytes = []byte(str) - } - A2e(ebcdicBytes) - return -} -func ZosEbcdicBytesToString(b []byte, trimRight bool) (str string) { - res := make([]byte, len(b)) - copy(res, b) - E2a(res) - if trimRight { - str = string(bytes.TrimRight(res, " \x00")) - } else { - str = string(res) - } - return -} - -func fdToPath(dirfd int) (path string, err error) { - var buffer [1024]byte - // w_ctrl() - ret := runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS_W_IOCTL<<4, - []uintptr{uintptr(dirfd), 17, 1024, uintptr(unsafe.Pointer(&buffer[0]))}) - if ret == 0 { - zb := bytes.IndexByte(buffer[:], 0) - if zb == -1 { - zb = len(buffer) - } - // __e2a_l() - runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS___E2A_L<<4, - []uintptr{uintptr(unsafe.Pointer(&buffer[0])), uintptr(zb)}) - return string(buffer[:zb]), nil - } - // __errno() - errno := int(*(*int32)(unsafe.Pointer(runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS___ERRNO<<4, - []uintptr{})))) - // __errno2() - errno2 := int(runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS___ERRNO2<<4, - []uintptr{})) - // strerror_r() - ret = runtime.CallLeFuncByPtr(runtime.XplinkLibvec+SYS_STRERROR_R<<4, - []uintptr{uintptr(errno), uintptr(unsafe.Pointer(&buffer[0])), 1024}) - if ret == 0 { - zb := bytes.IndexByte(buffer[:], 0) - if zb == -1 { - zb = len(buffer) - } - return "", fmt.Errorf("%s (errno2=0x%x)", buffer[:zb], errno2) - } else { - return "", fmt.Errorf("fdToPath errno %d (errno2=0x%x)", errno, errno2) - } +func ReadDirent(fd int, buf []byte) (n int, err error) { + var base = (*uintptr)(unsafe.Pointer(new(uint64))) + return Getdirentries(fd, buf, base) } -func impl_Mkfifoat(dirfd int, path string, mode uint32) (err error) { - var _p0 *byte - _p0, err = BytePtrFromString(path) - if err != nil { - return - } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___MKFIFOAT_A<<4, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode)) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return +func direntIno(buf []byte) (uint64, bool) { + return readInt(buf, unsafe.Offsetof(Dirent{}.Ino), unsafe.Sizeof(Dirent{}.Ino)) } -//go:nosplit -func get_MkfifoatAddr() *(func(dirfd int, path string, mode uint32) (err error)) - -var Mkfifoat = enter_Mkfifoat - -func enter_Mkfifoat(dirfd int, path string, mode uint32) (err error) { - funcref := get_MkfifoatAddr() - if funcptrtest(GetZosLibVec()+SYS___MKFIFOAT_A<<4, "") == 0 { - *funcref = impl_Mkfifoat - } else { - *funcref = legacy_Mkfifoat - } - return (*funcref)(dirfd, path, mode) +func direntReclen(buf []byte) (uint64, bool) { + return readInt(buf, unsafe.Offsetof(Dirent{}.Reclen), unsafe.Sizeof(Dirent{}.Reclen)) } -func legacy_Mkfifoat(dirfd int, path string, mode uint32) (err error) { - dirname, err := ZosFdToPath(dirfd) - if err != nil { - return err +func direntNamlen(buf []byte) (uint64, bool) { + reclen, ok := direntReclen(buf) + if !ok { + return 0, false } - return Mkfifo(dirname+"/"+path, mode) + return reclen - uint64(unsafe.Offsetof(Dirent{}.Name)), true } - -//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 diff --git a/services/vendor/golang.org/x/sys/unix/sysvshm_unix.go b/services/vendor/golang.org/x/sys/unix/sysvshm_unix.go index 672d6b0a..79a84f18 100644 --- a/services/vendor/golang.org/x/sys/unix/sysvshm_unix.go +++ b/services/vendor/golang.org/x/sys/unix/sysvshm_unix.go @@ -2,7 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. -//go:build (darwin && !ios) || linux || zos +//go:build (darwin && !ios) || linux package unix diff --git a/services/vendor/golang.org/x/sys/unix/sysvshm_unix_other.go b/services/vendor/golang.org/x/sys/unix/sysvshm_unix_other.go index 8b7977a2..9eb0db66 100644 --- a/services/vendor/golang.org/x/sys/unix/sysvshm_unix_other.go +++ b/services/vendor/golang.org/x/sys/unix/sysvshm_unix_other.go @@ -2,7 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. -//go:build (darwin && !ios) || zos +//go:build darwin && !ios package unix diff --git a/services/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go b/services/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go index 4308ac17..e40fa852 100644 --- a/services/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go +++ b/services/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go @@ -1169,11 +1169,6 @@ const ( PT_WRITE_D = 0x5 PT_WRITE_I = 0x4 PT_WRITE_U = 0x6 - RENAME_EXCL = 0x4 - RENAME_NOFOLLOW_ANY = 0x10 - RENAME_RESERVED1 = 0x8 - RENAME_SECLUDE = 0x1 - RENAME_SWAP = 0x2 RLIMIT_AS = 0x5 RLIMIT_CORE = 0x4 RLIMIT_CPU = 0x0 diff --git a/services/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go b/services/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go index c8068a7a..bb02aa6c 100644 --- a/services/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go +++ b/services/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go @@ -1169,11 +1169,6 @@ const ( PT_WRITE_D = 0x5 PT_WRITE_I = 0x4 PT_WRITE_U = 0x6 - RENAME_EXCL = 0x4 - RENAME_NOFOLLOW_ANY = 0x10 - RENAME_RESERVED1 = 0x8 - RENAME_SECLUDE = 0x1 - RENAME_SWAP = 0x2 RLIMIT_AS = 0x5 RLIMIT_CORE = 0x4 RLIMIT_CPU = 0x0 diff --git a/services/vendor/golang.org/x/sys/unix/zerrors_linux.go b/services/vendor/golang.org/x/sys/unix/zerrors_linux.go index 01a70b24..36bf8399 100644 --- a/services/vendor/golang.org/x/sys/unix/zerrors_linux.go +++ b/services/vendor/golang.org/x/sys/unix/zerrors_linux.go @@ -457,7 +457,6 @@ const ( B600 = 0x8 B75 = 0x2 B9600 = 0xd - BCACHEFS_SUPER_MAGIC = 0xca451a4e BDEVFS_MAGIC = 0x62646576 BINDERFS_SUPER_MAGIC = 0x6c6f6f70 BINFMTFS_MAGIC = 0x42494e4d @@ -492,7 +491,6 @@ const ( 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_STATE_FREQ = 0x8 @@ -503,7 +501,6 @@ const ( BPF_IMM = 0x0 BPF_IND = 0x40 BPF_JA = 0x0 - BPF_JCOND = 0xe0 BPF_JEQ = 0x10 BPF_JGE = 0x30 BPF_JGT = 0x20 @@ -659,9 +656,6 @@ const ( CAN_NPROTO = 0x8 CAN_RAW = 0x1 CAN_RAW_FILTER_MAX = 0x200 - CAN_RAW_XL_VCID_RX_FILTER = 0x4 - CAN_RAW_XL_VCID_TX_PASS = 0x2 - CAN_RAW_XL_VCID_TX_SET = 0x1 CAN_RTR_FLAG = 0x40000000 CAN_SFF_ID_BITS = 0xb CAN_SFF_MASK = 0x7ff @@ -929,7 +923,6 @@ const ( EPOLL_CTL_ADD = 0x1 EPOLL_CTL_DEL = 0x2 EPOLL_CTL_MOD = 0x3 - EPOLL_IOC_TYPE = 0x8a EROFS_SUPER_MAGIC_V1 = 0xe0f5e1e2 ESP_V4_FLOW = 0xa ESP_V6_FLOW = 0xc @@ -943,6 +936,9 @@ const ( ETHTOOL_FEC_OFF = 0x4 ETHTOOL_FEC_RS = 0x8 ETHTOOL_FLAG_ALL = 0x7 + ETHTOOL_FLAG_COMPACT_BITSETS = 0x1 + ETHTOOL_FLAG_OMIT_REPLY = 0x2 + ETHTOOL_FLAG_STATS = 0x4 ETHTOOL_FLASHDEV = 0x33 ETHTOOL_FLASH_MAX_FILENAME = 0x80 ETHTOOL_FWVERS_LEN = 0x20 @@ -1342,7 +1338,6 @@ const ( F_OFD_SETLK = 0x25 F_OFD_SETLKW = 0x26 F_OK = 0x0 - F_SEAL_EXEC = 0x20 F_SEAL_FUTURE_WRITE = 0x10 F_SEAL_GROW = 0x4 F_SEAL_SEAL = 0x1 @@ -1631,7 +1626,6 @@ const ( IP_FREEBIND = 0xf IP_HDRINCL = 0x3 IP_IPSEC_POLICY = 0x10 - IP_LOCAL_PORT_RANGE = 0x33 IP_MAXPACKET = 0xffff IP_MAX_MEMBERSHIPS = 0x14 IP_MF = 0x2000 @@ -1658,7 +1652,6 @@ const ( IP_PMTUDISC_OMIT = 0x5 IP_PMTUDISC_PROBE = 0x3 IP_PMTUDISC_WANT = 0x1 - IP_PROTOCOL = 0x34 IP_RECVERR = 0xb IP_RECVERR_RFC4884 = 0x1a IP_RECVFRAGSIZE = 0x19 @@ -1704,8 +1697,6 @@ const ( KEXEC_ARCH_S390 = 0x160000 KEXEC_ARCH_SH = 0x2a0000 KEXEC_ARCH_X86_64 = 0x3e0000 - KEXEC_CRASH_HOTPLUG_SUPPORT = 0x8 - KEXEC_FILE_DEBUG = 0x8 KEXEC_FILE_NO_INITRAMFS = 0x4 KEXEC_FILE_ON_CRASH = 0x2 KEXEC_FILE_UNLOAD = 0x1 @@ -1780,7 +1771,6 @@ const ( KEY_SPEC_USER_KEYRING = -0x4 KEY_SPEC_USER_SESSION_KEYRING = -0x5 LANDLOCK_ACCESS_FS_EXECUTE = 0x1 - LANDLOCK_ACCESS_FS_IOCTL_DEV = 0x8000 LANDLOCK_ACCESS_FS_MAKE_BLOCK = 0x800 LANDLOCK_ACCESS_FS_MAKE_CHAR = 0x40 LANDLOCK_ACCESS_FS_MAKE_DIR = 0x80 @@ -1862,19 +1852,6 @@ const ( MAP_FILE = 0x0 MAP_FIXED = 0x10 MAP_FIXED_NOREPLACE = 0x100000 - MAP_HUGE_16GB = 0x88000000 - MAP_HUGE_16KB = 0x38000000 - MAP_HUGE_16MB = 0x60000000 - MAP_HUGE_1GB = 0x78000000 - MAP_HUGE_1MB = 0x50000000 - MAP_HUGE_256MB = 0x70000000 - MAP_HUGE_2GB = 0x7c000000 - MAP_HUGE_2MB = 0x54000000 - MAP_HUGE_32MB = 0x64000000 - MAP_HUGE_512KB = 0x4c000000 - MAP_HUGE_512MB = 0x74000000 - MAP_HUGE_64KB = 0x40000000 - MAP_HUGE_8MB = 0x5c000000 MAP_HUGE_MASK = 0x3f MAP_HUGE_SHIFT = 0x1a MAP_PRIVATE = 0x2 @@ -1921,7 +1898,6 @@ const ( MNT_DETACH = 0x2 MNT_EXPIRE = 0x4 MNT_FORCE = 0x1 - MNT_ID_REQ_SIZE_VER0 = 0x18 MODULE_INIT_COMPRESSED_FILE = 0x4 MODULE_INIT_IGNORE_MODVERSIONS = 0x1 MODULE_INIT_IGNORE_VERMAGIC = 0x2 @@ -2190,7 +2166,7 @@ const ( NFT_SECMARK_CTX_MAXLEN = 0x100 NFT_SET_MAXNAMELEN = 0x100 NFT_SOCKET_MAX = 0x3 - NFT_TABLE_F_MASK = 0x7 + NFT_TABLE_F_MASK = 0x3 NFT_TABLE_MAXNAMELEN = 0x100 NFT_TRACETYPE_MAX = 0x3 NFT_TUNNEL_F_MASK = 0x7 @@ -2326,7 +2302,6 @@ const ( PERF_AUX_FLAG_PARTIAL = 0x4 PERF_AUX_FLAG_PMU_FORMAT_TYPE_MASK = 0xff00 PERF_AUX_FLAG_TRUNCATED = 0x1 - PERF_BRANCH_ENTRY_INFO_BITS_MAX = 0x21 PERF_BR_ARM64_DEBUG_DATA = 0x7 PERF_BR_ARM64_DEBUG_EXIT = 0x5 PERF_BR_ARM64_DEBUG_HALT = 0x4 @@ -2424,7 +2399,6 @@ const ( PERF_RECORD_MISC_USER = 0x2 PERF_SAMPLE_BRANCH_PLM_ALL = 0x7 PERF_SAMPLE_WEIGHT_TYPE = 0x1004000 - PID_FS_MAGIC = 0x50494446 PIPEFS_MAGIC = 0x50495045 PPPIOCGNPMODE = 0xc008744c PPPIOCNEWUNIT = 0xc004743e @@ -2512,23 +2486,6 @@ const ( PR_PAC_GET_ENABLED_KEYS = 0x3d PR_PAC_RESET_KEYS = 0x36 PR_PAC_SET_ENABLED_KEYS = 0x3c - PR_PPC_DEXCR_CTRL_CLEAR = 0x4 - PR_PPC_DEXCR_CTRL_CLEAR_ONEXEC = 0x10 - PR_PPC_DEXCR_CTRL_EDITABLE = 0x1 - PR_PPC_DEXCR_CTRL_MASK = 0x1f - PR_PPC_DEXCR_CTRL_SET = 0x2 - PR_PPC_DEXCR_CTRL_SET_ONEXEC = 0x8 - PR_PPC_DEXCR_IBRTPD = 0x1 - PR_PPC_DEXCR_NPHIE = 0x3 - PR_PPC_DEXCR_SBHE = 0x0 - PR_PPC_DEXCR_SRAPD = 0x2 - PR_PPC_GET_DEXCR = 0x48 - PR_PPC_SET_DEXCR = 0x49 - PR_RISCV_CTX_SW_FENCEI_OFF = 0x1 - PR_RISCV_CTX_SW_FENCEI_ON = 0x0 - PR_RISCV_SCOPE_PER_PROCESS = 0x0 - PR_RISCV_SCOPE_PER_THREAD = 0x1 - PR_RISCV_SET_ICACHE_FLUSH_CTX = 0x47 PR_RISCV_V_GET_CONTROL = 0x46 PR_RISCV_V_SET_CONTROL = 0x45 PR_RISCV_V_VSTATE_CTRL_CUR_MASK = 0x3 @@ -2935,9 +2892,8 @@ const ( RWF_APPEND = 0x10 RWF_DSYNC = 0x2 RWF_HIPRI = 0x1 - RWF_NOAPPEND = 0x20 RWF_NOWAIT = 0x8 - RWF_SUPPORTED = 0x3f + RWF_SUPPORTED = 0x1f RWF_SYNC = 0x4 RWF_WRITE_LIFE_NOT_SET = 0x0 SCHED_BATCH = 0x3 @@ -2958,9 +2914,7 @@ const ( SCHED_RESET_ON_FORK = 0x40000000 SCHED_RR = 0x2 SCM_CREDENTIALS = 0x2 - SCM_PIDFD = 0x4 SCM_RIGHTS = 0x1 - SCM_SECURITY = 0x3 SCM_TIMESTAMP = 0x1d SC_LOG_FLUSH = 0x100000 SECCOMP_ADDFD_FLAG_SEND = 0x2 @@ -3093,8 +3047,6 @@ const ( SIOCSMIIREG = 0x8949 SIOCSRARP = 0x8962 SIOCWANDEV = 0x894a - SK_DIAG_BPF_STORAGE_MAX = 0x3 - SK_DIAG_BPF_STORAGE_REQ_MAX = 0x1 SMACK_MAGIC = 0x43415d53 SMART_AUTOSAVE = 0xd2 SMART_AUTO_OFFLINE = 0xdb @@ -3115,8 +3067,6 @@ const ( SOCKFS_MAGIC = 0x534f434b SOCK_BUF_LOCK_MASK = 0x3 SOCK_DCCP = 0x6 - SOCK_DESTROY = 0x15 - SOCK_DIAG_BY_FAMILY = 0x14 SOCK_IOC_TYPE = 0x89 SOCK_PACKET = 0xa SOCK_RAW = 0x3 @@ -3218,12 +3168,10 @@ const ( STATX_GID = 0x10 STATX_INO = 0x100 STATX_MNT_ID = 0x1000 - STATX_MNT_ID_UNIQUE = 0x4000 STATX_MODE = 0x2 STATX_MTIME = 0x40 STATX_NLINK = 0x4 STATX_SIZE = 0x200 - STATX_SUBVOL = 0x8000 STATX_TYPE = 0x1 STATX_UID = 0x8 STATX__RESERVED = 0x80000000 @@ -3307,7 +3255,6 @@ const ( TCP_MAX_WINSHIFT = 0xe TCP_MD5SIG = 0xe TCP_MD5SIG_EXT = 0x20 - TCP_MD5SIG_FLAG_IFINDEX = 0x2 TCP_MD5SIG_FLAG_PREFIX = 0x1 TCP_MD5SIG_MAXKEYLEN = 0x50 TCP_MSS = 0x200 @@ -3615,16 +3562,12 @@ const ( XDP_RX_RING = 0x2 XDP_SHARED_UMEM = 0x1 XDP_STATISTICS = 0x7 - XDP_TXMD_FLAGS_CHECKSUM = 0x2 - XDP_TXMD_FLAGS_TIMESTAMP = 0x1 - XDP_TX_METADATA = 0x2 XDP_TX_RING = 0x3 XDP_UMEM_COMPLETION_RING = 0x6 XDP_UMEM_FILL_RING = 0x5 XDP_UMEM_PGOFF_COMPLETION_RING = 0x180000000 XDP_UMEM_PGOFF_FILL_RING = 0x100000000 XDP_UMEM_REG = 0x4 - XDP_UMEM_TX_SW_CSUM = 0x2 XDP_UMEM_UNALIGNED_CHUNK_FLAG = 0x1 XDP_USE_NEED_WAKEUP = 0x8 XDP_USE_SG = 0x10 diff --git a/services/vendor/golang.org/x/sys/unix/zerrors_linux_386.go b/services/vendor/golang.org/x/sys/unix/zerrors_linux_386.go index 684a5168..42ff8c3c 100644 --- a/services/vendor/golang.org/x/sys/unix/zerrors_linux_386.go +++ b/services/vendor/golang.org/x/sys/unix/zerrors_linux_386.go @@ -78,8 +78,6 @@ const ( ECHOPRT = 0x400 EFD_CLOEXEC = 0x80000 EFD_NONBLOCK = 0x800 - EPIOCGPARAMS = 0x80088a02 - EPIOCSPARAMS = 0x40088a01 EPOLL_CLOEXEC = 0x80000 EXTPROC = 0x10000 FF1 = 0x8000 @@ -120,7 +118,6 @@ const ( IXOFF = 0x1000 IXON = 0x400 MAP_32BIT = 0x40 - MAP_ABOVE4G = 0x80 MAP_ANON = 0x20 MAP_ANONYMOUS = 0x20 MAP_DENYWRITE = 0x800 diff --git a/services/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go b/services/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go index 61d74b59..dca43600 100644 --- a/services/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go +++ b/services/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go @@ -78,8 +78,6 @@ const ( ECHOPRT = 0x400 EFD_CLOEXEC = 0x80000 EFD_NONBLOCK = 0x800 - EPIOCGPARAMS = 0x80088a02 - EPIOCSPARAMS = 0x40088a01 EPOLL_CLOEXEC = 0x80000 EXTPROC = 0x10000 FF1 = 0x8000 @@ -120,7 +118,6 @@ const ( IXOFF = 0x1000 IXON = 0x400 MAP_32BIT = 0x40 - MAP_ABOVE4G = 0x80 MAP_ANON = 0x20 MAP_ANONYMOUS = 0x20 MAP_DENYWRITE = 0x800 diff --git a/services/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go b/services/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go index a28c9e3e..5cca668a 100644 --- a/services/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go +++ b/services/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go @@ -78,8 +78,6 @@ const ( ECHOPRT = 0x400 EFD_CLOEXEC = 0x80000 EFD_NONBLOCK = 0x800 - EPIOCGPARAMS = 0x80088a02 - EPIOCSPARAMS = 0x40088a01 EPOLL_CLOEXEC = 0x80000 EXTPROC = 0x10000 FF1 = 0x8000 diff --git a/services/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go b/services/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go index ab5d1fe8..d8cae6d1 100644 --- a/services/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go +++ b/services/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go @@ -78,8 +78,6 @@ const ( ECHOPRT = 0x400 EFD_CLOEXEC = 0x80000 EFD_NONBLOCK = 0x800 - EPIOCGPARAMS = 0x80088a02 - EPIOCSPARAMS = 0x40088a01 EPOLL_CLOEXEC = 0x80000 ESR_MAGIC = 0x45535201 EXTPROC = 0x10000 @@ -89,7 +87,6 @@ const ( FICLONE = 0x40049409 FICLONERANGE = 0x4020940d FLUSHO = 0x1000 - FPMR_MAGIC = 0x46504d52 FPSIMD_MAGIC = 0x46508001 FS_IOC_ENABLE_VERITY = 0x40806685 FS_IOC_GETFLAGS = 0x80086601 diff --git a/services/vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go b/services/vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go index c523090e..28e39afd 100644 --- a/services/vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go +++ b/services/vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go @@ -78,8 +78,6 @@ const ( ECHOPRT = 0x400 EFD_CLOEXEC = 0x80000 EFD_NONBLOCK = 0x800 - EPIOCGPARAMS = 0x80088a02 - EPIOCSPARAMS = 0x40088a01 EPOLL_CLOEXEC = 0x80000 EXTPROC = 0x10000 FF1 = 0x8000 diff --git a/services/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go b/services/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go index 01e6ea78..cd66e92c 100644 --- a/services/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go +++ b/services/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go @@ -78,8 +78,6 @@ const ( ECHOPRT = 0x400 EFD_CLOEXEC = 0x80000 EFD_NONBLOCK = 0x80 - EPIOCGPARAMS = 0x40088a02 - EPIOCSPARAMS = 0x80088a01 EPOLL_CLOEXEC = 0x80000 EXTPROC = 0x10000 FF1 = 0x8000 diff --git a/services/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go b/services/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go index 7aa610b1..c1595eba 100644 --- a/services/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go +++ b/services/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go @@ -78,8 +78,6 @@ const ( ECHOPRT = 0x400 EFD_CLOEXEC = 0x80000 EFD_NONBLOCK = 0x80 - EPIOCGPARAMS = 0x40088a02 - EPIOCSPARAMS = 0x80088a01 EPOLL_CLOEXEC = 0x80000 EXTPROC = 0x10000 FF1 = 0x8000 diff --git a/services/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go b/services/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go index 92af771b..ee9456b0 100644 --- a/services/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go +++ b/services/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go @@ -78,8 +78,6 @@ const ( ECHOPRT = 0x400 EFD_CLOEXEC = 0x80000 EFD_NONBLOCK = 0x80 - EPIOCGPARAMS = 0x40088a02 - EPIOCSPARAMS = 0x80088a01 EPOLL_CLOEXEC = 0x80000 EXTPROC = 0x10000 FF1 = 0x8000 diff --git a/services/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go b/services/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go index b27ef5e6..8cfca81e 100644 --- a/services/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go +++ b/services/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go @@ -78,8 +78,6 @@ const ( ECHOPRT = 0x400 EFD_CLOEXEC = 0x80000 EFD_NONBLOCK = 0x80 - EPIOCGPARAMS = 0x40088a02 - EPIOCSPARAMS = 0x80088a01 EPOLL_CLOEXEC = 0x80000 EXTPROC = 0x10000 FF1 = 0x8000 diff --git a/services/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go b/services/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go index 237a2cef..60b0deb3 100644 --- a/services/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go +++ b/services/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go @@ -78,8 +78,6 @@ const ( ECHOPRT = 0x20 EFD_CLOEXEC = 0x80000 EFD_NONBLOCK = 0x800 - EPIOCGPARAMS = 0x40088a02 - EPIOCSPARAMS = 0x80088a01 EPOLL_CLOEXEC = 0x80000 EXTPROC = 0x10000000 FF1 = 0x4000 diff --git a/services/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go b/services/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go index 4a5c555a..f90aa728 100644 --- a/services/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go +++ b/services/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go @@ -78,8 +78,6 @@ const ( ECHOPRT = 0x20 EFD_CLOEXEC = 0x80000 EFD_NONBLOCK = 0x800 - EPIOCGPARAMS = 0x40088a02 - EPIOCSPARAMS = 0x80088a01 EPOLL_CLOEXEC = 0x80000 EXTPROC = 0x10000000 FF1 = 0x4000 diff --git a/services/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go b/services/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go index a02fb49a..ba9e0150 100644 --- a/services/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go +++ b/services/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go @@ -78,8 +78,6 @@ const ( ECHOPRT = 0x20 EFD_CLOEXEC = 0x80000 EFD_NONBLOCK = 0x800 - EPIOCGPARAMS = 0x40088a02 - EPIOCSPARAMS = 0x80088a01 EPOLL_CLOEXEC = 0x80000 EXTPROC = 0x10000000 FF1 = 0x4000 diff --git a/services/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go b/services/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go index e26a7c61..07cdfd6e 100644 --- a/services/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go +++ b/services/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go @@ -78,8 +78,6 @@ const ( ECHOPRT = 0x400 EFD_CLOEXEC = 0x80000 EFD_NONBLOCK = 0x800 - EPIOCGPARAMS = 0x80088a02 - EPIOCSPARAMS = 0x40088a01 EPOLL_CLOEXEC = 0x80000 EXTPROC = 0x10000 FF1 = 0x8000 diff --git a/services/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go b/services/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go index c48f7c21..2f1dd214 100644 --- a/services/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go +++ b/services/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go @@ -78,8 +78,6 @@ const ( ECHOPRT = 0x400 EFD_CLOEXEC = 0x80000 EFD_NONBLOCK = 0x800 - EPIOCGPARAMS = 0x80088a02 - EPIOCSPARAMS = 0x40088a01 EPOLL_CLOEXEC = 0x80000 EXTPROC = 0x10000 FF1 = 0x8000 diff --git a/services/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go b/services/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go index ad4b9aac..f40519d9 100644 --- a/services/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go +++ b/services/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go @@ -82,8 +82,6 @@ const ( EFD_CLOEXEC = 0x400000 EFD_NONBLOCK = 0x4000 EMT_TAGOVF = 0x1 - EPIOCGPARAMS = 0x40088a02 - EPIOCSPARAMS = 0x80088a01 EPOLL_CLOEXEC = 0x400000 EXTPROC = 0x10000 FF1 = 0x8000 diff --git a/services/vendor/golang.org/x/sys/unix/zerrors_zos_s390x.go b/services/vendor/golang.org/x/sys/unix/zerrors_zos_s390x.go index da08b2ab..4dfd2e05 100644 --- a/services/vendor/golang.org/x/sys/unix/zerrors_zos_s390x.go +++ b/services/vendor/golang.org/x/sys/unix/zerrors_zos_s390x.go @@ -10,99 +10,41 @@ package unix const ( - BRKINT = 0x0001 - CLOCAL = 0x1 - CLOCK_MONOTONIC = 0x1 - CLOCK_PROCESS_CPUTIME_ID = 0x2 - CLOCK_REALTIME = 0x0 - CLOCK_THREAD_CPUTIME_ID = 0x3 - CLONE_NEWIPC = 0x08000000 - CLONE_NEWNET = 0x40000000 - CLONE_NEWNS = 0x00020000 - CLONE_NEWPID = 0x20000000 - CLONE_NEWUTS = 0x04000000 - CLONE_PARENT = 0x00008000 - CS8 = 0x0030 - CSIZE = 0x0030 - ECHO = 0x00000008 - ECHONL = 0x00000001 - EFD_SEMAPHORE = 0x00002000 - EFD_CLOEXEC = 0x00001000 - EFD_NONBLOCK = 0x00000004 - EPOLL_CLOEXEC = 0x00001000 - EPOLL_CTL_ADD = 0 - EPOLL_CTL_MOD = 1 - EPOLL_CTL_DEL = 2 - EPOLLRDNORM = 0x0001 - EPOLLRDBAND = 0x0002 - EPOLLIN = 0x0003 - EPOLLOUT = 0x0004 - EPOLLWRBAND = 0x0008 - EPOLLPRI = 0x0010 - EPOLLERR = 0x0020 - EPOLLHUP = 0x0040 - EPOLLEXCLUSIVE = 0x20000000 - EPOLLONESHOT = 0x40000000 - FD_CLOEXEC = 0x01 - FD_CLOFORK = 0x02 - FD_SETSIZE = 0x800 - FNDELAY = 0x04 - F_CLOSFD = 9 - F_CONTROL_CVT = 13 - F_DUPFD = 0 - F_DUPFD2 = 8 - F_GETFD = 1 - F_GETFL = 259 - F_GETLK = 5 - F_GETOWN = 10 - F_OK = 0x0 - F_RDLCK = 1 - F_SETFD = 2 - F_SETFL = 4 - F_SETLK = 6 - F_SETLKW = 7 - F_SETOWN = 11 - F_SETTAG = 12 - F_UNLCK = 3 - F_WRLCK = 2 - FSTYPE_ZFS = 0xe9 //"Z" - FSTYPE_HFS = 0xc8 //"H" - FSTYPE_NFS = 0xd5 //"N" - FSTYPE_TFS = 0xe3 //"T" - FSTYPE_AUTOMOUNT = 0xc1 //"A" - GRND_NONBLOCK = 1 - GRND_RANDOM = 2 - HUPCL = 0x0100 // Hang up on last close - IN_CLOEXEC = 0x00001000 - IN_NONBLOCK = 0x00000004 - IN_ACCESS = 0x00000001 - IN_MODIFY = 0x00000002 - IN_ATTRIB = 0x00000004 - IN_CLOSE_WRITE = 0x00000008 - IN_CLOSE_NOWRITE = 0x00000010 - IN_OPEN = 0x00000020 - IN_MOVED_FROM = 0x00000040 - IN_MOVED_TO = 0x00000080 - IN_CREATE = 0x00000100 - IN_DELETE = 0x00000200 - IN_DELETE_SELF = 0x00000400 - IN_MOVE_SELF = 0x00000800 - IN_UNMOUNT = 0x00002000 - IN_Q_OVERFLOW = 0x00004000 - IN_IGNORED = 0x00008000 - IN_CLOSE = (IN_CLOSE_WRITE | IN_CLOSE_NOWRITE) - IN_MOVE = (IN_MOVED_FROM | IN_MOVED_TO) - IN_ALL_EVENTS = (IN_ACCESS | IN_MODIFY | IN_ATTRIB | - IN_CLOSE | IN_OPEN | IN_MOVE | - IN_CREATE | IN_DELETE | IN_DELETE_SELF | - IN_MOVE_SELF) - IN_ONLYDIR = 0x01000000 - IN_DONT_FOLLOW = 0x02000000 - IN_EXCL_UNLINK = 0x04000000 - IN_MASK_CREATE = 0x10000000 - IN_MASK_ADD = 0x20000000 - IN_ISDIR = 0x40000000 - IN_ONESHOT = 0x80000000 + BRKINT = 0x0001 + CLOCK_MONOTONIC = 0x1 + CLOCK_PROCESS_CPUTIME_ID = 0x2 + CLOCK_REALTIME = 0x0 + CLOCK_THREAD_CPUTIME_ID = 0x3 + CS8 = 0x0030 + CSIZE = 0x0030 + ECHO = 0x00000008 + ECHONL = 0x00000001 + FD_CLOEXEC = 0x01 + FD_CLOFORK = 0x02 + FNDELAY = 0x04 + F_CLOSFD = 9 + F_CONTROL_CVT = 13 + F_DUPFD = 0 + F_DUPFD2 = 8 + F_GETFD = 1 + F_GETFL = 259 + F_GETLK = 5 + F_GETOWN = 10 + F_OK = 0x0 + F_RDLCK = 1 + F_SETFD = 2 + F_SETFL = 4 + F_SETLK = 6 + F_SETLKW = 7 + F_SETOWN = 11 + F_SETTAG = 12 + F_UNLCK = 3 + F_WRLCK = 2 + FSTYPE_ZFS = 0xe9 //"Z" + FSTYPE_HFS = 0xc8 //"H" + FSTYPE_NFS = 0xd5 //"N" + FSTYPE_TFS = 0xe3 //"T" + FSTYPE_AUTOMOUNT = 0xc1 //"A" IP6F_MORE_FRAG = 0x0001 IP6F_OFF_MASK = 0xfff8 IP6F_RESERVED_MASK = 0x0006 @@ -210,18 +152,10 @@ const ( IP_PKTINFO = 101 IP_RECVPKTINFO = 102 IP_TOS = 2 - IP_TTL = 14 + IP_TTL = 3 IP_UNBLOCK_SOURCE = 11 - ICMP6_FILTER = 1 - MCAST_INCLUDE = 0 - MCAST_EXCLUDE = 1 - MCAST_JOIN_GROUP = 40 - MCAST_LEAVE_GROUP = 41 - MCAST_JOIN_SOURCE_GROUP = 42 - MCAST_LEAVE_SOURCE_GROUP = 43 - MCAST_BLOCK_SOURCE = 44 - MCAST_UNBLOCK_SOURCE = 46 ICANON = 0x0010 + ICMP6_FILTER = 0x26 ICRNL = 0x0002 IEXTEN = 0x0020 IGNBRK = 0x0004 @@ -231,10 +165,10 @@ const ( ISTRIP = 0x0080 IXON = 0x0200 IXOFF = 0x0100 - LOCK_SH = 0x1 - LOCK_EX = 0x2 - LOCK_NB = 0x4 - LOCK_UN = 0x8 + LOCK_SH = 0x1 // Not exist on zOS + LOCK_EX = 0x2 // Not exist on zOS + LOCK_NB = 0x4 // Not exist on zOS + LOCK_UN = 0x8 // Not exist on zOS POLLIN = 0x0003 POLLOUT = 0x0004 POLLPRI = 0x0010 @@ -248,29 +182,15 @@ const ( MAP_PRIVATE = 0x1 // changes are private MAP_SHARED = 0x2 // changes are shared MAP_FIXED = 0x4 // place exactly - __MAP_MEGA = 0x8 - __MAP_64 = 0x10 - MAP_ANON = 0x20 - MAP_ANONYMOUS = 0x20 + MCAST_JOIN_GROUP = 40 + MCAST_LEAVE_GROUP = 41 + MCAST_JOIN_SOURCE_GROUP = 42 + MCAST_LEAVE_SOURCE_GROUP = 43 + MCAST_BLOCK_SOURCE = 44 + MCAST_UNBLOCK_SOURCE = 45 MS_SYNC = 0x1 // msync - synchronous writes MS_ASYNC = 0x2 // asynchronous writes MS_INVALIDATE = 0x4 // invalidate mappings - MS_BIND = 0x00001000 - MS_MOVE = 0x00002000 - MS_NOSUID = 0x00000002 - MS_PRIVATE = 0x00040000 - MS_REC = 0x00004000 - MS_REMOUNT = 0x00008000 - MS_RDONLY = 0x00000001 - MS_UNBINDABLE = 0x00020000 - MNT_DETACH = 0x00000004 - ZOSDSFS_SUPER_MAGIC = 0x44534653 // zOS DSFS - NFS_SUPER_MAGIC = 0x6969 // NFS - NSFS_MAGIC = 0x6e736673 // PROCNS - PROC_SUPER_MAGIC = 0x9fa0 // proc FS - ZOSTFS_SUPER_MAGIC = 0x544653 // zOS TFS - ZOSUFS_SUPER_MAGIC = 0x554653 // zOS UFS - ZOSZFS_SUPER_MAGIC = 0x5A4653 // zOS ZFS MTM_RDONLY = 0x80000000 MTM_RDWR = 0x40000000 MTM_UMOUNT = 0x10000000 @@ -285,20 +205,13 @@ const ( MTM_REMOUNT = 0x00000100 MTM_NOSECURITY = 0x00000080 NFDBITS = 0x20 - ONLRET = 0x0020 // NL performs CR function O_ACCMODE = 0x03 O_APPEND = 0x08 O_ASYNCSIG = 0x0200 O_CREAT = 0x80 - O_DIRECT = 0x00002000 - O_NOFOLLOW = 0x00004000 - O_DIRECTORY = 0x00008000 - O_PATH = 0x00080000 - O_CLOEXEC = 0x00001000 O_EXCL = 0x40 O_GETFL = 0x0F O_LARGEFILE = 0x0400 - O_NDELAY = 0x4 O_NONBLOCK = 0x04 O_RDONLY = 0x02 O_RDWR = 0x03 @@ -335,7 +248,6 @@ const ( AF_IUCV = 17 AF_LAT = 14 AF_LINK = 18 - AF_LOCAL = AF_UNIX // AF_LOCAL is an alias for AF_UNIX AF_MAX = 30 AF_NBS = 7 AF_NDD = 23 @@ -373,33 +285,15 @@ const ( RLIMIT_AS = 5 RLIMIT_NOFILE = 6 RLIMIT_MEMLIMIT = 7 - RLIMIT_MEMLOCK = 0x8 RLIM_INFINITY = 2147483647 - SCHED_FIFO = 0x2 - SCM_CREDENTIALS = 0x2 SCM_RIGHTS = 0x01 SF_CLOSE = 0x00000002 SF_REUSE = 0x00000001 - SHM_RND = 0x2 - SHM_RDONLY = 0x1 - SHMLBA = 0x1000 - IPC_STAT = 0x3 - IPC_SET = 0x2 - IPC_RMID = 0x1 - IPC_PRIVATE = 0x0 - IPC_CREAT = 0x1000000 - __IPC_MEGA = 0x4000000 - __IPC_SHAREAS = 0x20000000 - __IPC_BELOWBAR = 0x10000000 - IPC_EXCL = 0x2000000 - __IPC_GIGA = 0x8000000 SHUT_RD = 0 SHUT_RDWR = 2 SHUT_WR = 1 - SOCK_CLOEXEC = 0x00001000 SOCK_CONN_DGRAM = 6 SOCK_DGRAM = 2 - SOCK_NONBLOCK = 0x800 SOCK_RAW = 3 SOCK_RDM = 4 SOCK_SEQPACKET = 5 @@ -484,6 +378,8 @@ const ( S_IFMST = 0x00FF0000 TCP_KEEPALIVE = 0x8 TCP_NODELAY = 0x1 + TCP_INFO = 0xb + TCP_USER_TIMEOUT = 0x1 TIOCGWINSZ = 0x4008a368 TIOCSWINSZ = 0x8008a367 TIOCSBRK = 0x2000a77b @@ -531,10 +427,7 @@ const ( VSUSP = 9 VTIME = 10 WCONTINUED = 0x4 - WEXITED = 0x8 WNOHANG = 0x1 - WNOWAIT = 0x20 - WSTOPPED = 0x10 WUNTRACED = 0x2 _BPX_SWAP = 1 _BPX_NONSWAP = 2 @@ -559,28 +452,8 @@ const ( MADV_FREE = 15 // for Linux compatibility -- no zos semantics MADV_WIPEONFORK = 16 // for Linux compatibility -- no zos semantics MADV_KEEPONFORK = 17 // for Linux compatibility -- no zos semantics - AT_SYMLINK_FOLLOW = 0x400 - AT_SYMLINK_NOFOLLOW = 0x100 - XATTR_CREATE = 0x1 - XATTR_REPLACE = 0x2 - P_PID = 0 - P_PGID = 1 - P_ALL = 2 - PR_SET_NAME = 15 - PR_GET_NAME = 16 - PR_SET_NO_NEW_PRIVS = 38 - PR_GET_NO_NEW_PRIVS = 39 - PR_SET_DUMPABLE = 4 - PR_GET_DUMPABLE = 3 - PR_SET_PDEATHSIG = 1 - PR_GET_PDEATHSIG = 2 - PR_SET_CHILD_SUBREAPER = 36 - PR_GET_CHILD_SUBREAPER = 37 - AT_FDCWD = -100 - AT_EACCESS = 0x200 - AT_EMPTY_PATH = 0x1000 - AT_REMOVEDIR = 0x200 - RENAME_NOREPLACE = 1 << 0 + AT_SYMLINK_NOFOLLOW = 1 // for Unix compatibility -- no zos semantics + AT_FDCWD = 2 // for Unix compatibility -- no zos semantics ) const ( @@ -603,7 +476,6 @@ const ( EMLINK = Errno(125) ENAMETOOLONG = Errno(126) ENFILE = Errno(127) - ENOATTR = Errno(265) ENODEV = Errno(128) ENOENT = Errno(129) ENOEXEC = Errno(130) @@ -828,7 +700,7 @@ var errorList = [...]struct { {145, "EDC5145I", "The parameter list is too long, or the message to receive was too large for the buffer."}, {146, "EDC5146I", "Too many levels of symbolic links."}, {147, "EDC5147I", "Illegal byte sequence."}, - {148, "EDC5148I", "The named attribute or data not available."}, + {148, "", ""}, {149, "EDC5149I", "Value Overflow Error."}, {150, "EDC5150I", "UNIX System Services is not active."}, {151, "EDC5151I", "Dynamic allocation error."}, @@ -871,7 +743,6 @@ var errorList = [...]struct { {259, "EDC5259I", "A CUN_RS_NO_CONVERSION error was issued by Unicode Services."}, {260, "EDC5260I", "A CUN_RS_TABLE_NOT_ALIGNED error was issued by Unicode Services."}, {262, "EDC5262I", "An iconv() function encountered an unexpected error while using Unicode Services."}, - {265, "EDC5265I", "The named attribute not available."}, {1000, "EDC8000I", "A bad socket-call constant was found in the IUCV header."}, {1001, "EDC8001I", "An error was found in the IUCV header."}, {1002, "EDC8002I", "A socket descriptor is out of range."}, diff --git a/services/vendor/golang.org/x/sys/unix/zsymaddr_zos_s390x.s b/services/vendor/golang.org/x/sys/unix/zsymaddr_zos_s390x.s deleted file mode 100644 index b77ff5db..00000000 --- a/services/vendor/golang.org/x/sys/unix/zsymaddr_zos_s390x.s +++ /dev/null @@ -1,364 +0,0 @@ -// go run mksyscall_zos_s390x.go -o_sysnum zsysnum_zos_s390x.go -o_syscall zsyscall_zos_s390x.go -i_syscall syscall_zos_s390x.go -o_asm zsymaddr_zos_s390x.s -// Code generated by the command above; see README.md. DO NOT EDIT. - -//go:build zos && s390x -#include "textflag.h" - -// provide the address of function variable to be fixed up. - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -TEXT ·get_FlistxattrAddr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·Flistxattr(SB), R8 - MOVD R8, ret+0(FP) - RET - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -TEXT ·get_FremovexattrAddr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·Fremovexattr(SB), R8 - MOVD R8, ret+0(FP) - RET - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -TEXT ·get_FgetxattrAddr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·Fgetxattr(SB), R8 - MOVD R8, ret+0(FP) - RET - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -TEXT ·get_FsetxattrAddr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·Fsetxattr(SB), R8 - MOVD R8, ret+0(FP) - RET - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -TEXT ·get_accept4Addr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·accept4(SB), R8 - MOVD R8, ret+0(FP) - RET - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -TEXT ·get_RemovexattrAddr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·Removexattr(SB), R8 - MOVD R8, ret+0(FP) - RET - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -TEXT ·get_Dup3Addr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·Dup3(SB), R8 - MOVD R8, ret+0(FP) - RET - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -TEXT ·get_DirfdAddr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·Dirfd(SB), R8 - MOVD R8, ret+0(FP) - RET - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -TEXT ·get_EpollCreateAddr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·EpollCreate(SB), R8 - MOVD R8, ret+0(FP) - RET - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -TEXT ·get_EpollCreate1Addr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·EpollCreate1(SB), R8 - MOVD R8, ret+0(FP) - RET - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -TEXT ·get_EpollCtlAddr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·EpollCtl(SB), R8 - MOVD R8, ret+0(FP) - RET - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -TEXT ·get_EpollPwaitAddr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·EpollPwait(SB), R8 - MOVD R8, ret+0(FP) - RET - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -TEXT ·get_EpollWaitAddr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·EpollWait(SB), R8 - MOVD R8, ret+0(FP) - RET - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -TEXT ·get_EventfdAddr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·Eventfd(SB), R8 - MOVD R8, ret+0(FP) - RET - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -TEXT ·get_FaccessatAddr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·Faccessat(SB), R8 - MOVD R8, ret+0(FP) - RET - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -TEXT ·get_FchmodatAddr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·Fchmodat(SB), R8 - MOVD R8, ret+0(FP) - RET - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -TEXT ·get_FchownatAddr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·Fchownat(SB), R8 - MOVD R8, ret+0(FP) - RET - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -TEXT ·get_FdatasyncAddr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·Fdatasync(SB), R8 - MOVD R8, ret+0(FP) - RET - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -TEXT ·get_fstatatAddr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·fstatat(SB), R8 - MOVD R8, ret+0(FP) - RET - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -TEXT ·get_LgetxattrAddr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·Lgetxattr(SB), R8 - MOVD R8, ret+0(FP) - RET - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -TEXT ·get_LsetxattrAddr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·Lsetxattr(SB), R8 - MOVD R8, ret+0(FP) - RET - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -TEXT ·get_FstatfsAddr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·Fstatfs(SB), R8 - MOVD R8, ret+0(FP) - RET - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -TEXT ·get_FutimesAddr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·Futimes(SB), R8 - MOVD R8, ret+0(FP) - RET - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -TEXT ·get_FutimesatAddr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·Futimesat(SB), R8 - MOVD R8, ret+0(FP) - RET - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -TEXT ·get_GetrandomAddr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·Getrandom(SB), R8 - MOVD R8, ret+0(FP) - RET - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -TEXT ·get_InotifyInitAddr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·InotifyInit(SB), R8 - MOVD R8, ret+0(FP) - RET - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -TEXT ·get_InotifyInit1Addr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·InotifyInit1(SB), R8 - MOVD R8, ret+0(FP) - RET - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -TEXT ·get_InotifyAddWatchAddr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·InotifyAddWatch(SB), R8 - MOVD R8, ret+0(FP) - RET - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -TEXT ·get_InotifyRmWatchAddr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·InotifyRmWatch(SB), R8 - MOVD R8, ret+0(FP) - RET - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -TEXT ·get_ListxattrAddr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·Listxattr(SB), R8 - MOVD R8, ret+0(FP) - RET - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -TEXT ·get_LlistxattrAddr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·Llistxattr(SB), R8 - MOVD R8, ret+0(FP) - RET - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -TEXT ·get_LremovexattrAddr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·Lremovexattr(SB), R8 - MOVD R8, ret+0(FP) - RET - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -TEXT ·get_LutimesAddr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·Lutimes(SB), R8 - MOVD R8, ret+0(FP) - RET - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -TEXT ·get_StatfsAddr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·Statfs(SB), R8 - MOVD R8, ret+0(FP) - RET - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -TEXT ·get_SyncfsAddr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·Syncfs(SB), R8 - MOVD R8, ret+0(FP) - RET - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -TEXT ·get_UnshareAddr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·Unshare(SB), R8 - MOVD R8, ret+0(FP) - RET - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -TEXT ·get_LinkatAddr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·Linkat(SB), R8 - MOVD R8, ret+0(FP) - RET - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -TEXT ·get_MkdiratAddr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·Mkdirat(SB), R8 - MOVD R8, ret+0(FP) - RET - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -TEXT ·get_MknodatAddr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·Mknodat(SB), R8 - MOVD R8, ret+0(FP) - RET - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -TEXT ·get_PivotRootAddr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·PivotRoot(SB), R8 - MOVD R8, ret+0(FP) - RET - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -TEXT ·get_PrctlAddr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·Prctl(SB), R8 - MOVD R8, ret+0(FP) - RET - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -TEXT ·get_PrlimitAddr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·Prlimit(SB), R8 - MOVD R8, ret+0(FP) - RET - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -TEXT ·get_RenameatAddr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·Renameat(SB), R8 - MOVD R8, ret+0(FP) - RET - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -TEXT ·get_Renameat2Addr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·Renameat2(SB), R8 - MOVD R8, ret+0(FP) - RET - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -TEXT ·get_SethostnameAddr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·Sethostname(SB), R8 - MOVD R8, ret+0(FP) - RET - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -TEXT ·get_SetnsAddr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·Setns(SB), R8 - MOVD R8, ret+0(FP) - RET - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -TEXT ·get_SymlinkatAddr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·Symlinkat(SB), R8 - MOVD R8, ret+0(FP) - RET - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -TEXT ·get_UnlinkatAddr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·Unlinkat(SB), R8 - MOVD R8, ret+0(FP) - RET - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -TEXT ·get_openatAddr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·openat(SB), R8 - MOVD R8, ret+0(FP) - RET - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -TEXT ·get_openat2Addr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·openat2(SB), R8 - MOVD R8, ret+0(FP) - RET - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -TEXT ·get_utimensatAddr(SB), NOSPLIT|NOFRAME, $0-8 - MOVD $·utimensat(SB), R8 - MOVD R8, ret+0(FP) - RET diff --git a/services/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go b/services/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go index b622533e..ccb02f24 100644 --- a/services/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go +++ b/services/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go @@ -740,54 +740,6 @@ func ioctlPtr(fd int, req uint, arg unsafe.Pointer) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func renamexNp(from string, to string, flag uint32) (err error) { - var _p0 *byte - _p0, err = BytePtrFromString(from) - if err != nil { - return - } - var _p1 *byte - _p1, err = BytePtrFromString(to) - if err != nil { - return - } - _, _, e1 := syscall_syscall(libc_renamex_np_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(flag)) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -var libc_renamex_np_trampoline_addr uintptr - -//go:cgo_import_dynamic libc_renamex_np renamex_np "/usr/lib/libSystem.B.dylib" - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func renameatxNp(fromfd int, from string, tofd int, to string, flag uint32) (err error) { - var _p0 *byte - _p0, err = BytePtrFromString(from) - if err != nil { - return - } - var _p1 *byte - _p1, err = BytePtrFromString(to) - if err != nil { - return - } - _, _, e1 := syscall_syscall6(libc_renameatx_np_trampoline_addr, uintptr(fromfd), uintptr(unsafe.Pointer(_p0)), uintptr(tofd), uintptr(unsafe.Pointer(_p1)), uintptr(flag), 0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -var libc_renameatx_np_trampoline_addr uintptr - -//go:cgo_import_dynamic libc_renameatx_np renameatx_np "/usr/lib/libSystem.B.dylib" - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - func sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) { var _p0 unsafe.Pointer if len(mib) > 0 { @@ -808,39 +760,6 @@ var libc_sysctl_trampoline_addr uintptr // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func pthread_chdir_np(path string) (err error) { - var _p0 *byte - _p0, err = BytePtrFromString(path) - if err != nil { - return - } - _, _, e1 := syscall_syscall(libc_pthread_chdir_np_trampoline_addr, uintptr(unsafe.Pointer(_p0)), 0, 0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -var libc_pthread_chdir_np_trampoline_addr uintptr - -//go:cgo_import_dynamic libc_pthread_chdir_np pthread_chdir_np "/usr/lib/libSystem.B.dylib" - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func pthread_fchdir_np(fd int) (err error) { - _, _, e1 := syscall_syscall(libc_pthread_fchdir_np_trampoline_addr, uintptr(fd), 0, 0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -var libc_pthread_fchdir_np_trampoline_addr uintptr - -//go:cgo_import_dynamic libc_pthread_fchdir_np pthread_fchdir_np "/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/services/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.s b/services/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.s index cfe6646b..8b8bb284 100644 --- a/services/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.s +++ b/services/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.s @@ -223,31 +223,11 @@ TEXT libc_ioctl_trampoline<>(SB),NOSPLIT,$0-0 GLOBL ·libc_ioctl_trampoline_addr(SB), RODATA, $8 DATA ·libc_ioctl_trampoline_addr(SB)/8, $libc_ioctl_trampoline<>(SB) -TEXT libc_renamex_np_trampoline<>(SB),NOSPLIT,$0-0 - JMP libc_renamex_np(SB) -GLOBL ·libc_renamex_np_trampoline_addr(SB), RODATA, $8 -DATA ·libc_renamex_np_trampoline_addr(SB)/8, $libc_renamex_np_trampoline<>(SB) - -TEXT libc_renameatx_np_trampoline<>(SB),NOSPLIT,$0-0 - JMP libc_renameatx_np(SB) -GLOBL ·libc_renameatx_np_trampoline_addr(SB), RODATA, $8 -DATA ·libc_renameatx_np_trampoline_addr(SB)/8, $libc_renameatx_np_trampoline<>(SB) - TEXT libc_sysctl_trampoline<>(SB),NOSPLIT,$0-0 JMP libc_sysctl(SB) GLOBL ·libc_sysctl_trampoline_addr(SB), RODATA, $8 DATA ·libc_sysctl_trampoline_addr(SB)/8, $libc_sysctl_trampoline<>(SB) -TEXT libc_pthread_chdir_np_trampoline<>(SB),NOSPLIT,$0-0 - JMP libc_pthread_chdir_np(SB) -GLOBL ·libc_pthread_chdir_np_trampoline_addr(SB), RODATA, $8 -DATA ·libc_pthread_chdir_np_trampoline_addr(SB)/8, $libc_pthread_chdir_np_trampoline<>(SB) - -TEXT libc_pthread_fchdir_np_trampoline<>(SB),NOSPLIT,$0-0 - JMP libc_pthread_fchdir_np(SB) -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_sendfile_trampoline<>(SB),NOSPLIT,$0-0 JMP libc_sendfile(SB) GLOBL ·libc_sendfile_trampoline_addr(SB), RODATA, $8 diff --git a/services/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go b/services/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go index 13f624f6..1b40b997 100644 --- a/services/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go +++ b/services/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go @@ -740,54 +740,6 @@ func ioctlPtr(fd int, req uint, arg unsafe.Pointer) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func renamexNp(from string, to string, flag uint32) (err error) { - var _p0 *byte - _p0, err = BytePtrFromString(from) - if err != nil { - return - } - var _p1 *byte - _p1, err = BytePtrFromString(to) - if err != nil { - return - } - _, _, e1 := syscall_syscall(libc_renamex_np_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(flag)) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -var libc_renamex_np_trampoline_addr uintptr - -//go:cgo_import_dynamic libc_renamex_np renamex_np "/usr/lib/libSystem.B.dylib" - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func renameatxNp(fromfd int, from string, tofd int, to string, flag uint32) (err error) { - var _p0 *byte - _p0, err = BytePtrFromString(from) - if err != nil { - return - } - var _p1 *byte - _p1, err = BytePtrFromString(to) - if err != nil { - return - } - _, _, e1 := syscall_syscall6(libc_renameatx_np_trampoline_addr, uintptr(fromfd), uintptr(unsafe.Pointer(_p0)), uintptr(tofd), uintptr(unsafe.Pointer(_p1)), uintptr(flag), 0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -var libc_renameatx_np_trampoline_addr uintptr - -//go:cgo_import_dynamic libc_renameatx_np renameatx_np "/usr/lib/libSystem.B.dylib" - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - func sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) { var _p0 unsafe.Pointer if len(mib) > 0 { @@ -808,39 +760,6 @@ var libc_sysctl_trampoline_addr uintptr // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func pthread_chdir_np(path string) (err error) { - var _p0 *byte - _p0, err = BytePtrFromString(path) - if err != nil { - return - } - _, _, e1 := syscall_syscall(libc_pthread_chdir_np_trampoline_addr, uintptr(unsafe.Pointer(_p0)), 0, 0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -var libc_pthread_chdir_np_trampoline_addr uintptr - -//go:cgo_import_dynamic libc_pthread_chdir_np pthread_chdir_np "/usr/lib/libSystem.B.dylib" - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func pthread_fchdir_np(fd int) (err error) { - _, _, e1 := syscall_syscall(libc_pthread_fchdir_np_trampoline_addr, uintptr(fd), 0, 0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -var libc_pthread_fchdir_np_trampoline_addr uintptr - -//go:cgo_import_dynamic libc_pthread_fchdir_np pthread_fchdir_np "/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/services/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.s b/services/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.s index fe222b75..08362c1a 100644 --- a/services/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.s +++ b/services/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.s @@ -223,31 +223,11 @@ TEXT libc_ioctl_trampoline<>(SB),NOSPLIT,$0-0 GLOBL ·libc_ioctl_trampoline_addr(SB), RODATA, $8 DATA ·libc_ioctl_trampoline_addr(SB)/8, $libc_ioctl_trampoline<>(SB) -TEXT libc_renamex_np_trampoline<>(SB),NOSPLIT,$0-0 - JMP libc_renamex_np(SB) -GLOBL ·libc_renamex_np_trampoline_addr(SB), RODATA, $8 -DATA ·libc_renamex_np_trampoline_addr(SB)/8, $libc_renamex_np_trampoline<>(SB) - -TEXT libc_renameatx_np_trampoline<>(SB),NOSPLIT,$0-0 - JMP libc_renameatx_np(SB) -GLOBL ·libc_renameatx_np_trampoline_addr(SB), RODATA, $8 -DATA ·libc_renameatx_np_trampoline_addr(SB)/8, $libc_renameatx_np_trampoline<>(SB) - TEXT libc_sysctl_trampoline<>(SB),NOSPLIT,$0-0 JMP libc_sysctl(SB) GLOBL ·libc_sysctl_trampoline_addr(SB), RODATA, $8 DATA ·libc_sysctl_trampoline_addr(SB)/8, $libc_sysctl_trampoline<>(SB) -TEXT libc_pthread_chdir_np_trampoline<>(SB),NOSPLIT,$0-0 - JMP libc_pthread_chdir_np(SB) -GLOBL ·libc_pthread_chdir_np_trampoline_addr(SB), RODATA, $8 -DATA ·libc_pthread_chdir_np_trampoline_addr(SB)/8, $libc_pthread_chdir_np_trampoline<>(SB) - -TEXT libc_pthread_fchdir_np_trampoline<>(SB),NOSPLIT,$0-0 - JMP libc_pthread_fchdir_np(SB) -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_sendfile_trampoline<>(SB),NOSPLIT,$0-0 JMP libc_sendfile(SB) GLOBL ·libc_sendfile_trampoline_addr(SB), RODATA, $8 diff --git a/services/vendor/golang.org/x/sys/unix/zsyscall_linux.go b/services/vendor/golang.org/x/sys/unix/zsyscall_linux.go index 1bc1a5ad..1488d271 100644 --- a/services/vendor/golang.org/x/sys/unix/zsyscall_linux.go +++ b/services/vendor/golang.org/x/sys/unix/zsyscall_linux.go @@ -906,16 +906,6 @@ func Fspick(dirfd int, pathName string, flags int) (fd int, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func fsconfig(fd int, cmd uint, key *byte, value *byte, aux int) (err error) { - _, _, e1 := Syscall6(SYS_FSCONFIG, uintptr(fd), uintptr(cmd), uintptr(unsafe.Pointer(key)), uintptr(unsafe.Pointer(value)), uintptr(aux), 0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - func Getdents(fd int, buf []byte) (n int, err error) { var _p0 unsafe.Pointer if len(buf) > 0 { @@ -2229,19 +2219,3 @@ func Cachestat(fd uint, crange *CachestatRange, cstat *Cachestat_t, flags uint) } return } - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func Mseal(b []byte, flags uint) (err error) { - var _p0 unsafe.Pointer - if len(b) > 0 { - _p0 = unsafe.Pointer(&b[0]) - } else { - _p0 = unsafe.Pointer(&_zero) - } - _, _, e1 := Syscall(SYS_MSEAL, uintptr(_p0), uintptr(len(b)), uintptr(flags)) - if e1 != 0 { - err = errnoErr(e1) - } - return -} diff --git a/services/vendor/golang.org/x/sys/unix/zsyscall_openbsd_386.go b/services/vendor/golang.org/x/sys/unix/zsyscall_openbsd_386.go index 1851df14..9dc42410 100644 --- a/services/vendor/golang.org/x/sys/unix/zsyscall_openbsd_386.go +++ b/services/vendor/golang.org/x/sys/unix/zsyscall_openbsd_386.go @@ -1493,30 +1493,6 @@ var libc_mknodat_trampoline_addr uintptr // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func Mount(fsType string, dir string, flags int, data unsafe.Pointer) (err error) { - var _p0 *byte - _p0, err = BytePtrFromString(fsType) - if err != nil { - return - } - var _p1 *byte - _p1, err = BytePtrFromString(dir) - if err != nil { - return - } - _, _, e1 := syscall_syscall6(libc_mount_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(flags), uintptr(data), 0, 0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -var libc_mount_trampoline_addr uintptr - -//go:cgo_import_dynamic libc_mount mount "libc.so" - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - func Nanosleep(time *Timespec, leftover *Timespec) (err error) { _, _, e1 := syscall_syscall(libc_nanosleep_trampoline_addr, uintptr(unsafe.Pointer(time)), uintptr(unsafe.Pointer(leftover)), 0) if e1 != 0 { diff --git a/services/vendor/golang.org/x/sys/unix/zsyscall_openbsd_386.s b/services/vendor/golang.org/x/sys/unix/zsyscall_openbsd_386.s index 0b43c693..41b56173 100644 --- a/services/vendor/golang.org/x/sys/unix/zsyscall_openbsd_386.s +++ b/services/vendor/golang.org/x/sys/unix/zsyscall_openbsd_386.s @@ -463,11 +463,6 @@ TEXT libc_mknodat_trampoline<>(SB),NOSPLIT,$0-0 GLOBL ·libc_mknodat_trampoline_addr(SB), RODATA, $4 DATA ·libc_mknodat_trampoline_addr(SB)/4, $libc_mknodat_trampoline<>(SB) -TEXT libc_mount_trampoline<>(SB),NOSPLIT,$0-0 - JMP libc_mount(SB) -GLOBL ·libc_mount_trampoline_addr(SB), RODATA, $4 -DATA ·libc_mount_trampoline_addr(SB)/4, $libc_mount_trampoline<>(SB) - TEXT libc_nanosleep_trampoline<>(SB),NOSPLIT,$0-0 JMP libc_nanosleep(SB) GLOBL ·libc_nanosleep_trampoline_addr(SB), RODATA, $4 diff --git a/services/vendor/golang.org/x/sys/unix/zsyscall_openbsd_amd64.go b/services/vendor/golang.org/x/sys/unix/zsyscall_openbsd_amd64.go index e1ec0dbe..0d3a0751 100644 --- a/services/vendor/golang.org/x/sys/unix/zsyscall_openbsd_amd64.go +++ b/services/vendor/golang.org/x/sys/unix/zsyscall_openbsd_amd64.go @@ -1493,30 +1493,6 @@ var libc_mknodat_trampoline_addr uintptr // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func Mount(fsType string, dir string, flags int, data unsafe.Pointer) (err error) { - var _p0 *byte - _p0, err = BytePtrFromString(fsType) - if err != nil { - return - } - var _p1 *byte - _p1, err = BytePtrFromString(dir) - if err != nil { - return - } - _, _, e1 := syscall_syscall6(libc_mount_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(flags), uintptr(data), 0, 0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -var libc_mount_trampoline_addr uintptr - -//go:cgo_import_dynamic libc_mount mount "libc.so" - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - func Nanosleep(time *Timespec, leftover *Timespec) (err error) { _, _, e1 := syscall_syscall(libc_nanosleep_trampoline_addr, uintptr(unsafe.Pointer(time)), uintptr(unsafe.Pointer(leftover)), 0) if e1 != 0 { diff --git a/services/vendor/golang.org/x/sys/unix/zsyscall_openbsd_amd64.s b/services/vendor/golang.org/x/sys/unix/zsyscall_openbsd_amd64.s index 880c6d6e..4019a656 100644 --- a/services/vendor/golang.org/x/sys/unix/zsyscall_openbsd_amd64.s +++ b/services/vendor/golang.org/x/sys/unix/zsyscall_openbsd_amd64.s @@ -463,11 +463,6 @@ TEXT libc_mknodat_trampoline<>(SB),NOSPLIT,$0-0 GLOBL ·libc_mknodat_trampoline_addr(SB), RODATA, $8 DATA ·libc_mknodat_trampoline_addr(SB)/8, $libc_mknodat_trampoline<>(SB) -TEXT libc_mount_trampoline<>(SB),NOSPLIT,$0-0 - JMP libc_mount(SB) -GLOBL ·libc_mount_trampoline_addr(SB), RODATA, $8 -DATA ·libc_mount_trampoline_addr(SB)/8, $libc_mount_trampoline<>(SB) - TEXT libc_nanosleep_trampoline<>(SB),NOSPLIT,$0-0 JMP libc_nanosleep(SB) GLOBL ·libc_nanosleep_trampoline_addr(SB), RODATA, $8 diff --git a/services/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm.go b/services/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm.go index 7c8452a6..c39f7776 100644 --- a/services/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm.go +++ b/services/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm.go @@ -1493,30 +1493,6 @@ var libc_mknodat_trampoline_addr uintptr // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func Mount(fsType string, dir string, flags int, data unsafe.Pointer) (err error) { - var _p0 *byte - _p0, err = BytePtrFromString(fsType) - if err != nil { - return - } - var _p1 *byte - _p1, err = BytePtrFromString(dir) - if err != nil { - return - } - _, _, e1 := syscall_syscall6(libc_mount_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(flags), uintptr(data), 0, 0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -var libc_mount_trampoline_addr uintptr - -//go:cgo_import_dynamic libc_mount mount "libc.so" - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - func Nanosleep(time *Timespec, leftover *Timespec) (err error) { _, _, e1 := syscall_syscall(libc_nanosleep_trampoline_addr, uintptr(unsafe.Pointer(time)), uintptr(unsafe.Pointer(leftover)), 0) if e1 != 0 { diff --git a/services/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm.s b/services/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm.s index b8ef95b0..ac4af24f 100644 --- a/services/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm.s +++ b/services/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm.s @@ -463,11 +463,6 @@ TEXT libc_mknodat_trampoline<>(SB),NOSPLIT,$0-0 GLOBL ·libc_mknodat_trampoline_addr(SB), RODATA, $4 DATA ·libc_mknodat_trampoline_addr(SB)/4, $libc_mknodat_trampoline<>(SB) -TEXT libc_mount_trampoline<>(SB),NOSPLIT,$0-0 - JMP libc_mount(SB) -GLOBL ·libc_mount_trampoline_addr(SB), RODATA, $4 -DATA ·libc_mount_trampoline_addr(SB)/4, $libc_mount_trampoline<>(SB) - TEXT libc_nanosleep_trampoline<>(SB),NOSPLIT,$0-0 JMP libc_nanosleep(SB) GLOBL ·libc_nanosleep_trampoline_addr(SB), RODATA, $4 diff --git a/services/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm64.go b/services/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm64.go index 2ffdf861..57571d07 100644 --- a/services/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm64.go +++ b/services/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm64.go @@ -1493,30 +1493,6 @@ var libc_mknodat_trampoline_addr uintptr // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func Mount(fsType string, dir string, flags int, data unsafe.Pointer) (err error) { - var _p0 *byte - _p0, err = BytePtrFromString(fsType) - if err != nil { - return - } - var _p1 *byte - _p1, err = BytePtrFromString(dir) - if err != nil { - return - } - _, _, e1 := syscall_syscall6(libc_mount_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(flags), uintptr(data), 0, 0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -var libc_mount_trampoline_addr uintptr - -//go:cgo_import_dynamic libc_mount mount "libc.so" - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - func Nanosleep(time *Timespec, leftover *Timespec) (err error) { _, _, e1 := syscall_syscall(libc_nanosleep_trampoline_addr, uintptr(unsafe.Pointer(time)), uintptr(unsafe.Pointer(leftover)), 0) if e1 != 0 { diff --git a/services/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm64.s b/services/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm64.s index 2af3b5c7..f77d5321 100644 --- a/services/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm64.s +++ b/services/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm64.s @@ -463,11 +463,6 @@ TEXT libc_mknodat_trampoline<>(SB),NOSPLIT,$0-0 GLOBL ·libc_mknodat_trampoline_addr(SB), RODATA, $8 DATA ·libc_mknodat_trampoline_addr(SB)/8, $libc_mknodat_trampoline<>(SB) -TEXT libc_mount_trampoline<>(SB),NOSPLIT,$0-0 - JMP libc_mount(SB) -GLOBL ·libc_mount_trampoline_addr(SB), RODATA, $8 -DATA ·libc_mount_trampoline_addr(SB)/8, $libc_mount_trampoline<>(SB) - TEXT libc_nanosleep_trampoline<>(SB),NOSPLIT,$0-0 JMP libc_nanosleep(SB) GLOBL ·libc_nanosleep_trampoline_addr(SB), RODATA, $8 diff --git a/services/vendor/golang.org/x/sys/unix/zsyscall_openbsd_mips64.go b/services/vendor/golang.org/x/sys/unix/zsyscall_openbsd_mips64.go index 1da08d52..e62963e6 100644 --- a/services/vendor/golang.org/x/sys/unix/zsyscall_openbsd_mips64.go +++ b/services/vendor/golang.org/x/sys/unix/zsyscall_openbsd_mips64.go @@ -1493,30 +1493,6 @@ var libc_mknodat_trampoline_addr uintptr // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func Mount(fsType string, dir string, flags int, data unsafe.Pointer) (err error) { - var _p0 *byte - _p0, err = BytePtrFromString(fsType) - if err != nil { - return - } - var _p1 *byte - _p1, err = BytePtrFromString(dir) - if err != nil { - return - } - _, _, e1 := syscall_syscall6(libc_mount_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(flags), uintptr(data), 0, 0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -var libc_mount_trampoline_addr uintptr - -//go:cgo_import_dynamic libc_mount mount "libc.so" - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - func Nanosleep(time *Timespec, leftover *Timespec) (err error) { _, _, e1 := syscall_syscall(libc_nanosleep_trampoline_addr, uintptr(unsafe.Pointer(time)), uintptr(unsafe.Pointer(leftover)), 0) if e1 != 0 { diff --git a/services/vendor/golang.org/x/sys/unix/zsyscall_openbsd_mips64.s b/services/vendor/golang.org/x/sys/unix/zsyscall_openbsd_mips64.s index b7a25135..fae140b6 100644 --- a/services/vendor/golang.org/x/sys/unix/zsyscall_openbsd_mips64.s +++ b/services/vendor/golang.org/x/sys/unix/zsyscall_openbsd_mips64.s @@ -463,11 +463,6 @@ TEXT libc_mknodat_trampoline<>(SB),NOSPLIT,$0-0 GLOBL ·libc_mknodat_trampoline_addr(SB), RODATA, $8 DATA ·libc_mknodat_trampoline_addr(SB)/8, $libc_mknodat_trampoline<>(SB) -TEXT libc_mount_trampoline<>(SB),NOSPLIT,$0-0 - JMP libc_mount(SB) -GLOBL ·libc_mount_trampoline_addr(SB), RODATA, $8 -DATA ·libc_mount_trampoline_addr(SB)/8, $libc_mount_trampoline<>(SB) - TEXT libc_nanosleep_trampoline<>(SB),NOSPLIT,$0-0 JMP libc_nanosleep(SB) GLOBL ·libc_nanosleep_trampoline_addr(SB), RODATA, $8 diff --git a/services/vendor/golang.org/x/sys/unix/zsyscall_openbsd_ppc64.go b/services/vendor/golang.org/x/sys/unix/zsyscall_openbsd_ppc64.go index 6e85b0aa..00831354 100644 --- a/services/vendor/golang.org/x/sys/unix/zsyscall_openbsd_ppc64.go +++ b/services/vendor/golang.org/x/sys/unix/zsyscall_openbsd_ppc64.go @@ -1493,30 +1493,6 @@ var libc_mknodat_trampoline_addr uintptr // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func Mount(fsType string, dir string, flags int, data unsafe.Pointer) (err error) { - var _p0 *byte - _p0, err = BytePtrFromString(fsType) - if err != nil { - return - } - var _p1 *byte - _p1, err = BytePtrFromString(dir) - if err != nil { - return - } - _, _, e1 := syscall_syscall6(libc_mount_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(flags), uintptr(data), 0, 0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -var libc_mount_trampoline_addr uintptr - -//go:cgo_import_dynamic libc_mount mount "libc.so" - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - func Nanosleep(time *Timespec, leftover *Timespec) (err error) { _, _, e1 := syscall_syscall(libc_nanosleep_trampoline_addr, uintptr(unsafe.Pointer(time)), uintptr(unsafe.Pointer(leftover)), 0) if e1 != 0 { diff --git a/services/vendor/golang.org/x/sys/unix/zsyscall_openbsd_ppc64.s b/services/vendor/golang.org/x/sys/unix/zsyscall_openbsd_ppc64.s index f15dadf0..9d1e0ff0 100644 --- a/services/vendor/golang.org/x/sys/unix/zsyscall_openbsd_ppc64.s +++ b/services/vendor/golang.org/x/sys/unix/zsyscall_openbsd_ppc64.s @@ -555,12 +555,6 @@ TEXT libc_mknodat_trampoline<>(SB),NOSPLIT,$0-0 GLOBL ·libc_mknodat_trampoline_addr(SB), RODATA, $8 DATA ·libc_mknodat_trampoline_addr(SB)/8, $libc_mknodat_trampoline<>(SB) -TEXT libc_mount_trampoline<>(SB),NOSPLIT,$0-0 - CALL libc_mount(SB) - RET -GLOBL ·libc_mount_trampoline_addr(SB), RODATA, $8 -DATA ·libc_mount_trampoline_addr(SB)/8, $libc_mount_trampoline<>(SB) - TEXT libc_nanosleep_trampoline<>(SB),NOSPLIT,$0-0 CALL libc_nanosleep(SB) RET diff --git a/services/vendor/golang.org/x/sys/unix/zsyscall_openbsd_riscv64.go b/services/vendor/golang.org/x/sys/unix/zsyscall_openbsd_riscv64.go index 28b487df..79029ed5 100644 --- a/services/vendor/golang.org/x/sys/unix/zsyscall_openbsd_riscv64.go +++ b/services/vendor/golang.org/x/sys/unix/zsyscall_openbsd_riscv64.go @@ -1493,30 +1493,6 @@ var libc_mknodat_trampoline_addr uintptr // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func Mount(fsType string, dir string, flags int, data unsafe.Pointer) (err error) { - var _p0 *byte - _p0, err = BytePtrFromString(fsType) - if err != nil { - return - } - var _p1 *byte - _p1, err = BytePtrFromString(dir) - if err != nil { - return - } - _, _, e1 := syscall_syscall6(libc_mount_trampoline_addr, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(flags), uintptr(data), 0, 0) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -var libc_mount_trampoline_addr uintptr - -//go:cgo_import_dynamic libc_mount mount "libc.so" - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - func Nanosleep(time *Timespec, leftover *Timespec) (err error) { _, _, e1 := syscall_syscall(libc_nanosleep_trampoline_addr, uintptr(unsafe.Pointer(time)), uintptr(unsafe.Pointer(leftover)), 0) if e1 != 0 { diff --git a/services/vendor/golang.org/x/sys/unix/zsyscall_openbsd_riscv64.s b/services/vendor/golang.org/x/sys/unix/zsyscall_openbsd_riscv64.s index 1e7f321e..da115f9a 100644 --- a/services/vendor/golang.org/x/sys/unix/zsyscall_openbsd_riscv64.s +++ b/services/vendor/golang.org/x/sys/unix/zsyscall_openbsd_riscv64.s @@ -463,11 +463,6 @@ TEXT libc_mknodat_trampoline<>(SB),NOSPLIT,$0-0 GLOBL ·libc_mknodat_trampoline_addr(SB), RODATA, $8 DATA ·libc_mknodat_trampoline_addr(SB)/8, $libc_mknodat_trampoline<>(SB) -TEXT libc_mount_trampoline<>(SB),NOSPLIT,$0-0 - JMP libc_mount(SB) -GLOBL ·libc_mount_trampoline_addr(SB), RODATA, $8 -DATA ·libc_mount_trampoline_addr(SB)/8, $libc_mount_trampoline<>(SB) - TEXT libc_nanosleep_trampoline<>(SB),NOSPLIT,$0-0 JMP libc_nanosleep(SB) GLOBL ·libc_nanosleep_trampoline_addr(SB), RODATA, $8 diff --git a/services/vendor/golang.org/x/sys/unix/zsyscall_zos_s390x.go b/services/vendor/golang.org/x/sys/unix/zsyscall_zos_s390x.go index 7ccf66b7..94f01123 100644 --- a/services/vendor/golang.org/x/sys/unix/zsyscall_zos_s390x.go +++ b/services/vendor/golang.org/x/sys/unix/zsyscall_zos_s390x.go @@ -1,4 +1,4 @@ -// go run mksyscall_zos_s390x.go -o_sysnum zsysnum_zos_s390x.go -o_syscall zsyscall_zos_s390x.go -i_syscall syscall_zos_s390x.go -o_asm zsymaddr_zos_s390x.s +// go run mksyscall.go -tags zos,s390x syscall_zos_s390x.go // Code generated by the command above; see README.md. DO NOT EDIT. //go:build zos && s390x @@ -6,100 +6,17 @@ package unix import ( - "runtime" - "syscall" "unsafe" ) -var _ syscall.Errno - // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT func fcntl(fd int, cmd int, arg int) (val int, err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_FCNTL<<4, uintptr(fd), uintptr(cmd), uintptr(arg)) - runtime.ExitSyscall() + r0, _, e1 := syscall_syscall(SYS_FCNTL, uintptr(fd), uintptr(cmd), uintptr(arg)) val = int(r0) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func impl_Flistxattr(fd int, dest []byte) (sz int, err error) { - var _p0 unsafe.Pointer - if len(dest) > 0 { - _p0 = unsafe.Pointer(&dest[0]) - } else { - _p0 = unsafe.Pointer(&_zero) - } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___FLISTXATTR_A<<4, uintptr(fd), uintptr(_p0), uintptr(len(dest))) - runtime.ExitSyscall() - sz = int(r0) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -//go:nosplit -func get_FlistxattrAddr() *(func(fd int, dest []byte) (sz int, err error)) - -var Flistxattr = enter_Flistxattr - -func enter_Flistxattr(fd int, dest []byte) (sz int, err error) { - funcref := get_FlistxattrAddr() - if funcptrtest(GetZosLibVec()+SYS___FLISTXATTR_A<<4, "") == 0 { - *funcref = impl_Flistxattr - } else { - *funcref = error_Flistxattr - } - return (*funcref)(fd, dest) -} - -func error_Flistxattr(fd int, dest []byte) (sz int, err error) { - sz = -1 - err = ENOSYS - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func impl_Fremovexattr(fd int, attr string) (err error) { - var _p0 *byte - _p0, err = BytePtrFromString(attr) - if err != nil { - return - } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___FREMOVEXATTR_A<<4, uintptr(fd), uintptr(unsafe.Pointer(_p0))) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -//go:nosplit -func get_FremovexattrAddr() *(func(fd int, attr string) (err error)) - -var Fremovexattr = enter_Fremovexattr - -func enter_Fremovexattr(fd int, attr string) (err error) { - funcref := get_FremovexattrAddr() - if funcptrtest(GetZosLibVec()+SYS___FREMOVEXATTR_A<<4, "") == 0 { - *funcref = impl_Fremovexattr - } else { - *funcref = error_Fremovexattr + if e1 != 0 { + err = errnoErr(e1) } - return (*funcref)(fd, attr) -} - -func error_Fremovexattr(fd int, attr string) (err error) { - err = ENOSYS return } @@ -112,12 +29,10 @@ func read(fd int, p []byte) (n int, err error) { } else { _p0 = unsafe.Pointer(&_zero) } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_READ<<4, uintptr(fd), uintptr(_p0), uintptr(len(p))) - runtime.ExitSyscall() + r0, _, e1 := syscall_syscall(SYS_READ, uintptr(fd), uintptr(_p0), uintptr(len(p))) n = int(r0) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) + if e1 != 0 { + err = errnoErr(e1) } return } @@ -131,159 +46,31 @@ func write(fd int, p []byte) (n int, err error) { } else { _p0 = unsafe.Pointer(&_zero) } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_WRITE<<4, uintptr(fd), uintptr(_p0), uintptr(len(p))) - runtime.ExitSyscall() + r0, _, e1 := syscall_syscall(SYS_WRITE, uintptr(fd), uintptr(_p0), uintptr(len(p))) n = int(r0) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func impl_Fgetxattr(fd int, attr string, dest []byte) (sz int, err error) { - var _p0 *byte - _p0, err = BytePtrFromString(attr) - if err != nil { - return - } - var _p1 unsafe.Pointer - if len(dest) > 0 { - _p1 = unsafe.Pointer(&dest[0]) - } else { - _p1 = unsafe.Pointer(&_zero) - } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___FGETXATTR_A<<4, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(dest))) - runtime.ExitSyscall() - sz = int(r0) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -//go:nosplit -func get_FgetxattrAddr() *(func(fd int, attr string, dest []byte) (sz int, err error)) - -var Fgetxattr = enter_Fgetxattr - -func enter_Fgetxattr(fd int, attr string, dest []byte) (sz int, err error) { - funcref := get_FgetxattrAddr() - if funcptrtest(GetZosLibVec()+SYS___FGETXATTR_A<<4, "") == 0 { - *funcref = impl_Fgetxattr - } else { - *funcref = error_Fgetxattr - } - return (*funcref)(fd, attr, dest) -} - -func error_Fgetxattr(fd int, attr string, dest []byte) (sz int, err error) { - sz = -1 - err = ENOSYS - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func impl_Fsetxattr(fd int, attr string, data []byte, flag int) (err error) { - var _p0 *byte - _p0, err = BytePtrFromString(attr) - if err != nil { - return - } - var _p1 unsafe.Pointer - if len(data) > 0 { - _p1 = unsafe.Pointer(&data[0]) - } else { - _p1 = unsafe.Pointer(&_zero) - } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___FSETXATTR_A<<4, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(data)), uintptr(flag)) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -//go:nosplit -func get_FsetxattrAddr() *(func(fd int, attr string, data []byte, flag int) (err error)) - -var Fsetxattr = enter_Fsetxattr - -func enter_Fsetxattr(fd int, attr string, data []byte, flag int) (err error) { - funcref := get_FsetxattrAddr() - if funcptrtest(GetZosLibVec()+SYS___FSETXATTR_A<<4, "") == 0 { - *funcref = impl_Fsetxattr - } else { - *funcref = error_Fsetxattr + if e1 != 0 { + err = errnoErr(e1) } - return (*funcref)(fd, attr, data, flag) -} - -func error_Fsetxattr(fd int, attr string, data []byte, flag int) (err error) { - err = ENOSYS return } // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT func accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___ACCEPT_A<<4, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen))) - runtime.ExitSyscall() - fd = int(r0) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func impl_accept4(s int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (fd int, err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___ACCEPT4_A<<4, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)), uintptr(flags)) - runtime.ExitSyscall() + r0, _, e1 := syscall_syscall(SYS___ACCEPT_A, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen))) fd = int(r0) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -//go:nosplit -func get_accept4Addr() *(func(s int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (fd int, err error)) - -var accept4 = enter_accept4 - -func enter_accept4(s int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (fd int, err error) { - funcref := get_accept4Addr() - if funcptrtest(GetZosLibVec()+SYS___ACCEPT4_A<<4, "") == 0 { - *funcref = impl_accept4 - } else { - *funcref = error_accept4 + if e1 != 0 { + err = errnoErr(e1) } - return (*funcref)(s, rsa, addrlen, flags) -} - -func error_accept4(s int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (fd int, err error) { - fd = -1 - err = ENOSYS return } // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___BIND_A<<4, uintptr(s), uintptr(addr), uintptr(addrlen)) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) + _, _, e1 := syscall_syscall(SYS___BIND_A, uintptr(s), uintptr(addr), uintptr(addrlen)) + if e1 != 0 { + err = errnoErr(e1) } return } @@ -291,11 +78,9 @@ func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___CONNECT_A<<4, uintptr(s), uintptr(addr), uintptr(addrlen)) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) + _, _, e1 := syscall_syscall(SYS___CONNECT_A, uintptr(s), uintptr(addr), uintptr(addrlen)) + if e1 != 0 { + err = errnoErr(e1) } return } @@ -303,10 +88,10 @@ func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT func getgroups(n int, list *_Gid_t) (nn int, err error) { - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_GETGROUPS<<4, uintptr(n), uintptr(unsafe.Pointer(list))) + r0, _, e1 := syscall_rawsyscall(SYS_GETGROUPS, uintptr(n), uintptr(unsafe.Pointer(list)), 0) nn = int(r0) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) + if e1 != 0 { + err = errnoErr(e1) } return } @@ -314,9 +99,9 @@ func getgroups(n int, list *_Gid_t) (nn int, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT func setgroups(n int, list *_Gid_t) (err error) { - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_SETGROUPS<<4, uintptr(n), uintptr(unsafe.Pointer(list))) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) + _, _, e1 := syscall_rawsyscall(SYS_SETGROUPS, uintptr(n), uintptr(unsafe.Pointer(list)), 0) + if e1 != 0 { + err = errnoErr(e1) } return } @@ -324,11 +109,9 @@ func setgroups(n int, list *_Gid_t) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_GETSOCKOPT<<4, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen))) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) + _, _, e1 := syscall_syscall6(SYS_GETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0) + if e1 != 0 { + err = errnoErr(e1) } return } @@ -336,11 +119,9 @@ func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_SETSOCKOPT<<4, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen)) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) + _, _, e1 := syscall_syscall6(SYS_SETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0) + if e1 != 0 { + err = errnoErr(e1) } return } @@ -348,10 +129,10 @@ func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT func socket(domain int, typ int, proto int) (fd int, err error) { - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_SOCKET<<4, uintptr(domain), uintptr(typ), uintptr(proto)) + r0, _, e1 := syscall_rawsyscall(SYS_SOCKET, uintptr(domain), uintptr(typ), uintptr(proto)) fd = int(r0) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) + if e1 != 0 { + err = errnoErr(e1) } return } @@ -359,9 +140,9 @@ func socket(domain int, typ int, proto int) (fd int, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT func socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) { - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_SOCKETPAIR<<4, uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd))) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) + _, _, e1 := syscall_rawsyscall6(SYS_SOCKETPAIR, uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0) + if e1 != 0 { + err = errnoErr(e1) } return } @@ -369,9 +150,9 @@ func socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT func getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) { - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___GETPEERNAME_A<<4, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen))) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) + _, _, e1 := syscall_rawsyscall(SYS___GETPEERNAME_A, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen))) + if e1 != 0 { + err = errnoErr(e1) } return } @@ -379,52 +160,10 @@ func getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT func getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) { - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___GETSOCKNAME_A<<4, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen))) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func impl_Removexattr(path string, attr string) (err error) { - var _p0 *byte - _p0, err = BytePtrFromString(path) - if err != nil { - return - } - var _p1 *byte - _p1, err = BytePtrFromString(attr) - if err != nil { - return - } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___REMOVEXATTR_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1))) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -//go:nosplit -func get_RemovexattrAddr() *(func(path string, attr string) (err error)) - -var Removexattr = enter_Removexattr - -func enter_Removexattr(path string, attr string) (err error) { - funcref := get_RemovexattrAddr() - if funcptrtest(GetZosLibVec()+SYS___REMOVEXATTR_A<<4, "") == 0 { - *funcref = impl_Removexattr - } else { - *funcref = error_Removexattr + _, _, e1 := syscall_rawsyscall(SYS___GETSOCKNAME_A, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen))) + if e1 != 0 { + err = errnoErr(e1) } - return (*funcref)(path, attr) -} - -func error_Removexattr(path string, attr string) (err error) { - err = ENOSYS return } @@ -437,12 +176,10 @@ func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Sockl } else { _p0 = unsafe.Pointer(&_zero) } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___RECVFROM_A<<4, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen))) - runtime.ExitSyscall() + r0, _, e1 := syscall_syscall6(SYS___RECVFROM_A, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen))) n = int(r0) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) + if e1 != 0 { + err = errnoErr(e1) } return } @@ -456,11 +193,9 @@ func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) ( } else { _p0 = unsafe.Pointer(&_zero) } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___SENDTO_A<<4, uintptr(s), uintptr(_p0), uintptr(len(buf)), uintptr(flags), uintptr(to), uintptr(addrlen)) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) + _, _, e1 := syscall_syscall6(SYS___SENDTO_A, uintptr(s), uintptr(_p0), uintptr(len(buf)), uintptr(flags), uintptr(to), uintptr(addrlen)) + if e1 != 0 { + err = errnoErr(e1) } return } @@ -468,12 +203,10 @@ func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) ( // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___RECVMSG_A<<4, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags)) - runtime.ExitSyscall() + r0, _, e1 := syscall_syscall(SYS___RECVMSG_A, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags)) n = int(r0) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) + if e1 != 0 { + err = errnoErr(e1) } return } @@ -481,12 +214,10 @@ func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___SENDMSG_A<<4, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags)) - runtime.ExitSyscall() + r0, _, e1 := syscall_syscall(SYS___SENDMSG_A, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags)) n = int(r0) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) + if e1 != 0 { + err = errnoErr(e1) } return } @@ -494,12 +225,10 @@ func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT func mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_MMAP<<4, uintptr(addr), uintptr(length), uintptr(prot), uintptr(flag), uintptr(fd), uintptr(pos)) - runtime.ExitSyscall() + r0, _, e1 := syscall_syscall6(SYS_MMAP, uintptr(addr), uintptr(length), uintptr(prot), uintptr(flag), uintptr(fd), uintptr(pos)) ret = uintptr(r0) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) + if e1 != 0 { + err = errnoErr(e1) } return } @@ -507,11 +236,9 @@ func mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) ( // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT func munmap(addr uintptr, length uintptr) (err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_MUNMAP<<4, uintptr(addr), uintptr(length)) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) + _, _, e1 := syscall_syscall(SYS_MUNMAP, uintptr(addr), uintptr(length), 0) + if e1 != 0 { + err = errnoErr(e1) } return } @@ -519,11 +246,9 @@ func munmap(addr uintptr, length uintptr) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT func ioctl(fd int, req int, arg uintptr) (err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_IOCTL<<4, uintptr(fd), uintptr(req), uintptr(arg)) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) + _, _, e1 := syscall_syscall(SYS_IOCTL, uintptr(fd), uintptr(req), uintptr(arg)) + if e1 != 0 { + err = errnoErr(e1) } return } @@ -531,62 +256,9 @@ func ioctl(fd int, req int, arg uintptr) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT func ioctlPtr(fd int, req int, arg unsafe.Pointer) (err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_IOCTL<<4, uintptr(fd), uintptr(req), uintptr(arg)) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func shmat(id int, addr uintptr, flag int) (ret uintptr, err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_SHMAT<<4, uintptr(id), uintptr(addr), uintptr(flag)) - runtime.ExitSyscall() - ret = uintptr(r0) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func shmctl(id int, cmd int, buf *SysvShmDesc) (result int, err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_SHMCTL64<<4, uintptr(id), uintptr(cmd), uintptr(unsafe.Pointer(buf))) - runtime.ExitSyscall() - result = int(r0) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func shmdt(addr uintptr) (err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_SHMDT<<4, uintptr(addr)) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func shmget(key int, size int, flag int) (id int, err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_SHMGET<<4, uintptr(key), uintptr(size), uintptr(flag)) - runtime.ExitSyscall() - id = int(r0) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) + _, _, e1 := syscall_syscall(SYS_IOCTL, uintptr(fd), uintptr(req), uintptr(arg)) + if e1 != 0 { + err = errnoErr(e1) } return } @@ -599,11 +271,9 @@ func Access(path string, mode uint32) (err error) { if err != nil { return } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___ACCESS_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(mode)) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) + _, _, e1 := syscall_syscall(SYS___ACCESS_A, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0) + if e1 != 0 { + err = errnoErr(e1) } return } @@ -616,11 +286,9 @@ func Chdir(path string) (err error) { if err != nil { return } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___CHDIR_A<<4, uintptr(unsafe.Pointer(_p0))) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) + _, _, e1 := syscall_syscall(SYS___CHDIR_A, uintptr(unsafe.Pointer(_p0)), 0, 0) + if e1 != 0 { + err = errnoErr(e1) } return } @@ -633,11 +301,9 @@ func Chown(path string, uid int, gid int) (err error) { if err != nil { return } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___CHOWN_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid)) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) + _, _, e1 := syscall_syscall(SYS___CHOWN_A, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid)) + if e1 != 0 { + err = errnoErr(e1) } return } @@ -650,11 +316,9 @@ func Chmod(path string, mode uint32) (err error) { if err != nil { return } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___CHMOD_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(mode)) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) + _, _, e1 := syscall_syscall(SYS___CHMOD_A, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0) + if e1 != 0 { + err = errnoErr(e1) } return } @@ -667,12 +331,10 @@ func Creat(path string, mode uint32) (fd int, err error) { if err != nil { return } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___CREAT_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(mode)) - runtime.ExitSyscall() + r0, _, e1 := syscall_syscall(SYS___CREAT_A, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0) fd = int(r0) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) + if e1 != 0 { + err = errnoErr(e1) } return } @@ -680,12 +342,10 @@ func Creat(path string, mode uint32) (fd int, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT func Dup(oldfd int) (fd int, err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_DUP<<4, uintptr(oldfd)) - runtime.ExitSyscall() + r0, _, e1 := syscall_syscall(SYS_DUP, uintptr(oldfd), 0, 0) fd = int(r0) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) + if e1 != 0 { + err = errnoErr(e1) } return } @@ -693,2216 +353,617 @@ func Dup(oldfd int) (fd int, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT func Dup2(oldfd int, newfd int) (err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_DUP2<<4, uintptr(oldfd), uintptr(newfd)) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) + _, _, e1 := syscall_syscall(SYS_DUP2, uintptr(oldfd), uintptr(newfd), 0) + if e1 != 0 { + err = errnoErr(e1) } return } // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func impl_Dup3(oldfd int, newfd int, flags int) (err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_DUP3<<4, uintptr(oldfd), uintptr(newfd), uintptr(flags)) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } +func Errno2() (er2 int) { + uer2, _, _ := syscall_syscall(SYS___ERRNO2, 0, 0, 0) + er2 = int(uer2) return } -//go:nosplit -func get_Dup3Addr() *(func(oldfd int, newfd int, flags int) (err error)) - -var Dup3 = enter_Dup3 +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func enter_Dup3(oldfd int, newfd int, flags int) (err error) { - funcref := get_Dup3Addr() - if funcptrtest(GetZosLibVec()+SYS_DUP3<<4, "") == 0 { - *funcref = impl_Dup3 - } else { - *funcref = error_Dup3 - } - return (*funcref)(oldfd, newfd, flags) +func Err2ad() (eadd *int) { + ueadd, _, _ := syscall_syscall(SYS___ERR2AD, 0, 0, 0) + eadd = (*int)(unsafe.Pointer(ueadd)) + return } -func error_Dup3(oldfd int, newfd int, flags int) (err error) { - err = ENOSYS +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func Exit(code int) { + syscall_syscall(SYS_EXIT, uintptr(code), 0, 0) return } // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func impl_Dirfd(dirp uintptr) (fd int, err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_DIRFD<<4, uintptr(dirp)) - runtime.ExitSyscall() - fd = int(r0) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) +func Fchdir(fd int) (err error) { + _, _, e1 := syscall_syscall(SYS_FCHDIR, uintptr(fd), 0, 0) + if e1 != 0 { + err = errnoErr(e1) } return } -//go:nosplit -func get_DirfdAddr() *(func(dirp uintptr) (fd int, err error)) - -var Dirfd = enter_Dirfd +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func enter_Dirfd(dirp uintptr) (fd int, err error) { - funcref := get_DirfdAddr() - if funcptrtest(GetZosLibVec()+SYS_DIRFD<<4, "") == 0 { - *funcref = impl_Dirfd - } else { - *funcref = error_Dirfd +func Fchmod(fd int, mode uint32) (err error) { + _, _, e1 := syscall_syscall(SYS_FCHMOD, uintptr(fd), uintptr(mode), 0) + if e1 != 0 { + err = errnoErr(e1) } - return (*funcref)(dirp) -} - -func error_Dirfd(dirp uintptr) (fd int, err error) { - fd = -1 - err = ENOSYS return } // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func impl_EpollCreate(size int) (fd int, err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_EPOLL_CREATE<<4, uintptr(size)) - runtime.ExitSyscall() - fd = int(r0) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) +func Fchown(fd int, uid int, gid int) (err error) { + _, _, e1 := syscall_syscall(SYS_FCHOWN, uintptr(fd), uintptr(uid), uintptr(gid)) + if e1 != 0 { + err = errnoErr(e1) } return } -//go:nosplit -func get_EpollCreateAddr() *(func(size int) (fd int, err error)) - -var EpollCreate = enter_EpollCreate +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func enter_EpollCreate(size int) (fd int, err error) { - funcref := get_EpollCreateAddr() - if funcptrtest(GetZosLibVec()+SYS_EPOLL_CREATE<<4, "") == 0 { - *funcref = impl_EpollCreate - } else { - *funcref = error_EpollCreate +func FcntlInt(fd uintptr, cmd int, arg int) (retval int, err error) { + r0, _, e1 := syscall_syscall(SYS_FCNTL, uintptr(fd), uintptr(cmd), uintptr(arg)) + retval = int(r0) + if e1 != 0 { + err = errnoErr(e1) } - return (*funcref)(size) -} - -func error_EpollCreate(size int) (fd int, err error) { - fd = -1 - err = ENOSYS return } // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func impl_EpollCreate1(flags int) (fd int, err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_EPOLL_CREATE1<<4, uintptr(flags)) - runtime.ExitSyscall() - fd = int(r0) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) +func fstat(fd int, stat *Stat_LE_t) (err error) { + _, _, e1 := syscall_syscall(SYS_FSTAT, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0) + if e1 != 0 { + err = errnoErr(e1) } return } -//go:nosplit -func get_EpollCreate1Addr() *(func(flags int) (fd int, err error)) - -var EpollCreate1 = enter_EpollCreate1 +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func enter_EpollCreate1(flags int) (fd int, err error) { - funcref := get_EpollCreate1Addr() - if funcptrtest(GetZosLibVec()+SYS_EPOLL_CREATE1<<4, "") == 0 { - *funcref = impl_EpollCreate1 - } else { - *funcref = error_EpollCreate1 +func Fstatvfs(fd int, stat *Statvfs_t) (err error) { + _, _, e1 := syscall_syscall(SYS_FSTATVFS, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0) + if e1 != 0 { + err = errnoErr(e1) } - return (*funcref)(flags) -} - -func error_EpollCreate1(flags int) (fd int, err error) { - fd = -1 - err = ENOSYS return } // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func impl_EpollCtl(epfd int, op int, fd int, event *EpollEvent) (err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_EPOLL_CTL<<4, uintptr(epfd), uintptr(op), uintptr(fd), uintptr(unsafe.Pointer(event))) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) +func Fsync(fd int) (err error) { + _, _, e1 := syscall_syscall(SYS_FSYNC, uintptr(fd), 0, 0) + if e1 != 0 { + err = errnoErr(e1) } return } -//go:nosplit -func get_EpollCtlAddr() *(func(epfd int, op int, fd int, event *EpollEvent) (err error)) - -var EpollCtl = enter_EpollCtl +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func enter_EpollCtl(epfd int, op int, fd int, event *EpollEvent) (err error) { - funcref := get_EpollCtlAddr() - if funcptrtest(GetZosLibVec()+SYS_EPOLL_CTL<<4, "") == 0 { - *funcref = impl_EpollCtl - } else { - *funcref = error_EpollCtl +func Ftruncate(fd int, length int64) (err error) { + _, _, e1 := syscall_syscall(SYS_FTRUNCATE, uintptr(fd), uintptr(length), 0) + if e1 != 0 { + err = errnoErr(e1) } - return (*funcref)(epfd, op, fd, event) + return } -func error_EpollCtl(epfd int, op int, fd int, event *EpollEvent) (err error) { - err = ENOSYS +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func Getpagesize() (pgsize int) { + r0, _, _ := syscall_syscall(SYS_GETPAGESIZE, 0, 0, 0) + pgsize = int(r0) return } // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func impl_EpollPwait(epfd int, events []EpollEvent, msec int, sigmask *int) (n int, err error) { +func Mprotect(b []byte, prot int) (err error) { var _p0 unsafe.Pointer - if len(events) > 0 { - _p0 = unsafe.Pointer(&events[0]) + if len(b) > 0 { + _p0 = unsafe.Pointer(&b[0]) } else { _p0 = unsafe.Pointer(&_zero) } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_EPOLL_PWAIT<<4, uintptr(epfd), uintptr(_p0), uintptr(len(events)), uintptr(msec), uintptr(unsafe.Pointer(sigmask))) - runtime.ExitSyscall() - n = int(r0) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) + _, _, e1 := syscall_syscall(SYS_MPROTECT, uintptr(_p0), uintptr(len(b)), uintptr(prot)) + if e1 != 0 { + err = errnoErr(e1) } return } -//go:nosplit -func get_EpollPwaitAddr() *(func(epfd int, events []EpollEvent, msec int, sigmask *int) (n int, err error)) - -var EpollPwait = enter_EpollPwait +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func enter_EpollPwait(epfd int, events []EpollEvent, msec int, sigmask *int) (n int, err error) { - funcref := get_EpollPwaitAddr() - if funcptrtest(GetZosLibVec()+SYS_EPOLL_PWAIT<<4, "") == 0 { - *funcref = impl_EpollPwait +func Msync(b []byte, flags int) (err error) { + var _p0 unsafe.Pointer + if len(b) > 0 { + _p0 = unsafe.Pointer(&b[0]) } else { - *funcref = error_EpollPwait + _p0 = unsafe.Pointer(&_zero) + } + _, _, e1 := syscall_syscall(SYS_MSYNC, uintptr(_p0), uintptr(len(b)), uintptr(flags)) + if e1 != 0 { + err = errnoErr(e1) } - return (*funcref)(epfd, events, msec, sigmask) -} - -func error_EpollPwait(epfd int, events []EpollEvent, msec int, sigmask *int) (n int, err error) { - n = -1 - err = ENOSYS return } // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func impl_EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error) { +func Poll(fds []PollFd, timeout int) (n int, err error) { var _p0 unsafe.Pointer - if len(events) > 0 { - _p0 = unsafe.Pointer(&events[0]) + if len(fds) > 0 { + _p0 = unsafe.Pointer(&fds[0]) } else { _p0 = unsafe.Pointer(&_zero) } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_EPOLL_WAIT<<4, uintptr(epfd), uintptr(_p0), uintptr(len(events)), uintptr(msec)) - runtime.ExitSyscall() + r0, _, e1 := syscall_syscall(SYS_POLL, uintptr(_p0), uintptr(len(fds)), uintptr(timeout)) n = int(r0) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -//go:nosplit -func get_EpollWaitAddr() *(func(epfd int, events []EpollEvent, msec int) (n int, err error)) - -var EpollWait = enter_EpollWait - -func enter_EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error) { - funcref := get_EpollWaitAddr() - if funcptrtest(GetZosLibVec()+SYS_EPOLL_WAIT<<4, "") == 0 { - *funcref = impl_EpollWait - } else { - *funcref = error_EpollWait + if e1 != 0 { + err = errnoErr(e1) } - return (*funcref)(epfd, events, msec) -} - -func error_EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error) { - n = -1 - err = ENOSYS - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func Errno2() (er2 int) { - runtime.EnterSyscall() - r0, _, _ := CallLeFuncWithErr(GetZosLibVec() + SYS___ERRNO2<<4) - runtime.ExitSyscall() - er2 = int(r0) return } // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func impl_Eventfd(initval uint, flags int) (fd int, err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_EVENTFD<<4, uintptr(initval), uintptr(flags)) - runtime.ExitSyscall() - fd = int(r0) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) +func Times(tms *Tms) (ticks uintptr, err error) { + r0, _, e1 := syscall_syscall(SYS_TIMES, uintptr(unsafe.Pointer(tms)), 0, 0) + ticks = uintptr(r0) + if e1 != 0 { + err = errnoErr(e1) } return } -//go:nosplit -func get_EventfdAddr() *(func(initval uint, flags int) (fd int, err error)) - -var Eventfd = enter_Eventfd +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func enter_Eventfd(initval uint, flags int) (fd int, err error) { - funcref := get_EventfdAddr() - if funcptrtest(GetZosLibVec()+SYS_EVENTFD<<4, "") == 0 { - *funcref = impl_Eventfd - } else { - *funcref = error_Eventfd +func W_Getmntent(buff *byte, size int) (lastsys int, err error) { + r0, _, e1 := syscall_syscall(SYS_W_GETMNTENT, uintptr(unsafe.Pointer(buff)), uintptr(size), 0) + lastsys = int(r0) + if e1 != 0 { + err = errnoErr(e1) } - return (*funcref)(initval, flags) -} - -func error_Eventfd(initval uint, flags int) (fd int, err error) { - fd = -1 - err = ENOSYS return } // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func Exit(code int) { - runtime.EnterSyscall() - CallLeFuncWithErr(GetZosLibVec()+SYS_EXIT<<4, uintptr(code)) - runtime.ExitSyscall() +func W_Getmntent_A(buff *byte, size int) (lastsys int, err error) { + r0, _, e1 := syscall_syscall(SYS___W_GETMNTENT_A, uintptr(unsafe.Pointer(buff)), uintptr(size), 0) + lastsys = int(r0) + if e1 != 0 { + err = errnoErr(e1) + } return } // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func impl_Faccessat(dirfd int, path string, mode uint32, flags int) (err error) { +func mount_LE(path string, filesystem string, fstype string, mtm uint32, parmlen int32, parm string) (err error) { var _p0 *byte _p0, err = BytePtrFromString(path) if err != nil { return } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___FACCESSAT_A<<4, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags)) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) + var _p1 *byte + _p1, err = BytePtrFromString(filesystem) + if err != nil { + return + } + var _p2 *byte + _p2, err = BytePtrFromString(fstype) + if err != nil { + return + } + var _p3 *byte + _p3, err = BytePtrFromString(parm) + if err != nil { + return + } + _, _, e1 := syscall_syscall6(SYS___MOUNT_A, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(unsafe.Pointer(_p2)), uintptr(mtm), uintptr(parmlen), uintptr(unsafe.Pointer(_p3))) + if e1 != 0 { + err = errnoErr(e1) } return } -//go:nosplit -func get_FaccessatAddr() *(func(dirfd int, path string, mode uint32, flags int) (err error)) +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -var Faccessat = enter_Faccessat - -func enter_Faccessat(dirfd int, path string, mode uint32, flags int) (err error) { - funcref := get_FaccessatAddr() - if funcptrtest(GetZosLibVec()+SYS___FACCESSAT_A<<4, "") == 0 { - *funcref = impl_Faccessat - } else { - *funcref = error_Faccessat - } - return (*funcref)(dirfd, path, mode, flags) -} - -func error_Faccessat(dirfd int, path string, mode uint32, flags int) (err error) { - err = ENOSYS - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func Fchdir(fd int) (err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_FCHDIR<<4, uintptr(fd)) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func Fchmod(fd int, mode uint32) (err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_FCHMOD<<4, uintptr(fd), uintptr(mode)) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func impl_Fchmodat(dirfd int, path string, mode uint32, flags int) (err error) { - var _p0 *byte - _p0, err = BytePtrFromString(path) - if err != nil { - return - } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___FCHMODAT_A<<4, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags)) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -//go:nosplit -func get_FchmodatAddr() *(func(dirfd int, path string, mode uint32, flags int) (err error)) - -var Fchmodat = enter_Fchmodat - -func enter_Fchmodat(dirfd int, path string, mode uint32, flags int) (err error) { - funcref := get_FchmodatAddr() - if funcptrtest(GetZosLibVec()+SYS___FCHMODAT_A<<4, "") == 0 { - *funcref = impl_Fchmodat - } else { - *funcref = error_Fchmodat - } - return (*funcref)(dirfd, path, mode, flags) -} - -func error_Fchmodat(dirfd int, path string, mode uint32, flags int) (err error) { - err = ENOSYS - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func Fchown(fd int, uid int, gid int) (err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_FCHOWN<<4, uintptr(fd), uintptr(uid), uintptr(gid)) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func impl_Fchownat(fd int, path string, uid int, gid int, flags int) (err error) { - var _p0 *byte - _p0, err = BytePtrFromString(path) - if err != nil { - return - } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___FCHOWNAT_A<<4, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid), uintptr(flags)) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -//go:nosplit -func get_FchownatAddr() *(func(fd int, path string, uid int, gid int, flags int) (err error)) - -var Fchownat = enter_Fchownat - -func enter_Fchownat(fd int, path string, uid int, gid int, flags int) (err error) { - funcref := get_FchownatAddr() - if funcptrtest(GetZosLibVec()+SYS___FCHOWNAT_A<<4, "") == 0 { - *funcref = impl_Fchownat - } else { - *funcref = error_Fchownat - } - return (*funcref)(fd, path, uid, gid, flags) -} - -func error_Fchownat(fd int, path string, uid int, gid int, flags int) (err error) { - err = ENOSYS - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func FcntlInt(fd uintptr, cmd int, arg int) (retval int, err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_FCNTL<<4, uintptr(fd), uintptr(cmd), uintptr(arg)) - runtime.ExitSyscall() - retval = int(r0) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func impl_Fdatasync(fd int) (err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_FDATASYNC<<4, uintptr(fd)) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -//go:nosplit -func get_FdatasyncAddr() *(func(fd int) (err error)) - -var Fdatasync = enter_Fdatasync - -func enter_Fdatasync(fd int) (err error) { - funcref := get_FdatasyncAddr() - if funcptrtest(GetZosLibVec()+SYS_FDATASYNC<<4, "") == 0 { - *funcref = impl_Fdatasync - } else { - *funcref = error_Fdatasync - } - return (*funcref)(fd) -} - -func error_Fdatasync(fd int) (err error) { - err = ENOSYS - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func fstat(fd int, stat *Stat_LE_t) (err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_FSTAT<<4, uintptr(fd), uintptr(unsafe.Pointer(stat))) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func impl_fstatat(dirfd int, path string, stat *Stat_LE_t, flags int) (err error) { - var _p0 *byte - _p0, err = BytePtrFromString(path) - if err != nil { - return - } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___FSTATAT_A<<4, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), uintptr(flags)) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -//go:nosplit -func get_fstatatAddr() *(func(dirfd int, path string, stat *Stat_LE_t, flags int) (err error)) - -var fstatat = enter_fstatat - -func enter_fstatat(dirfd int, path string, stat *Stat_LE_t, flags int) (err error) { - funcref := get_fstatatAddr() - if funcptrtest(GetZosLibVec()+SYS___FSTATAT_A<<4, "") == 0 { - *funcref = impl_fstatat - } else { - *funcref = error_fstatat - } - return (*funcref)(dirfd, path, stat, flags) -} - -func error_fstatat(dirfd int, path string, stat *Stat_LE_t, flags int) (err error) { - err = ENOSYS - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func impl_Lgetxattr(link string, attr string, dest []byte) (sz int, err error) { +func unmount(filesystem string, mtm int) (err error) { var _p0 *byte - _p0, err = BytePtrFromString(link) - if err != nil { - return - } - var _p1 *byte - _p1, err = BytePtrFromString(attr) + _p0, err = BytePtrFromString(filesystem) if err != nil { return } - var _p2 unsafe.Pointer - if len(dest) > 0 { - _p2 = unsafe.Pointer(&dest[0]) - } else { - _p2 = unsafe.Pointer(&_zero) - } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___LGETXATTR_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(_p2), uintptr(len(dest))) - runtime.ExitSyscall() - sz = int(r0) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) + _, _, e1 := syscall_syscall(SYS___UMOUNT_A, uintptr(unsafe.Pointer(_p0)), uintptr(mtm), 0) + if e1 != 0 { + err = errnoErr(e1) } return } -//go:nosplit -func get_LgetxattrAddr() *(func(link string, attr string, dest []byte) (sz int, err error)) - -var Lgetxattr = enter_Lgetxattr - -func enter_Lgetxattr(link string, attr string, dest []byte) (sz int, err error) { - funcref := get_LgetxattrAddr() - if funcptrtest(GetZosLibVec()+SYS___LGETXATTR_A<<4, "") == 0 { - *funcref = impl_Lgetxattr - } else { - *funcref = error_Lgetxattr - } - return (*funcref)(link, attr, dest) -} - -func error_Lgetxattr(link string, attr string, dest []byte) (sz int, err error) { - sz = -1 - err = ENOSYS - return -} - // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func impl_Lsetxattr(path string, attr string, data []byte, flags int) (err error) { +func Chroot(path string) (err error) { var _p0 *byte _p0, err = BytePtrFromString(path) if err != nil { return } - var _p1 *byte - _p1, err = BytePtrFromString(attr) - if err != nil { - return - } - var _p2 unsafe.Pointer - if len(data) > 0 { - _p2 = unsafe.Pointer(&data[0]) - } else { - _p2 = unsafe.Pointer(&_zero) - } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___LSETXATTR_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(_p2), uintptr(len(data)), uintptr(flags)) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -//go:nosplit -func get_LsetxattrAddr() *(func(path string, attr string, data []byte, flags int) (err error)) - -var Lsetxattr = enter_Lsetxattr - -func enter_Lsetxattr(path string, attr string, data []byte, flags int) (err error) { - funcref := get_LsetxattrAddr() - if funcptrtest(GetZosLibVec()+SYS___LSETXATTR_A<<4, "") == 0 { - *funcref = impl_Lsetxattr - } else { - *funcref = error_Lsetxattr - } - return (*funcref)(path, attr, data, flags) -} - -func error_Lsetxattr(path string, attr string, data []byte, flags int) (err error) { - err = ENOSYS - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func impl_Fstatfs(fd int, buf *Statfs_t) (err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_FSTATFS<<4, uintptr(fd), uintptr(unsafe.Pointer(buf))) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -//go:nosplit -func get_FstatfsAddr() *(func(fd int, buf *Statfs_t) (err error)) - -var Fstatfs = enter_Fstatfs - -func enter_Fstatfs(fd int, buf *Statfs_t) (err error) { - funcref := get_FstatfsAddr() - if funcptrtest(GetZosLibVec()+SYS_FSTATFS<<4, "") == 0 { - *funcref = impl_Fstatfs - } else { - *funcref = error_Fstatfs - } - return (*funcref)(fd, buf) -} - -func error_Fstatfs(fd int, buf *Statfs_t) (err error) { - err = ENOSYS - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func Fstatvfs(fd int, stat *Statvfs_t) (err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_FSTATVFS<<4, uintptr(fd), uintptr(unsafe.Pointer(stat))) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) + _, _, e1 := syscall_syscall(SYS___CHROOT_A, uintptr(unsafe.Pointer(_p0)), 0, 0) + if e1 != 0 { + err = errnoErr(e1) } return } // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func Fsync(fd int) (err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_FSYNC<<4, uintptr(fd)) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) +func Uname(buf *Utsname) (err error) { + _, _, e1 := syscall_rawsyscall(SYS___UNAME_A, uintptr(unsafe.Pointer(buf)), 0, 0) + if e1 != 0 { + err = errnoErr(e1) } return } // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func impl_Futimes(fd int, tv []Timeval) (err error) { +func Gethostname(buf []byte) (err error) { var _p0 unsafe.Pointer - if len(tv) > 0 { - _p0 = unsafe.Pointer(&tv[0]) + if len(buf) > 0 { + _p0 = unsafe.Pointer(&buf[0]) } else { _p0 = unsafe.Pointer(&_zero) } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_FUTIMES<<4, uintptr(fd), uintptr(_p0), uintptr(len(tv))) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -//go:nosplit -func get_FutimesAddr() *(func(fd int, tv []Timeval) (err error)) - -var Futimes = enter_Futimes - -func enter_Futimes(fd int, tv []Timeval) (err error) { - funcref := get_FutimesAddr() - if funcptrtest(GetZosLibVec()+SYS_FUTIMES<<4, "") == 0 { - *funcref = impl_Futimes - } else { - *funcref = error_Futimes + _, _, e1 := syscall_syscall(SYS___GETHOSTNAME_A, uintptr(_p0), uintptr(len(buf)), 0) + if e1 != 0 { + err = errnoErr(e1) } - return (*funcref)(fd, tv) -} - -func error_Futimes(fd int, tv []Timeval) (err error) { - err = ENOSYS return } // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func impl_Futimesat(dirfd int, path string, tv []Timeval) (err error) { - var _p0 *byte - _p0, err = BytePtrFromString(path) - if err != nil { - return - } - var _p1 unsafe.Pointer - if len(tv) > 0 { - _p1 = unsafe.Pointer(&tv[0]) - } else { - _p1 = unsafe.Pointer(&_zero) - } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___FUTIMESAT_A<<4, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(tv))) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -//go:nosplit -func get_FutimesatAddr() *(func(dirfd int, path string, tv []Timeval) (err error)) - -var Futimesat = enter_Futimesat - -func enter_Futimesat(dirfd int, path string, tv []Timeval) (err error) { - funcref := get_FutimesatAddr() - if funcptrtest(GetZosLibVec()+SYS___FUTIMESAT_A<<4, "") == 0 { - *funcref = impl_Futimesat - } else { - *funcref = error_Futimesat - } - return (*funcref)(dirfd, path, tv) -} - -func error_Futimesat(dirfd int, path string, tv []Timeval) (err error) { - err = ENOSYS +func Getegid() (egid int) { + r0, _, _ := syscall_rawsyscall(SYS_GETEGID, 0, 0, 0) + egid = int(r0) return } // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func Ftruncate(fd int, length int64) (err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_FTRUNCATE<<4, uintptr(fd), uintptr(length)) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } +func Geteuid() (uid int) { + r0, _, _ := syscall_rawsyscall(SYS_GETEUID, 0, 0, 0) + uid = int(r0) return } // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func impl_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) - } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_GETRANDOM<<4, uintptr(_p0), uintptr(len(buf)), uintptr(flags)) - runtime.ExitSyscall() - n = int(r0) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -//go:nosplit -func get_GetrandomAddr() *(func(buf []byte, flags int) (n int, err error)) - -var Getrandom = enter_Getrandom - -func enter_Getrandom(buf []byte, flags int) (n int, err error) { - funcref := get_GetrandomAddr() - if funcptrtest(GetZosLibVec()+SYS_GETRANDOM<<4, "") == 0 { - *funcref = impl_Getrandom - } else { - *funcref = error_Getrandom - } - return (*funcref)(buf, flags) -} - -func error_Getrandom(buf []byte, flags int) (n int, err error) { - n = -1 - err = ENOSYS +func Getgid() (gid int) { + r0, _, _ := syscall_rawsyscall(SYS_GETGID, 0, 0, 0) + gid = int(r0) return } // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func impl_InotifyInit() (fd int, err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec() + SYS_INOTIFY_INIT<<4) - runtime.ExitSyscall() - fd = int(r0) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -//go:nosplit -func get_InotifyInitAddr() *(func() (fd int, err error)) - -var InotifyInit = enter_InotifyInit - -func enter_InotifyInit() (fd int, err error) { - funcref := get_InotifyInitAddr() - if funcptrtest(GetZosLibVec()+SYS_INOTIFY_INIT<<4, "") == 0 { - *funcref = impl_InotifyInit - } else { - *funcref = error_InotifyInit - } - return (*funcref)() -} - -func error_InotifyInit() (fd int, err error) { - fd = -1 - err = ENOSYS +func Getpid() (pid int) { + r0, _, _ := syscall_rawsyscall(SYS_GETPID, 0, 0, 0) + pid = int(r0) return } // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func impl_InotifyInit1(flags int) (fd int, err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_INOTIFY_INIT1<<4, uintptr(flags)) - runtime.ExitSyscall() - fd = int(r0) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) +func Getpgid(pid int) (pgid int, err error) { + r0, _, e1 := syscall_rawsyscall(SYS_GETPGID, uintptr(pid), 0, 0) + pgid = int(r0) + if e1 != 0 { + err = errnoErr(e1) } return } -//go:nosplit -func get_InotifyInit1Addr() *(func(flags int) (fd int, err error)) - -var InotifyInit1 = enter_InotifyInit1 - -func enter_InotifyInit1(flags int) (fd int, err error) { - funcref := get_InotifyInit1Addr() - if funcptrtest(GetZosLibVec()+SYS_INOTIFY_INIT1<<4, "") == 0 { - *funcref = impl_InotifyInit1 - } else { - *funcref = error_InotifyInit1 - } - return (*funcref)(flags) -} - -func error_InotifyInit1(flags int) (fd int, err error) { - fd = -1 - err = ENOSYS - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func impl_InotifyAddWatch(fd int, pathname string, mask uint32) (watchdesc int, err error) { - var _p0 *byte - _p0, err = BytePtrFromString(pathname) - if err != nil { - return - } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___INOTIFY_ADD_WATCH_A<<4, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(mask)) - runtime.ExitSyscall() - watchdesc = int(r0) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -//go:nosplit -func get_InotifyAddWatchAddr() *(func(fd int, pathname string, mask uint32) (watchdesc int, err error)) - -var InotifyAddWatch = enter_InotifyAddWatch - -func enter_InotifyAddWatch(fd int, pathname string, mask uint32) (watchdesc int, err error) { - funcref := get_InotifyAddWatchAddr() - if funcptrtest(GetZosLibVec()+SYS___INOTIFY_ADD_WATCH_A<<4, "") == 0 { - *funcref = impl_InotifyAddWatch - } else { - *funcref = error_InotifyAddWatch - } - return (*funcref)(fd, pathname, mask) -} - -func error_InotifyAddWatch(fd int, pathname string, mask uint32) (watchdesc int, err error) { - watchdesc = -1 - err = ENOSYS - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func impl_InotifyRmWatch(fd int, watchdesc uint32) (success int, err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_INOTIFY_RM_WATCH<<4, uintptr(fd), uintptr(watchdesc)) - runtime.ExitSyscall() - success = int(r0) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -//go:nosplit -func get_InotifyRmWatchAddr() *(func(fd int, watchdesc uint32) (success int, err error)) - -var InotifyRmWatch = enter_InotifyRmWatch - -func enter_InotifyRmWatch(fd int, watchdesc uint32) (success int, err error) { - funcref := get_InotifyRmWatchAddr() - if funcptrtest(GetZosLibVec()+SYS_INOTIFY_RM_WATCH<<4, "") == 0 { - *funcref = impl_InotifyRmWatch - } else { - *funcref = error_InotifyRmWatch - } - return (*funcref)(fd, watchdesc) -} - -func error_InotifyRmWatch(fd int, watchdesc uint32) (success int, err error) { - success = -1 - err = ENOSYS - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func impl_Listxattr(path string, dest []byte) (sz int, err error) { - var _p0 *byte - _p0, err = BytePtrFromString(path) - if err != nil { - return - } - var _p1 unsafe.Pointer - if len(dest) > 0 { - _p1 = unsafe.Pointer(&dest[0]) - } else { - _p1 = unsafe.Pointer(&_zero) - } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___LISTXATTR_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(dest))) - runtime.ExitSyscall() - sz = int(r0) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -//go:nosplit -func get_ListxattrAddr() *(func(path string, dest []byte) (sz int, err error)) - -var Listxattr = enter_Listxattr - -func enter_Listxattr(path string, dest []byte) (sz int, err error) { - funcref := get_ListxattrAddr() - if funcptrtest(GetZosLibVec()+SYS___LISTXATTR_A<<4, "") == 0 { - *funcref = impl_Listxattr - } else { - *funcref = error_Listxattr - } - return (*funcref)(path, dest) -} - -func error_Listxattr(path string, dest []byte) (sz int, err error) { - sz = -1 - err = ENOSYS - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func impl_Llistxattr(path string, dest []byte) (sz int, err error) { - var _p0 *byte - _p0, err = BytePtrFromString(path) - if err != nil { - return - } - var _p1 unsafe.Pointer - if len(dest) > 0 { - _p1 = unsafe.Pointer(&dest[0]) - } else { - _p1 = unsafe.Pointer(&_zero) - } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___LLISTXATTR_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(dest))) - runtime.ExitSyscall() - sz = int(r0) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -//go:nosplit -func get_LlistxattrAddr() *(func(path string, dest []byte) (sz int, err error)) - -var Llistxattr = enter_Llistxattr - -func enter_Llistxattr(path string, dest []byte) (sz int, err error) { - funcref := get_LlistxattrAddr() - if funcptrtest(GetZosLibVec()+SYS___LLISTXATTR_A<<4, "") == 0 { - *funcref = impl_Llistxattr - } else { - *funcref = error_Llistxattr - } - return (*funcref)(path, dest) -} - -func error_Llistxattr(path string, dest []byte) (sz int, err error) { - sz = -1 - err = ENOSYS - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func impl_Lremovexattr(path string, attr string) (err error) { - var _p0 *byte - _p0, err = BytePtrFromString(path) - if err != nil { - return - } - var _p1 *byte - _p1, err = BytePtrFromString(attr) - if err != nil { - return - } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___LREMOVEXATTR_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1))) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -//go:nosplit -func get_LremovexattrAddr() *(func(path string, attr string) (err error)) - -var Lremovexattr = enter_Lremovexattr - -func enter_Lremovexattr(path string, attr string) (err error) { - funcref := get_LremovexattrAddr() - if funcptrtest(GetZosLibVec()+SYS___LREMOVEXATTR_A<<4, "") == 0 { - *funcref = impl_Lremovexattr - } else { - *funcref = error_Lremovexattr - } - return (*funcref)(path, attr) -} - -func error_Lremovexattr(path string, attr string) (err error) { - err = ENOSYS - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func impl_Lutimes(path string, tv []Timeval) (err error) { - var _p0 *byte - _p0, err = BytePtrFromString(path) - if err != nil { - return - } - var _p1 unsafe.Pointer - if len(tv) > 0 { - _p1 = unsafe.Pointer(&tv[0]) - } else { - _p1 = unsafe.Pointer(&_zero) - } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___LUTIMES_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(tv))) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -//go:nosplit -func get_LutimesAddr() *(func(path string, tv []Timeval) (err error)) - -var Lutimes = enter_Lutimes - -func enter_Lutimes(path string, tv []Timeval) (err error) { - funcref := get_LutimesAddr() - if funcptrtest(GetZosLibVec()+SYS___LUTIMES_A<<4, "") == 0 { - *funcref = impl_Lutimes - } else { - *funcref = error_Lutimes - } - return (*funcref)(path, tv) -} - -func error_Lutimes(path string, tv []Timeval) (err error) { - err = ENOSYS - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func Mprotect(b []byte, prot int) (err error) { - var _p0 unsafe.Pointer - if len(b) > 0 { - _p0 = unsafe.Pointer(&b[0]) - } else { - _p0 = unsafe.Pointer(&_zero) - } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_MPROTECT<<4, uintptr(_p0), uintptr(len(b)), uintptr(prot)) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func Msync(b []byte, flags int) (err error) { - var _p0 unsafe.Pointer - if len(b) > 0 { - _p0 = unsafe.Pointer(&b[0]) - } else { - _p0 = unsafe.Pointer(&_zero) - } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_MSYNC<<4, uintptr(_p0), uintptr(len(b)), uintptr(flags)) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func Console2(cmsg *ConsMsg2, modstr *byte, concmd *uint32) (err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___CONSOLE2<<4, uintptr(unsafe.Pointer(cmsg)), uintptr(unsafe.Pointer(modstr)), uintptr(unsafe.Pointer(concmd))) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func Poll(fds []PollFd, timeout int) (n int, err error) { - var _p0 unsafe.Pointer - if len(fds) > 0 { - _p0 = unsafe.Pointer(&fds[0]) - } else { - _p0 = unsafe.Pointer(&_zero) - } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_POLL<<4, uintptr(_p0), uintptr(len(fds)), uintptr(timeout)) - runtime.ExitSyscall() - n = int(r0) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func Readdir_r(dirp uintptr, entry *direntLE, result **direntLE) (err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___READDIR_R_A<<4, uintptr(dirp), uintptr(unsafe.Pointer(entry)), uintptr(unsafe.Pointer(result))) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func impl_Statfs(path string, buf *Statfs_t) (err error) { - var _p0 *byte - _p0, err = BytePtrFromString(path) - if err != nil { - return - } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___STATFS_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(buf))) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -//go:nosplit -func get_StatfsAddr() *(func(path string, buf *Statfs_t) (err error)) - -var Statfs = enter_Statfs - -func enter_Statfs(path string, buf *Statfs_t) (err error) { - funcref := get_StatfsAddr() - if funcptrtest(GetZosLibVec()+SYS___STATFS_A<<4, "") == 0 { - *funcref = impl_Statfs - } else { - *funcref = error_Statfs - } - return (*funcref)(path, buf) -} - -func error_Statfs(path string, buf *Statfs_t) (err error) { - err = ENOSYS - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func impl_Syncfs(fd int) (err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_SYNCFS<<4, uintptr(fd)) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -//go:nosplit -func get_SyncfsAddr() *(func(fd int) (err error)) - -var Syncfs = enter_Syncfs - -func enter_Syncfs(fd int) (err error) { - funcref := get_SyncfsAddr() - if funcptrtest(GetZosLibVec()+SYS_SYNCFS<<4, "") == 0 { - *funcref = impl_Syncfs - } else { - *funcref = error_Syncfs - } - return (*funcref)(fd) -} - -func error_Syncfs(fd int) (err error) { - err = ENOSYS - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func Times(tms *Tms) (ticks uintptr, err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_TIMES<<4, uintptr(unsafe.Pointer(tms))) - runtime.ExitSyscall() - ticks = uintptr(r0) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func W_Getmntent(buff *byte, size int) (lastsys int, err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_W_GETMNTENT<<4, uintptr(unsafe.Pointer(buff)), uintptr(size)) - runtime.ExitSyscall() - lastsys = int(r0) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func W_Getmntent_A(buff *byte, size int) (lastsys int, err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___W_GETMNTENT_A<<4, uintptr(unsafe.Pointer(buff)), uintptr(size)) - runtime.ExitSyscall() - lastsys = int(r0) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func mount_LE(path string, filesystem string, fstype string, mtm uint32, parmlen int32, parm string) (err error) { - var _p0 *byte - _p0, err = BytePtrFromString(path) - if err != nil { - return - } - var _p1 *byte - _p1, err = BytePtrFromString(filesystem) - if err != nil { - return - } - var _p2 *byte - _p2, err = BytePtrFromString(fstype) - if err != nil { - return - } - var _p3 *byte - _p3, err = BytePtrFromString(parm) - if err != nil { - return - } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___MOUNT_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(unsafe.Pointer(_p2)), uintptr(mtm), uintptr(parmlen), uintptr(unsafe.Pointer(_p3))) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func unmount_LE(filesystem string, mtm int) (err error) { - var _p0 *byte - _p0, err = BytePtrFromString(filesystem) - if err != nil { - return - } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___UMOUNT_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(mtm)) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func Chroot(path string) (err error) { - var _p0 *byte - _p0, err = BytePtrFromString(path) - if err != nil { - return - } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___CHROOT_A<<4, uintptr(unsafe.Pointer(_p0))) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func Select(nmsgsfds int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (ret int, err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_SELECT<<4, uintptr(nmsgsfds), uintptr(unsafe.Pointer(r)), uintptr(unsafe.Pointer(w)), uintptr(unsafe.Pointer(e)), uintptr(unsafe.Pointer(timeout))) - runtime.ExitSyscall() - ret = int(r0) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func Uname(buf *Utsname) (err error) { - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_____OSNAME_A<<4, uintptr(unsafe.Pointer(buf))) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func impl_Unshare(flags int) (err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_UNSHARE<<4, uintptr(flags)) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -//go:nosplit -func get_UnshareAddr() *(func(flags int) (err error)) - -var Unshare = enter_Unshare - -func enter_Unshare(flags int) (err error) { - funcref := get_UnshareAddr() - if funcptrtest(GetZosLibVec()+SYS_UNSHARE<<4, "") == 0 { - *funcref = impl_Unshare - } else { - *funcref = error_Unshare - } - return (*funcref)(flags) -} - -func error_Unshare(flags int) (err error) { - err = ENOSYS - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func Gethostname(buf []byte) (err error) { - var _p0 unsafe.Pointer - if len(buf) > 0 { - _p0 = unsafe.Pointer(&buf[0]) - } else { - _p0 = unsafe.Pointer(&_zero) - } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___GETHOSTNAME_A<<4, uintptr(_p0), uintptr(len(buf))) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func Getgid() (gid int) { - r0, _, _ := CallLeFuncWithErr(GetZosLibVec() + SYS_GETGID<<4) - gid = int(r0) - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func Getpid() (pid int) { - r0, _, _ := CallLeFuncWithErr(GetZosLibVec() + SYS_GETPID<<4) - pid = int(r0) - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func Getpgid(pid int) (pgid int, err error) { - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_GETPGID<<4, uintptr(pid)) - pgid = int(r0) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT func Getppid() (pid int) { - r0, _, _ := CallLeFuncWithErr(GetZosLibVec() + SYS_GETPPID<<4) - pid = int(r0) - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func Getpriority(which int, who int) (prio int, err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_GETPRIORITY<<4, uintptr(which), uintptr(who)) - runtime.ExitSyscall() - prio = int(r0) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func Getrlimit(resource int, rlim *Rlimit) (err error) { - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_GETRLIMIT<<4, uintptr(resource), uintptr(unsafe.Pointer(rlim))) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func getrusage(who int, rusage *rusage_zos) (err error) { - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_GETRUSAGE<<4, uintptr(who), uintptr(unsafe.Pointer(rusage))) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func Getegid() (egid int) { - runtime.EnterSyscall() - r0, _, _ := CallLeFuncWithErr(GetZosLibVec() + SYS_GETEGID<<4) - runtime.ExitSyscall() - egid = int(r0) - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func Geteuid() (euid int) { - runtime.EnterSyscall() - r0, _, _ := CallLeFuncWithErr(GetZosLibVec() + SYS_GETEUID<<4) - runtime.ExitSyscall() - euid = int(r0) - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func Getsid(pid int) (sid int, err error) { - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_GETSID<<4, uintptr(pid)) - sid = int(r0) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func Getuid() (uid int) { - r0, _, _ := CallLeFuncWithErr(GetZosLibVec() + SYS_GETUID<<4) - uid = int(r0) - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func Kill(pid int, sig Signal) (err error) { - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_KILL<<4, uintptr(pid), uintptr(sig)) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func Lchown(path string, uid int, gid int) (err error) { - var _p0 *byte - _p0, err = BytePtrFromString(path) - if err != nil { - return - } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___LCHOWN_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid)) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func Link(path string, link string) (err error) { - var _p0 *byte - _p0, err = BytePtrFromString(path) - if err != nil { - return - } - var _p1 *byte - _p1, err = BytePtrFromString(link) - if err != nil { - return - } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___LINK_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1))) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func impl_Linkat(oldDirFd int, oldPath string, newDirFd int, newPath string, flags int) (err error) { - var _p0 *byte - _p0, err = BytePtrFromString(oldPath) - if err != nil { - return - } - var _p1 *byte - _p1, err = BytePtrFromString(newPath) - if err != nil { - return - } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___LINKAT_A<<4, uintptr(oldDirFd), uintptr(unsafe.Pointer(_p0)), uintptr(newDirFd), uintptr(unsafe.Pointer(_p1)), uintptr(flags)) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -//go:nosplit -func get_LinkatAddr() *(func(oldDirFd int, oldPath string, newDirFd int, newPath string, flags int) (err error)) - -var Linkat = enter_Linkat - -func enter_Linkat(oldDirFd int, oldPath string, newDirFd int, newPath string, flags int) (err error) { - funcref := get_LinkatAddr() - if funcptrtest(GetZosLibVec()+SYS___LINKAT_A<<4, "") == 0 { - *funcref = impl_Linkat - } else { - *funcref = error_Linkat - } - return (*funcref)(oldDirFd, oldPath, newDirFd, newPath, flags) -} - -func error_Linkat(oldDirFd int, oldPath string, newDirFd int, newPath string, flags int) (err error) { - err = ENOSYS - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func Listen(s int, n int) (err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_LISTEN<<4, uintptr(s), uintptr(n)) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func lstat(path string, stat *Stat_LE_t) (err error) { - var _p0 *byte - _p0, err = BytePtrFromString(path) - if err != nil { - return - } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___LSTAT_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat))) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func Mkdir(path string, mode uint32) (err error) { - var _p0 *byte - _p0, err = BytePtrFromString(path) - if err != nil { - return - } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___MKDIR_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(mode)) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func impl_Mkdirat(dirfd int, path string, mode uint32) (err error) { - var _p0 *byte - _p0, err = BytePtrFromString(path) - if err != nil { - return - } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___MKDIRAT_A<<4, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode)) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -//go:nosplit -func get_MkdiratAddr() *(func(dirfd int, path string, mode uint32) (err error)) - -var Mkdirat = enter_Mkdirat - -func enter_Mkdirat(dirfd int, path string, mode uint32) (err error) { - funcref := get_MkdiratAddr() - if funcptrtest(GetZosLibVec()+SYS___MKDIRAT_A<<4, "") == 0 { - *funcref = impl_Mkdirat - } else { - *funcref = error_Mkdirat - } - return (*funcref)(dirfd, path, mode) -} - -func error_Mkdirat(dirfd int, path string, mode uint32) (err error) { - err = ENOSYS - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func Mkfifo(path string, mode uint32) (err error) { - var _p0 *byte - _p0, err = BytePtrFromString(path) - if err != nil { - return - } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___MKFIFO_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(mode)) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func Mknod(path string, mode uint32, dev int) (err error) { - var _p0 *byte - _p0, err = BytePtrFromString(path) - if err != nil { - return - } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___MKNOD_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev)) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func impl_Mknodat(dirfd int, path string, mode uint32, dev int) (err error) { - var _p0 *byte - _p0, err = BytePtrFromString(path) - if err != nil { - return - } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___MKNODAT_A<<4, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev)) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -//go:nosplit -func get_MknodatAddr() *(func(dirfd int, path string, mode uint32, dev int) (err error)) - -var Mknodat = enter_Mknodat - -func enter_Mknodat(dirfd int, path string, mode uint32, dev int) (err error) { - funcref := get_MknodatAddr() - if funcptrtest(GetZosLibVec()+SYS___MKNODAT_A<<4, "") == 0 { - *funcref = impl_Mknodat - } else { - *funcref = error_Mknodat - } - return (*funcref)(dirfd, path, mode, dev) -} - -func error_Mknodat(dirfd int, path string, mode uint32, dev int) (err error) { - err = ENOSYS - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func impl_PivotRoot(newroot string, oldroot string) (err error) { - var _p0 *byte - _p0, err = BytePtrFromString(newroot) - if err != nil { - return - } - var _p1 *byte - _p1, err = BytePtrFromString(oldroot) - if err != nil { - return - } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___PIVOT_ROOT_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1))) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -//go:nosplit -func get_PivotRootAddr() *(func(newroot string, oldroot string) (err error)) - -var PivotRoot = enter_PivotRoot - -func enter_PivotRoot(newroot string, oldroot string) (err error) { - funcref := get_PivotRootAddr() - if funcptrtest(GetZosLibVec()+SYS___PIVOT_ROOT_A<<4, "") == 0 { - *funcref = impl_PivotRoot - } else { - *funcref = error_PivotRoot - } - return (*funcref)(newroot, oldroot) -} - -func error_PivotRoot(newroot string, oldroot string) (err error) { - err = ENOSYS - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func Pread(fd int, p []byte, offset int64) (n int, err error) { - var _p0 unsafe.Pointer - if len(p) > 0 { - _p0 = unsafe.Pointer(&p[0]) - } else { - _p0 = unsafe.Pointer(&_zero) - } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_PREAD<<4, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset)) - runtime.ExitSyscall() - n = int(r0) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } + r0, _, _ := syscall_rawsyscall(SYS_GETPPID, 0, 0, 0) + pid = int(r0) return } // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func Pwrite(fd int, p []byte, offset int64) (n int, err error) { - var _p0 unsafe.Pointer - if len(p) > 0 { - _p0 = unsafe.Pointer(&p[0]) - } else { - _p0 = unsafe.Pointer(&_zero) - } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_PWRITE<<4, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset)) - runtime.ExitSyscall() - n = int(r0) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) +func Getpriority(which int, who int) (prio int, err error) { + r0, _, e1 := syscall_syscall(SYS_GETPRIORITY, uintptr(which), uintptr(who), 0) + prio = int(r0) + if e1 != 0 { + err = errnoErr(e1) } return } // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func impl_Prctl(option int, arg2 uintptr, arg3 uintptr, arg4 uintptr, arg5 uintptr) (err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___PRCTL_A<<4, uintptr(option), uintptr(arg2), uintptr(arg3), uintptr(arg4), uintptr(arg5)) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) +func Getrlimit(resource int, rlim *Rlimit) (err error) { + _, _, e1 := syscall_rawsyscall(SYS_GETRLIMIT, uintptr(resource), uintptr(unsafe.Pointer(rlim)), 0) + if e1 != 0 { + err = errnoErr(e1) } return } -//go:nosplit -func get_PrctlAddr() *(func(option int, arg2 uintptr, arg3 uintptr, arg4 uintptr, arg5 uintptr) (err error)) - -var Prctl = enter_Prctl +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func enter_Prctl(option int, arg2 uintptr, arg3 uintptr, arg4 uintptr, arg5 uintptr) (err error) { - funcref := get_PrctlAddr() - if funcptrtest(GetZosLibVec()+SYS___PRCTL_A<<4, "") == 0 { - *funcref = impl_Prctl - } else { - *funcref = error_Prctl +func getrusage(who int, rusage *rusage_zos) (err error) { + _, _, e1 := syscall_rawsyscall(SYS_GETRUSAGE, uintptr(who), uintptr(unsafe.Pointer(rusage)), 0) + if e1 != 0 { + err = errnoErr(e1) } - return (*funcref)(option, arg2, arg3, arg4, arg5) -} - -func error_Prctl(option int, arg2 uintptr, arg3 uintptr, arg4 uintptr, arg5 uintptr) (err error) { - err = ENOSYS return } // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func impl_Prlimit(pid int, resource int, newlimit *Rlimit, old *Rlimit) (err error) { - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_PRLIMIT<<4, uintptr(pid), uintptr(resource), uintptr(unsafe.Pointer(newlimit)), uintptr(unsafe.Pointer(old))) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) +func Getsid(pid int) (sid int, err error) { + r0, _, e1 := syscall_rawsyscall(SYS_GETSID, uintptr(pid), 0, 0) + sid = int(r0) + if e1 != 0 { + err = errnoErr(e1) } return } -//go:nosplit -func get_PrlimitAddr() *(func(pid int, resource int, newlimit *Rlimit, old *Rlimit) (err error)) - -var Prlimit = enter_Prlimit +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func enter_Prlimit(pid int, resource int, newlimit *Rlimit, old *Rlimit) (err error) { - funcref := get_PrlimitAddr() - if funcptrtest(GetZosLibVec()+SYS_PRLIMIT<<4, "") == 0 { - *funcref = impl_Prlimit - } else { - *funcref = error_Prlimit - } - return (*funcref)(pid, resource, newlimit, old) +func Getuid() (uid int) { + r0, _, _ := syscall_rawsyscall(SYS_GETUID, 0, 0, 0) + uid = int(r0) + return } -func error_Prlimit(pid int, resource int, newlimit *Rlimit, old *Rlimit) (err error) { - err = ENOSYS +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func Kill(pid int, sig Signal) (err error) { + _, _, e1 := syscall_rawsyscall(SYS_KILL, uintptr(pid), uintptr(sig), 0) + if e1 != 0 { + err = errnoErr(e1) + } return } // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func Rename(from string, to string) (err error) { +func Lchown(path string, uid int, gid int) (err error) { var _p0 *byte - _p0, err = BytePtrFromString(from) - if err != nil { - return - } - var _p1 *byte - _p1, err = BytePtrFromString(to) + _p0, err = BytePtrFromString(path) if err != nil { return } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___RENAME_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1))) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) + _, _, e1 := syscall_syscall(SYS___LCHOWN_A, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid)) + if e1 != 0 { + err = errnoErr(e1) } return } // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func impl_Renameat(olddirfd int, oldpath string, newdirfd int, newpath string) (err error) { +func Link(path string, link string) (err error) { var _p0 *byte - _p0, err = BytePtrFromString(oldpath) + _p0, err = BytePtrFromString(path) if err != nil { return } var _p1 *byte - _p1, err = BytePtrFromString(newpath) + _p1, err = BytePtrFromString(link) if err != nil { return } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___RENAMEAT_A<<4, uintptr(olddirfd), uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1))) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) + _, _, e1 := syscall_syscall(SYS___LINK_A, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0) + if e1 != 0 { + err = errnoErr(e1) } return } -//go:nosplit -func get_RenameatAddr() *(func(olddirfd int, oldpath string, newdirfd int, newpath string) (err error)) - -var Renameat = enter_Renameat +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func enter_Renameat(olddirfd int, oldpath string, newdirfd int, newpath string) (err error) { - funcref := get_RenameatAddr() - if funcptrtest(GetZosLibVec()+SYS___RENAMEAT_A<<4, "") == 0 { - *funcref = impl_Renameat - } else { - *funcref = error_Renameat +func Listen(s int, n int) (err error) { + _, _, e1 := syscall_syscall(SYS_LISTEN, uintptr(s), uintptr(n), 0) + if e1 != 0 { + err = errnoErr(e1) } - return (*funcref)(olddirfd, oldpath, newdirfd, newpath) -} - -func error_Renameat(olddirfd int, oldpath string, newdirfd int, newpath string) (err error) { - err = ENOSYS return } // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func impl_Renameat2(olddirfd int, oldpath string, newdirfd int, newpath string, flags uint) (err error) { +func lstat(path string, stat *Stat_LE_t) (err error) { var _p0 *byte - _p0, err = BytePtrFromString(oldpath) - if err != nil { - return - } - var _p1 *byte - _p1, err = BytePtrFromString(newpath) + _p0, err = BytePtrFromString(path) if err != nil { return } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___RENAMEAT2_A<<4, uintptr(olddirfd), uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1)), uintptr(flags)) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -//go:nosplit -func get_Renameat2Addr() *(func(olddirfd int, oldpath string, newdirfd int, newpath string, flags uint) (err error)) - -var Renameat2 = enter_Renameat2 - -func enter_Renameat2(olddirfd int, oldpath string, newdirfd int, newpath string, flags uint) (err error) { - funcref := get_Renameat2Addr() - if funcptrtest(GetZosLibVec()+SYS___RENAMEAT2_A<<4, "") == 0 { - *funcref = impl_Renameat2 - } else { - *funcref = error_Renameat2 + _, _, e1 := syscall_syscall(SYS___LSTAT_A, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0) + if e1 != 0 { + err = errnoErr(e1) } - return (*funcref)(olddirfd, oldpath, newdirfd, newpath, flags) -} - -func error_Renameat2(olddirfd int, oldpath string, newdirfd int, newpath string, flags uint) (err error) { - err = ENOSYS return } // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func Rmdir(path string) (err error) { +func Mkdir(path string, mode uint32) (err error) { var _p0 *byte _p0, err = BytePtrFromString(path) if err != nil { return } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___RMDIR_A<<4, uintptr(unsafe.Pointer(_p0))) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) + _, _, e1 := syscall_syscall(SYS___MKDIR_A, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0) + if e1 != 0 { + err = errnoErr(e1) } return } // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func Seek(fd int, offset int64, whence int) (off int64, err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_LSEEK<<4, uintptr(fd), uintptr(offset), uintptr(whence)) - runtime.ExitSyscall() - off = int64(r0) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) +func Mkfifo(path string, mode uint32) (err error) { + var _p0 *byte + _p0, err = BytePtrFromString(path) + if err != nil { + return + } + _, _, e1 := syscall_syscall(SYS___MKFIFO_A, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0) + if e1 != 0 { + err = errnoErr(e1) } return } // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func Setegid(egid int) (err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_SETEGID<<4, uintptr(egid)) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) +func Mknod(path string, mode uint32, dev int) (err error) { + var _p0 *byte + _p0, err = BytePtrFromString(path) + if err != nil { + return + } + _, _, e1 := syscall_syscall(SYS___MKNOD_A, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev)) + if e1 != 0 { + err = errnoErr(e1) } return } // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func Seteuid(euid int) (err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_SETEUID<<4, uintptr(euid)) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) +func Pread(fd int, p []byte, offset int64) (n int, err error) { + var _p0 unsafe.Pointer + if len(p) > 0 { + _p0 = unsafe.Pointer(&p[0]) + } else { + _p0 = unsafe.Pointer(&_zero) + } + r0, _, e1 := syscall_syscall6(SYS_PREAD, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0) + n = int(r0) + if e1 != 0 { + err = errnoErr(e1) } return } // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func impl_Sethostname(p []byte) (err error) { +func Pwrite(fd int, p []byte, offset int64) (n int, err error) { var _p0 unsafe.Pointer if len(p) > 0 { _p0 = unsafe.Pointer(&p[0]) } else { _p0 = unsafe.Pointer(&_zero) } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___SETHOSTNAME_A<<4, uintptr(_p0), uintptr(len(p))) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) + r0, _, e1 := syscall_syscall6(SYS_PWRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0) + n = int(r0) + if e1 != 0 { + err = errnoErr(e1) } return } -//go:nosplit -func get_SethostnameAddr() *(func(p []byte) (err error)) - -var Sethostname = enter_Sethostname +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func enter_Sethostname(p []byte) (err error) { - funcref := get_SethostnameAddr() - if funcptrtest(GetZosLibVec()+SYS___SETHOSTNAME_A<<4, "") == 0 { - *funcref = impl_Sethostname +func Readlink(path string, buf []byte) (n int, err error) { + var _p0 *byte + _p0, err = BytePtrFromString(path) + if err != nil { + return + } + var _p1 unsafe.Pointer + if len(buf) > 0 { + _p1 = unsafe.Pointer(&buf[0]) } else { - *funcref = error_Sethostname + _p1 = unsafe.Pointer(&_zero) + } + r0, _, e1 := syscall_syscall(SYS___READLINK_A, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf))) + n = int(r0) + if e1 != 0 { + err = errnoErr(e1) } - return (*funcref)(p) -} - -func error_Sethostname(p []byte) (err error) { - err = ENOSYS return } // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func impl_Setns(fd int, nstype int) (err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_SETNS<<4, uintptr(fd), uintptr(nstype)) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) +func Rename(from string, to string) (err error) { + var _p0 *byte + _p0, err = BytePtrFromString(from) + if err != nil { + return + } + var _p1 *byte + _p1, err = BytePtrFromString(to) + if err != nil { + return + } + _, _, e1 := syscall_syscall(SYS___RENAME_A, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0) + if e1 != 0 { + err = errnoErr(e1) } return } -//go:nosplit -func get_SetnsAddr() *(func(fd int, nstype int) (err error)) - -var Setns = enter_Setns +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func enter_Setns(fd int, nstype int) (err error) { - funcref := get_SetnsAddr() - if funcptrtest(GetZosLibVec()+SYS_SETNS<<4, "") == 0 { - *funcref = impl_Setns - } else { - *funcref = error_Setns +func Rmdir(path string) (err error) { + var _p0 *byte + _p0, err = BytePtrFromString(path) + if err != nil { + return + } + _, _, e1 := syscall_syscall(SYS___RMDIR_A, uintptr(unsafe.Pointer(_p0)), 0, 0) + if e1 != 0 { + err = errnoErr(e1) } - return (*funcref)(fd, nstype) + return } -func error_Setns(fd int, nstype int) (err error) { - err = ENOSYS +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func Seek(fd int, offset int64, whence int) (off int64, err error) { + r0, _, e1 := syscall_syscall(SYS_LSEEK, uintptr(fd), uintptr(offset), uintptr(whence)) + off = int64(r0) + if e1 != 0 { + err = errnoErr(e1) + } return } // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT func Setpriority(which int, who int, prio int) (err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_SETPRIORITY<<4, uintptr(which), uintptr(who), uintptr(prio)) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) + _, _, e1 := syscall_syscall(SYS_SETPRIORITY, uintptr(which), uintptr(who), uintptr(prio)) + if e1 != 0 { + err = errnoErr(e1) } return } @@ -2910,9 +971,9 @@ func Setpriority(which int, who int, prio int) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT func Setpgid(pid int, pgid int) (err error) { - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_SETPGID<<4, uintptr(pid), uintptr(pgid)) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) + _, _, e1 := syscall_rawsyscall(SYS_SETPGID, uintptr(pid), uintptr(pgid), 0) + if e1 != 0 { + err = errnoErr(e1) } return } @@ -2920,9 +981,9 @@ func Setpgid(pid int, pgid int) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT func Setrlimit(resource int, lim *Rlimit) (err error) { - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_SETRLIMIT<<4, uintptr(resource), uintptr(unsafe.Pointer(lim))) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) + _, _, e1 := syscall_rawsyscall(SYS_SETRLIMIT, uintptr(resource), uintptr(unsafe.Pointer(lim)), 0) + if e1 != 0 { + err = errnoErr(e1) } return } @@ -2930,9 +991,9 @@ func Setrlimit(resource int, lim *Rlimit) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT func Setregid(rgid int, egid int) (err error) { - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_SETREGID<<4, uintptr(rgid), uintptr(egid)) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) + _, _, e1 := syscall_rawsyscall(SYS_SETREGID, uintptr(rgid), uintptr(egid), 0) + if e1 != 0 { + err = errnoErr(e1) } return } @@ -2940,9 +1001,9 @@ func Setregid(rgid int, egid int) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT func Setreuid(ruid int, euid int) (err error) { - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_SETREUID<<4, uintptr(ruid), uintptr(euid)) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) + _, _, e1 := syscall_rawsyscall(SYS_SETREUID, uintptr(ruid), uintptr(euid), 0) + if e1 != 0 { + err = errnoErr(e1) } return } @@ -2950,10 +1011,10 @@ func Setreuid(ruid int, euid int) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT func Setsid() (pid int, err error) { - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec() + SYS_SETSID<<4) + r0, _, e1 := syscall_rawsyscall(SYS_SETSID, 0, 0, 0) pid = int(r0) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) + if e1 != 0 { + err = errnoErr(e1) } return } @@ -2961,11 +1022,9 @@ func Setsid() (pid int, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT func Setuid(uid int) (err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_SETUID<<4, uintptr(uid)) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) + _, _, e1 := syscall_syscall(SYS_SETUID, uintptr(uid), 0, 0) + if e1 != 0 { + err = errnoErr(e1) } return } @@ -2973,11 +1032,9 @@ func Setuid(uid int) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT func Setgid(uid int) (err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_SETGID<<4, uintptr(uid)) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) + _, _, e1 := syscall_syscall(SYS_SETGID, uintptr(uid), 0, 0) + if e1 != 0 { + err = errnoErr(e1) } return } @@ -2985,11 +1042,9 @@ func Setgid(uid int) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT func Shutdown(fd int, how int) (err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_SHUTDOWN<<4, uintptr(fd), uintptr(how)) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) + _, _, e1 := syscall_syscall(SYS_SHUTDOWN, uintptr(fd), uintptr(how), 0) + if e1 != 0 { + err = errnoErr(e1) } return } @@ -3002,11 +1057,9 @@ func stat(path string, statLE *Stat_LE_t) (err error) { if err != nil { return } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___STAT_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(statLE))) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) + _, _, e1 := syscall_syscall(SYS___STAT_A, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(statLE)), 0) + if e1 != 0 { + err = errnoErr(e1) } return } @@ -3024,63 +1077,17 @@ func Symlink(path string, link string) (err error) { if err != nil { return } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___SYMLINK_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1))) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func impl_Symlinkat(oldPath string, dirfd int, newPath string) (err error) { - var _p0 *byte - _p0, err = BytePtrFromString(oldPath) - if err != nil { - return - } - var _p1 *byte - _p1, err = BytePtrFromString(newPath) - if err != nil { - return - } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___SYMLINKAT_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(dirfd), uintptr(unsafe.Pointer(_p1))) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) + _, _, e1 := syscall_syscall(SYS___SYMLINK_A, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0) + if e1 != 0 { + err = errnoErr(e1) } return } -//go:nosplit -func get_SymlinkatAddr() *(func(oldPath string, dirfd int, newPath string) (err error)) - -var Symlinkat = enter_Symlinkat - -func enter_Symlinkat(oldPath string, dirfd int, newPath string) (err error) { - funcref := get_SymlinkatAddr() - if funcptrtest(GetZosLibVec()+SYS___SYMLINKAT_A<<4, "") == 0 { - *funcref = impl_Symlinkat - } else { - *funcref = error_Symlinkat - } - return (*funcref)(oldPath, dirfd, newPath) -} - -func error_Symlinkat(oldPath string, dirfd int, newPath string) (err error) { - err = ENOSYS - return -} - // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT func Sync() { - runtime.EnterSyscall() - CallLeFuncWithErr(GetZosLibVec() + SYS_SYNC<<4) - runtime.ExitSyscall() + syscall_syscall(SYS_SYNC, 0, 0, 0) return } @@ -3092,11 +1099,9 @@ func Truncate(path string, length int64) (err error) { if err != nil { return } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___TRUNCATE_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(length)) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) + _, _, e1 := syscall_syscall(SYS___TRUNCATE_A, uintptr(unsafe.Pointer(_p0)), uintptr(length), 0) + if e1 != 0 { + err = errnoErr(e1) } return } @@ -3104,11 +1109,9 @@ func Truncate(path string, length int64) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT func Tcgetattr(fildes int, termptr *Termios) (err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_TCGETATTR<<4, uintptr(fildes), uintptr(unsafe.Pointer(termptr))) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) + _, _, e1 := syscall_syscall(SYS_TCGETATTR, uintptr(fildes), uintptr(unsafe.Pointer(termptr)), 0) + if e1 != 0 { + err = errnoErr(e1) } return } @@ -3116,11 +1119,9 @@ func Tcgetattr(fildes int, termptr *Termios) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT func Tcsetattr(fildes int, when int, termptr *Termios) (err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_TCSETATTR<<4, uintptr(fildes), uintptr(when), uintptr(unsafe.Pointer(termptr))) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) + _, _, e1 := syscall_syscall(SYS_TCSETATTR, uintptr(fildes), uintptr(when), uintptr(unsafe.Pointer(termptr))) + if e1 != 0 { + err = errnoErr(e1) } return } @@ -3128,9 +1129,7 @@ func Tcsetattr(fildes int, when int, termptr *Termios) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT func Umask(mask int) (oldmask int) { - runtime.EnterSyscall() - r0, _, _ := CallLeFuncWithErr(GetZosLibVec()+SYS_UMASK<<4, uintptr(mask)) - runtime.ExitSyscall() + r0, _, _ := syscall_syscall(SYS_UMASK, uintptr(mask), 0, 0) oldmask = int(r0) return } @@ -3143,49 +1142,10 @@ func Unlink(path string) (err error) { if err != nil { return } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___UNLINK_A<<4, uintptr(unsafe.Pointer(_p0))) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func impl_Unlinkat(dirfd int, path string, flags int) (err error) { - var _p0 *byte - _p0, err = BytePtrFromString(path) - if err != nil { - return - } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___UNLINKAT_A<<4, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags)) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -//go:nosplit -func get_UnlinkatAddr() *(func(dirfd int, path string, flags int) (err error)) - -var Unlinkat = enter_Unlinkat - -func enter_Unlinkat(dirfd int, path string, flags int) (err error) { - funcref := get_UnlinkatAddr() - if funcptrtest(GetZosLibVec()+SYS___UNLINKAT_A<<4, "") == 0 { - *funcref = impl_Unlinkat - } else { - *funcref = error_Unlinkat + _, _, e1 := syscall_syscall(SYS___UNLINK_A, uintptr(unsafe.Pointer(_p0)), 0, 0) + if e1 != 0 { + err = errnoErr(e1) } - return (*funcref)(dirfd, path, flags) -} - -func error_Unlinkat(dirfd int, path string, flags int) (err error) { - err = ENOSYS return } @@ -3197,11 +1157,9 @@ func Utime(path string, utim *Utimbuf) (err error) { if err != nil { return } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___UTIME_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(utim))) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) + _, _, e1 := syscall_syscall(SYS___UTIME_A, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(utim)), 0) + if e1 != 0 { + err = errnoErr(e1) } return } @@ -3214,91 +1172,11 @@ func open(path string, mode int, perm uint32) (fd int, err error) { if err != nil { return } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___OPEN_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm)) - runtime.ExitSyscall() - fd = int(r0) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func impl_openat(dirfd int, path string, flags int, mode uint32) (fd int, err error) { - var _p0 *byte - _p0, err = BytePtrFromString(path) - if err != nil { - return - } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___OPENAT_A<<4, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags), uintptr(mode)) - runtime.ExitSyscall() - fd = int(r0) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -//go:nosplit -func get_openatAddr() *(func(dirfd int, path string, flags int, mode uint32) (fd int, err error)) - -var openat = enter_openat - -func enter_openat(dirfd int, path string, flags int, mode uint32) (fd int, err error) { - funcref := get_openatAddr() - if funcptrtest(GetZosLibVec()+SYS___OPENAT_A<<4, "") == 0 { - *funcref = impl_openat - } else { - *funcref = error_openat - } - return (*funcref)(dirfd, path, flags, mode) -} - -func error_openat(dirfd int, path string, flags int, mode uint32) (fd int, err error) { - fd = -1 - err = ENOSYS - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func impl_openat2(dirfd int, path string, open_how *OpenHow, size int) (fd int, err error) { - var _p0 *byte - _p0, err = BytePtrFromString(path) - if err != nil { - return - } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___OPENAT2_A<<4, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(open_how)), uintptr(size)) - runtime.ExitSyscall() + r0, _, e1 := syscall_syscall(SYS___OPEN_A, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm)) fd = int(r0) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -//go:nosplit -func get_openat2Addr() *(func(dirfd int, path string, open_how *OpenHow, size int) (fd int, err error)) - -var openat2 = enter_openat2 - -func enter_openat2(dirfd int, path string, open_how *OpenHow, size int) (fd int, err error) { - funcref := get_openat2Addr() - if funcptrtest(GetZosLibVec()+SYS___OPENAT2_A<<4, "") == 0 { - *funcref = impl_openat2 - } else { - *funcref = error_openat2 + if e1 != 0 { + err = errnoErr(e1) } - return (*funcref)(dirfd, path, open_how, size) -} - -func error_openat2(dirfd int, path string, open_how *OpenHow, size int) (fd int, err error) { - fd = -1 - err = ENOSYS return } @@ -3310,23 +1188,9 @@ func remove(path string) (err error) { if err != nil { return } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_REMOVE<<4, uintptr(unsafe.Pointer(_p0))) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func waitid(idType int, id int, info *Siginfo, options int) (err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_WAITID<<4, uintptr(idType), uintptr(id), uintptr(unsafe.Pointer(info)), uintptr(options)) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) + _, _, e1 := syscall_syscall(SYS_REMOVE, uintptr(unsafe.Pointer(_p0)), 0, 0) + if e1 != 0 { + err = errnoErr(e1) } return } @@ -3334,12 +1198,10 @@ func waitid(idType int, id int, info *Siginfo, options int) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT func waitpid(pid int, wstatus *_C_int, options int) (wpid int, err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_WAITPID<<4, uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options)) - runtime.ExitSyscall() + r0, _, e1 := syscall_syscall(SYS_WAITPID, uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options)) wpid = int(r0) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) + if e1 != 0 { + err = errnoErr(e1) } return } @@ -3347,9 +1209,9 @@ func waitpid(pid int, wstatus *_C_int, options int) (wpid int, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT func gettimeofday(tv *timeval_zos) (err error) { - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_GETTIMEOFDAY<<4, uintptr(unsafe.Pointer(tv))) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) + _, _, e1 := syscall_rawsyscall(SYS_GETTIMEOFDAY, uintptr(unsafe.Pointer(tv)), 0, 0) + if e1 != 0 { + err = errnoErr(e1) } return } @@ -3357,9 +1219,9 @@ func gettimeofday(tv *timeval_zos) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT func pipe(p *[2]_C_int) (err error) { - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_PIPE<<4, uintptr(unsafe.Pointer(p))) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) + _, _, e1 := syscall_rawsyscall(SYS_PIPE, uintptr(unsafe.Pointer(p)), 0, 0) + if e1 != 0 { + err = errnoErr(e1) } return } @@ -3372,87 +1234,20 @@ func utimes(path string, timeval *[2]Timeval) (err error) { if err != nil { return } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___UTIMES_A<<4, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(timeval))) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func impl_utimensat(dirfd int, path string, ts *[2]Timespec, flags int) (err error) { - var _p0 *byte - _p0, err = BytePtrFromString(path) - if err != nil { - return - } - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS___UTIMENSAT_A<<4, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(ts)), uintptr(flags)) - runtime.ExitSyscall() - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -//go:nosplit -func get_utimensatAddr() *(func(dirfd int, path string, ts *[2]Timespec, flags int) (err error)) - -var utimensat = enter_utimensat - -func enter_utimensat(dirfd int, path string, ts *[2]Timespec, flags int) (err error) { - funcref := get_utimensatAddr() - if funcptrtest(GetZosLibVec()+SYS___UTIMENSAT_A<<4, "") == 0 { - *funcref = impl_utimensat - } else { - *funcref = error_utimensat - } - return (*funcref)(dirfd, path, ts, flags) -} - -func error_utimensat(dirfd int, path string, ts *[2]Timespec, flags int) (err error) { - err = ENOSYS - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func Posix_openpt(oflag int) (fd int, err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_POSIX_OPENPT<<4, uintptr(oflag)) - runtime.ExitSyscall() - fd = int(r0) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) + _, _, e1 := syscall_syscall(SYS___UTIMES_A, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(timeval)), 0) + if e1 != 0 { + err = errnoErr(e1) } return } // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func Grantpt(fildes int) (rc int, err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_GRANTPT<<4, uintptr(fildes)) - runtime.ExitSyscall() - rc = int(r0) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - -func Unlockpt(fildes int) (rc int, err error) { - runtime.EnterSyscall() - r0, e2, e1 := CallLeFuncWithErr(GetZosLibVec()+SYS_UNLOCKPT<<4, uintptr(fildes)) - runtime.ExitSyscall() - rc = int(r0) - if int64(r0) == -1 { - err = errnoErr2(e1, e2) +func Select(nmsgsfds int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (ret int, err error) { + r0, _, e1 := syscall_syscall6(SYS_SELECT, uintptr(nmsgsfds), uintptr(unsafe.Pointer(r)), uintptr(unsafe.Pointer(w)), uintptr(unsafe.Pointer(e)), uintptr(unsafe.Pointer(timeout)), 0) + ret = int(r0) + if e1 != 0 { + err = errnoErr(e1) } return } diff --git a/services/vendor/golang.org/x/sys/unix/zsysnum_linux_386.go b/services/vendor/golang.org/x/sys/unix/zsysnum_linux_386.go index 524b0820..0cc3ce49 100644 --- a/services/vendor/golang.org/x/sys/unix/zsysnum_linux_386.go +++ b/services/vendor/golang.org/x/sys/unix/zsysnum_linux_386.go @@ -452,10 +452,4 @@ const ( SYS_FUTEX_WAKE = 454 SYS_FUTEX_WAIT = 455 SYS_FUTEX_REQUEUE = 456 - SYS_STATMOUNT = 457 - SYS_LISTMOUNT = 458 - SYS_LSM_GET_SELF_ATTR = 459 - SYS_LSM_SET_SELF_ATTR = 460 - SYS_LSM_LIST_MODULES = 461 - SYS_MSEAL = 462 ) diff --git a/services/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go b/services/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go index d3e38f68..856d92d6 100644 --- a/services/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go +++ b/services/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go @@ -374,10 +374,4 @@ const ( SYS_FUTEX_WAKE = 454 SYS_FUTEX_WAIT = 455 SYS_FUTEX_REQUEUE = 456 - SYS_STATMOUNT = 457 - SYS_LISTMOUNT = 458 - SYS_LSM_GET_SELF_ATTR = 459 - SYS_LSM_SET_SELF_ATTR = 460 - SYS_LSM_LIST_MODULES = 461 - SYS_MSEAL = 462 ) diff --git a/services/vendor/golang.org/x/sys/unix/zsysnum_linux_arm.go b/services/vendor/golang.org/x/sys/unix/zsysnum_linux_arm.go index 70b35bf3..8d467094 100644 --- a/services/vendor/golang.org/x/sys/unix/zsysnum_linux_arm.go +++ b/services/vendor/golang.org/x/sys/unix/zsysnum_linux_arm.go @@ -416,10 +416,4 @@ const ( SYS_FUTEX_WAKE = 454 SYS_FUTEX_WAIT = 455 SYS_FUTEX_REQUEUE = 456 - SYS_STATMOUNT = 457 - SYS_LISTMOUNT = 458 - SYS_LSM_GET_SELF_ATTR = 459 - SYS_LSM_SET_SELF_ATTR = 460 - SYS_LSM_LIST_MODULES = 461 - SYS_MSEAL = 462 ) diff --git a/services/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go b/services/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go index 6c778c23..edc17324 100644 --- a/services/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go +++ b/services/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go @@ -319,10 +319,4 @@ const ( SYS_FUTEX_WAKE = 454 SYS_FUTEX_WAIT = 455 SYS_FUTEX_REQUEUE = 456 - SYS_STATMOUNT = 457 - SYS_LISTMOUNT = 458 - SYS_LSM_GET_SELF_ATTR = 459 - SYS_LSM_SET_SELF_ATTR = 460 - SYS_LSM_LIST_MODULES = 461 - SYS_MSEAL = 462 ) diff --git a/services/vendor/golang.org/x/sys/unix/zsysnum_linux_loong64.go b/services/vendor/golang.org/x/sys/unix/zsysnum_linux_loong64.go index 37281cf5..445eba20 100644 --- a/services/vendor/golang.org/x/sys/unix/zsysnum_linux_loong64.go +++ b/services/vendor/golang.org/x/sys/unix/zsysnum_linux_loong64.go @@ -313,10 +313,4 @@ const ( SYS_FUTEX_WAKE = 454 SYS_FUTEX_WAIT = 455 SYS_FUTEX_REQUEUE = 456 - SYS_STATMOUNT = 457 - SYS_LISTMOUNT = 458 - SYS_LSM_GET_SELF_ATTR = 459 - SYS_LSM_SET_SELF_ATTR = 460 - SYS_LSM_LIST_MODULES = 461 - SYS_MSEAL = 462 ) diff --git a/services/vendor/golang.org/x/sys/unix/zsysnum_linux_mips.go b/services/vendor/golang.org/x/sys/unix/zsysnum_linux_mips.go index 7e567f1e..adba01bc 100644 --- a/services/vendor/golang.org/x/sys/unix/zsysnum_linux_mips.go +++ b/services/vendor/golang.org/x/sys/unix/zsysnum_linux_mips.go @@ -436,10 +436,4 @@ const ( SYS_FUTEX_WAKE = 4454 SYS_FUTEX_WAIT = 4455 SYS_FUTEX_REQUEUE = 4456 - SYS_STATMOUNT = 4457 - SYS_LISTMOUNT = 4458 - SYS_LSM_GET_SELF_ATTR = 4459 - SYS_LSM_SET_SELF_ATTR = 4460 - SYS_LSM_LIST_MODULES = 4461 - SYS_MSEAL = 4462 ) diff --git a/services/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64.go b/services/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64.go index 38ae55e5..014c4e9c 100644 --- a/services/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64.go +++ b/services/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64.go @@ -366,10 +366,4 @@ const ( SYS_FUTEX_WAKE = 5454 SYS_FUTEX_WAIT = 5455 SYS_FUTEX_REQUEUE = 5456 - SYS_STATMOUNT = 5457 - SYS_LISTMOUNT = 5458 - SYS_LSM_GET_SELF_ATTR = 5459 - SYS_LSM_SET_SELF_ATTR = 5460 - SYS_LSM_LIST_MODULES = 5461 - SYS_MSEAL = 5462 ) diff --git a/services/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64le.go b/services/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64le.go index 55e92e60..ccc97d74 100644 --- a/services/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64le.go +++ b/services/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64le.go @@ -366,10 +366,4 @@ const ( SYS_FUTEX_WAKE = 5454 SYS_FUTEX_WAIT = 5455 SYS_FUTEX_REQUEUE = 5456 - SYS_STATMOUNT = 5457 - SYS_LISTMOUNT = 5458 - SYS_LSM_GET_SELF_ATTR = 5459 - SYS_LSM_SET_SELF_ATTR = 5460 - SYS_LSM_LIST_MODULES = 5461 - SYS_MSEAL = 5462 ) diff --git a/services/vendor/golang.org/x/sys/unix/zsysnum_linux_mipsle.go b/services/vendor/golang.org/x/sys/unix/zsysnum_linux_mipsle.go index 60658d6a..ec2b64a9 100644 --- a/services/vendor/golang.org/x/sys/unix/zsysnum_linux_mipsle.go +++ b/services/vendor/golang.org/x/sys/unix/zsysnum_linux_mipsle.go @@ -436,10 +436,4 @@ const ( SYS_FUTEX_WAKE = 4454 SYS_FUTEX_WAIT = 4455 SYS_FUTEX_REQUEUE = 4456 - SYS_STATMOUNT = 4457 - SYS_LISTMOUNT = 4458 - SYS_LSM_GET_SELF_ATTR = 4459 - SYS_LSM_SET_SELF_ATTR = 4460 - SYS_LSM_LIST_MODULES = 4461 - SYS_MSEAL = 4462 ) diff --git a/services/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc.go b/services/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc.go index e203e8a7..21a839e3 100644 --- a/services/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc.go +++ b/services/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc.go @@ -443,10 +443,4 @@ const ( SYS_FUTEX_WAKE = 454 SYS_FUTEX_WAIT = 455 SYS_FUTEX_REQUEUE = 456 - SYS_STATMOUNT = 457 - SYS_LISTMOUNT = 458 - SYS_LSM_GET_SELF_ATTR = 459 - SYS_LSM_SET_SELF_ATTR = 460 - SYS_LSM_LIST_MODULES = 461 - SYS_MSEAL = 462 ) diff --git a/services/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64.go b/services/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64.go index 5944b97d..c11121ec 100644 --- a/services/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64.go +++ b/services/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64.go @@ -415,10 +415,4 @@ const ( SYS_FUTEX_WAKE = 454 SYS_FUTEX_WAIT = 455 SYS_FUTEX_REQUEUE = 456 - SYS_STATMOUNT = 457 - SYS_LISTMOUNT = 458 - SYS_LSM_GET_SELF_ATTR = 459 - SYS_LSM_SET_SELF_ATTR = 460 - SYS_LSM_LIST_MODULES = 461 - SYS_MSEAL = 462 ) diff --git a/services/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64le.go b/services/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64le.go index c66d416d..909b631f 100644 --- a/services/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64le.go +++ b/services/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64le.go @@ -415,10 +415,4 @@ const ( SYS_FUTEX_WAKE = 454 SYS_FUTEX_WAIT = 455 SYS_FUTEX_REQUEUE = 456 - SYS_STATMOUNT = 457 - SYS_LISTMOUNT = 458 - SYS_LSM_GET_SELF_ATTR = 459 - SYS_LSM_SET_SELF_ATTR = 460 - SYS_LSM_LIST_MODULES = 461 - SYS_MSEAL = 462 ) diff --git a/services/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go b/services/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go index 9889f6a5..e49bed16 100644 --- a/services/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go +++ b/services/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go @@ -320,10 +320,4 @@ const ( SYS_FUTEX_WAKE = 454 SYS_FUTEX_WAIT = 455 SYS_FUTEX_REQUEUE = 456 - SYS_STATMOUNT = 457 - SYS_LISTMOUNT = 458 - SYS_LSM_GET_SELF_ATTR = 459 - SYS_LSM_SET_SELF_ATTR = 460 - SYS_LSM_LIST_MODULES = 461 - SYS_MSEAL = 462 ) diff --git a/services/vendor/golang.org/x/sys/unix/zsysnum_linux_s390x.go b/services/vendor/golang.org/x/sys/unix/zsysnum_linux_s390x.go index 01d86825..66017d2d 100644 --- a/services/vendor/golang.org/x/sys/unix/zsysnum_linux_s390x.go +++ b/services/vendor/golang.org/x/sys/unix/zsysnum_linux_s390x.go @@ -381,10 +381,4 @@ const ( SYS_FUTEX_WAKE = 454 SYS_FUTEX_WAIT = 455 SYS_FUTEX_REQUEUE = 456 - SYS_STATMOUNT = 457 - SYS_LISTMOUNT = 458 - SYS_LSM_GET_SELF_ATTR = 459 - SYS_LSM_SET_SELF_ATTR = 460 - SYS_LSM_LIST_MODULES = 461 - SYS_MSEAL = 462 ) diff --git a/services/vendor/golang.org/x/sys/unix/zsysnum_linux_sparc64.go b/services/vendor/golang.org/x/sys/unix/zsysnum_linux_sparc64.go index 7b703e77..47bab18d 100644 --- a/services/vendor/golang.org/x/sys/unix/zsysnum_linux_sparc64.go +++ b/services/vendor/golang.org/x/sys/unix/zsysnum_linux_sparc64.go @@ -394,10 +394,4 @@ const ( SYS_FUTEX_WAKE = 454 SYS_FUTEX_WAIT = 455 SYS_FUTEX_REQUEUE = 456 - SYS_STATMOUNT = 457 - SYS_LISTMOUNT = 458 - SYS_LSM_GET_SELF_ATTR = 459 - SYS_LSM_SET_SELF_ATTR = 460 - SYS_LSM_LIST_MODULES = 461 - SYS_MSEAL = 462 ) diff --git a/services/vendor/golang.org/x/sys/unix/zsysnum_zos_s390x.go b/services/vendor/golang.org/x/sys/unix/zsysnum_zos_s390x.go index 5e8c263c..b2e30858 100644 --- a/services/vendor/golang.org/x/sys/unix/zsysnum_zos_s390x.go +++ b/services/vendor/golang.org/x/sys/unix/zsysnum_zos_s390x.go @@ -1,2852 +1,2669 @@ -// go run mksyscall_zos_s390x.go -o_sysnum zsysnum_zos_s390x.go -o_syscall zsyscall_zos_s390x.go -i_syscall syscall_zos_s390x.go -o_asm zsymaddr_zos_s390x.s -// Code generated by the command above; see README.md. DO NOT EDIT. +// Copyright 2020 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 zos && s390x package unix -const ( - SYS_LOG = 0x17 // 23 - SYS_COSH = 0x18 // 24 - SYS_TANH = 0x19 // 25 - SYS_EXP = 0x1A // 26 - SYS_MODF = 0x1B // 27 - SYS_LOG10 = 0x1C // 28 - SYS_FREXP = 0x1D // 29 - SYS_LDEXP = 0x1E // 30 - SYS_CEIL = 0x1F // 31 - SYS_POW = 0x20 // 32 - SYS_SQRT = 0x21 // 33 - SYS_FLOOR = 0x22 // 34 - SYS_J1 = 0x23 // 35 - SYS_FABS = 0x24 // 36 - SYS_FMOD = 0x25 // 37 - SYS_J0 = 0x26 // 38 - SYS_YN = 0x27 // 39 - SYS_JN = 0x28 // 40 - SYS_Y0 = 0x29 // 41 - SYS_Y1 = 0x2A // 42 - SYS_HYPOT = 0x2B // 43 - SYS_ERF = 0x2C // 44 - SYS_ERFC = 0x2D // 45 - SYS_GAMMA = 0x2E // 46 - SYS_ISALPHA = 0x30 // 48 - SYS_ISALNUM = 0x31 // 49 - SYS_ISLOWER = 0x32 // 50 - SYS_ISCNTRL = 0x33 // 51 - SYS_ISDIGIT = 0x34 // 52 - SYS_ISGRAPH = 0x35 // 53 - SYS_ISUPPER = 0x36 // 54 - SYS_ISPRINT = 0x37 // 55 - SYS_ISPUNCT = 0x38 // 56 - SYS_ISSPACE = 0x39 // 57 - SYS_SETLOCAL = 0x3A // 58 - SYS_SETLOCALE = 0x3A // 58 - SYS_ISXDIGIT = 0x3B // 59 - SYS_TOLOWER = 0x3C // 60 - SYS_TOUPPER = 0x3D // 61 - SYS_ASIN = 0x3E // 62 - SYS_SIN = 0x3F // 63 - SYS_COS = 0x40 // 64 - SYS_TAN = 0x41 // 65 - SYS_SINH = 0x42 // 66 - SYS_ACOS = 0x43 // 67 - SYS_ATAN = 0x44 // 68 - SYS_ATAN2 = 0x45 // 69 - SYS_FTELL = 0x46 // 70 - SYS_FGETPOS = 0x47 // 71 - SYS_FSEEK = 0x48 // 72 - SYS_FSETPOS = 0x49 // 73 - SYS_FERROR = 0x4A // 74 - SYS_REWIND = 0x4B // 75 - SYS_CLEARERR = 0x4C // 76 - SYS_FEOF = 0x4D // 77 - SYS_ATOL = 0x4E // 78 - SYS_PERROR = 0x4F // 79 - SYS_ATOF = 0x50 // 80 - SYS_ATOI = 0x51 // 81 - SYS_RAND = 0x52 // 82 - SYS_STRTOD = 0x53 // 83 - SYS_STRTOL = 0x54 // 84 - SYS_STRTOUL = 0x55 // 85 - SYS_MALLOC = 0x56 // 86 - SYS_SRAND = 0x57 // 87 - SYS_CALLOC = 0x58 // 88 - SYS_FREE = 0x59 // 89 - SYS_EXIT = 0x5A // 90 - SYS_REALLOC = 0x5B // 91 - SYS_ABORT = 0x5C // 92 - SYS___ABORT = 0x5C // 92 - SYS_ATEXIT = 0x5D // 93 - SYS_RAISE = 0x5E // 94 - SYS_SETJMP = 0x5F // 95 - SYS_LONGJMP = 0x60 // 96 - SYS_SIGNAL = 0x61 // 97 - SYS_TMPNAM = 0x62 // 98 - SYS_REMOVE = 0x63 // 99 - SYS_RENAME = 0x64 // 100 - SYS_TMPFILE = 0x65 // 101 - SYS_FREOPEN = 0x66 // 102 - SYS_FCLOSE = 0x67 // 103 - SYS_FFLUSH = 0x68 // 104 - SYS_FOPEN = 0x69 // 105 - SYS_FSCANF = 0x6A // 106 - SYS_SETBUF = 0x6B // 107 - SYS_SETVBUF = 0x6C // 108 - SYS_FPRINTF = 0x6D // 109 - SYS_SSCANF = 0x6E // 110 - SYS_PRINTF = 0x6F // 111 - SYS_SCANF = 0x70 // 112 - SYS_SPRINTF = 0x71 // 113 - SYS_FGETC = 0x72 // 114 - SYS_VFPRINTF = 0x73 // 115 - SYS_VPRINTF = 0x74 // 116 - SYS_VSPRINTF = 0x75 // 117 - SYS_GETC = 0x76 // 118 - SYS_FGETS = 0x77 // 119 - SYS_FPUTC = 0x78 // 120 - SYS_FPUTS = 0x79 // 121 - SYS_PUTCHAR = 0x7A // 122 - SYS_GETCHAR = 0x7B // 123 - SYS_GETS = 0x7C // 124 - SYS_PUTC = 0x7D // 125 - SYS_FWRITE = 0x7E // 126 - SYS_PUTS = 0x7F // 127 - SYS_UNGETC = 0x80 // 128 - SYS_FREAD = 0x81 // 129 - SYS_WCSTOMBS = 0x82 // 130 - SYS_MBTOWC = 0x83 // 131 - SYS_WCTOMB = 0x84 // 132 - SYS_MBSTOWCS = 0x85 // 133 - SYS_WCSCPY = 0x86 // 134 - SYS_WCSCAT = 0x87 // 135 - SYS_WCSCHR = 0x88 // 136 - SYS_WCSCMP = 0x89 // 137 - SYS_WCSNCMP = 0x8A // 138 - SYS_WCSCSPN = 0x8B // 139 - SYS_WCSLEN = 0x8C // 140 - SYS_WCSNCAT = 0x8D // 141 - SYS_WCSSPN = 0x8E // 142 - SYS_WCSNCPY = 0x8F // 143 - SYS_ABS = 0x90 // 144 - SYS_DIV = 0x91 // 145 - SYS_LABS = 0x92 // 146 - SYS_STRNCPY = 0x93 // 147 - SYS_MEMCPY = 0x94 // 148 - SYS_MEMMOVE = 0x95 // 149 - SYS_STRCPY = 0x96 // 150 - SYS_STRCMP = 0x97 // 151 - SYS_STRCAT = 0x98 // 152 - SYS_STRNCAT = 0x99 // 153 - SYS_MEMCMP = 0x9A // 154 - SYS_MEMCHR = 0x9B // 155 - SYS_STRCOLL = 0x9C // 156 - SYS_STRNCMP = 0x9D // 157 - SYS_STRXFRM = 0x9E // 158 - SYS_STRRCHR = 0x9F // 159 - SYS_STRCHR = 0xA0 // 160 - SYS_STRCSPN = 0xA1 // 161 - SYS_STRPBRK = 0xA2 // 162 - SYS_MEMSET = 0xA3 // 163 - SYS_STRSPN = 0xA4 // 164 - SYS_STRSTR = 0xA5 // 165 - SYS_STRTOK = 0xA6 // 166 - SYS_DIFFTIME = 0xA7 // 167 - SYS_STRERROR = 0xA8 // 168 - SYS_STRLEN = 0xA9 // 169 - SYS_CLOCK = 0xAA // 170 - SYS_CTIME = 0xAB // 171 - SYS_MKTIME = 0xAC // 172 - SYS_TIME = 0xAD // 173 - SYS_ASCTIME = 0xAE // 174 - SYS_MBLEN = 0xAF // 175 - SYS_GMTIME = 0xB0 // 176 - SYS_LOCALTIM = 0xB1 // 177 - SYS_LOCALTIME = 0xB1 // 177 - SYS_STRFTIME = 0xB2 // 178 - SYS___GETCB = 0xB4 // 180 - SYS_FUPDATE = 0xB5 // 181 - SYS___FUPDT = 0xB5 // 181 - SYS_CLRMEMF = 0xBD // 189 - SYS___CLRMF = 0xBD // 189 - SYS_FETCHEP = 0xBF // 191 - SYS___FTCHEP = 0xBF // 191 - SYS_FLDATA = 0xC1 // 193 - SYS___FLDATA = 0xC1 // 193 - SYS_DYNFREE = 0xC2 // 194 - SYS___DYNFRE = 0xC2 // 194 - SYS_DYNALLOC = 0xC3 // 195 - SYS___DYNALL = 0xC3 // 195 - SYS___CDUMP = 0xC4 // 196 - SYS_CSNAP = 0xC5 // 197 - SYS___CSNAP = 0xC5 // 197 - SYS_CTRACE = 0xC6 // 198 - SYS___CTRACE = 0xC6 // 198 - SYS___CTEST = 0xC7 // 199 - SYS_SETENV = 0xC8 // 200 - SYS___SETENV = 0xC8 // 200 - SYS_CLEARENV = 0xC9 // 201 - SYS___CLRENV = 0xC9 // 201 - SYS___REGCOMP_STD = 0xEA // 234 - SYS_NL_LANGINFO = 0xFC // 252 - SYS_GETSYNTX = 0xFD // 253 - SYS_ISBLANK = 0xFE // 254 - SYS___ISBLNK = 0xFE // 254 - SYS_ISWALNUM = 0xFF // 255 - SYS_ISWALPHA = 0x100 // 256 - SYS_ISWBLANK = 0x101 // 257 - SYS___ISWBLK = 0x101 // 257 - SYS_ISWCNTRL = 0x102 // 258 - SYS_ISWDIGIT = 0x103 // 259 - SYS_ISWGRAPH = 0x104 // 260 - SYS_ISWLOWER = 0x105 // 261 - SYS_ISWPRINT = 0x106 // 262 - SYS_ISWPUNCT = 0x107 // 263 - SYS_ISWSPACE = 0x108 // 264 - SYS_ISWUPPER = 0x109 // 265 - SYS_ISWXDIGI = 0x10A // 266 - SYS_ISWXDIGIT = 0x10A // 266 - SYS_WCTYPE = 0x10B // 267 - SYS_ISWCTYPE = 0x10C // 268 - SYS_TOWLOWER = 0x10D // 269 - SYS_TOWUPPER = 0x10E // 270 - SYS_MBSINIT = 0x10F // 271 - SYS_WCTOB = 0x110 // 272 - SYS_MBRLEN = 0x111 // 273 - SYS_MBRTOWC = 0x112 // 274 - SYS_MBSRTOWC = 0x113 // 275 - SYS_MBSRTOWCS = 0x113 // 275 - SYS_WCRTOMB = 0x114 // 276 - SYS_WCSRTOMB = 0x115 // 277 - SYS_WCSRTOMBS = 0x115 // 277 - SYS___CSID = 0x116 // 278 - SYS___WCSID = 0x117 // 279 - SYS_STRPTIME = 0x118 // 280 - SYS___STRPTM = 0x118 // 280 - SYS_STRFMON = 0x119 // 281 - SYS___RPMTCH = 0x11A // 282 - SYS_WCSSTR = 0x11B // 283 - SYS_WCSTOK = 0x12C // 300 - SYS_WCSTOL = 0x12D // 301 - SYS_WCSTOD = 0x12E // 302 - SYS_WCSTOUL = 0x12F // 303 - SYS_WCSCOLL = 0x130 // 304 - SYS_WCSXFRM = 0x131 // 305 - SYS_WCSWIDTH = 0x132 // 306 - SYS_WCWIDTH = 0x133 // 307 - SYS_WCSFTIME = 0x134 // 308 - SYS_SWPRINTF = 0x135 // 309 - SYS_VSWPRINT = 0x136 // 310 - SYS_VSWPRINTF = 0x136 // 310 - SYS_SWSCANF = 0x137 // 311 - SYS_REGCOMP = 0x138 // 312 - SYS_REGEXEC = 0x139 // 313 - SYS_REGFREE = 0x13A // 314 - SYS_REGERROR = 0x13B // 315 - SYS_FGETWC = 0x13C // 316 - SYS_FGETWS = 0x13D // 317 - SYS_FPUTWC = 0x13E // 318 - SYS_FPUTWS = 0x13F // 319 - SYS_GETWC = 0x140 // 320 - SYS_GETWCHAR = 0x141 // 321 - SYS_PUTWC = 0x142 // 322 - SYS_PUTWCHAR = 0x143 // 323 - SYS_UNGETWC = 0x144 // 324 - SYS_ICONV_OPEN = 0x145 // 325 - SYS_ICONV = 0x146 // 326 - SYS_ICONV_CLOSE = 0x147 // 327 - SYS_ISMCCOLLEL = 0x14C // 332 - SYS_STRTOCOLL = 0x14D // 333 - SYS_COLLTOSTR = 0x14E // 334 - SYS_COLLEQUIV = 0x14F // 335 - SYS_COLLRANGE = 0x150 // 336 - SYS_CCLASS = 0x151 // 337 - SYS_COLLORDER = 0x152 // 338 - SYS___DEMANGLE = 0x154 // 340 - SYS_FDOPEN = 0x155 // 341 - SYS___ERRNO = 0x156 // 342 - SYS___ERRNO2 = 0x157 // 343 - SYS___TERROR = 0x158 // 344 - SYS_MAXCOLL = 0x169 // 361 - SYS_GETMCCOLL = 0x16A // 362 - SYS_GETWMCCOLL = 0x16B // 363 - SYS___ERR2AD = 0x16C // 364 - SYS_DLLQUERYFN = 0x16D // 365 - SYS_DLLQUERYVAR = 0x16E // 366 - SYS_DLLFREE = 0x16F // 367 - SYS_DLLLOAD = 0x170 // 368 - SYS__EXIT = 0x174 // 372 - SYS_ACCESS = 0x175 // 373 - SYS_ALARM = 0x176 // 374 - SYS_CFGETISPEED = 0x177 // 375 - SYS_CFGETOSPEED = 0x178 // 376 - SYS_CFSETISPEED = 0x179 // 377 - SYS_CFSETOSPEED = 0x17A // 378 - SYS_CHDIR = 0x17B // 379 - SYS_CHMOD = 0x17C // 380 - SYS_CHOWN = 0x17D // 381 - SYS_CLOSE = 0x17E // 382 - SYS_CLOSEDIR = 0x17F // 383 - SYS_CREAT = 0x180 // 384 - SYS_CTERMID = 0x181 // 385 - SYS_DUP = 0x182 // 386 - SYS_DUP2 = 0x183 // 387 - SYS_EXECL = 0x184 // 388 - SYS_EXECLE = 0x185 // 389 - SYS_EXECLP = 0x186 // 390 - SYS_EXECV = 0x187 // 391 - SYS_EXECVE = 0x188 // 392 - SYS_EXECVP = 0x189 // 393 - SYS_FCHMOD = 0x18A // 394 - SYS_FCHOWN = 0x18B // 395 - SYS_FCNTL = 0x18C // 396 - SYS_FILENO = 0x18D // 397 - SYS_FORK = 0x18E // 398 - SYS_FPATHCONF = 0x18F // 399 - SYS_FSTAT = 0x190 // 400 - SYS_FSYNC = 0x191 // 401 - SYS_FTRUNCATE = 0x192 // 402 - SYS_GETCWD = 0x193 // 403 - SYS_GETEGID = 0x194 // 404 - SYS_GETEUID = 0x195 // 405 - SYS_GETGID = 0x196 // 406 - SYS_GETGRGID = 0x197 // 407 - SYS_GETGRNAM = 0x198 // 408 - SYS_GETGROUPS = 0x199 // 409 - SYS_GETLOGIN = 0x19A // 410 - SYS_W_GETMNTENT = 0x19B // 411 - SYS_GETPGRP = 0x19C // 412 - SYS_GETPID = 0x19D // 413 - SYS_GETPPID = 0x19E // 414 - SYS_GETPWNAM = 0x19F // 415 - SYS_GETPWUID = 0x1A0 // 416 - SYS_GETUID = 0x1A1 // 417 - SYS_W_IOCTL = 0x1A2 // 418 - SYS_ISATTY = 0x1A3 // 419 - SYS_KILL = 0x1A4 // 420 - SYS_LINK = 0x1A5 // 421 - SYS_LSEEK = 0x1A6 // 422 - SYS_LSTAT = 0x1A7 // 423 - SYS_MKDIR = 0x1A8 // 424 - SYS_MKFIFO = 0x1A9 // 425 - SYS_MKNOD = 0x1AA // 426 - SYS_MOUNT = 0x1AB // 427 - SYS_OPEN = 0x1AC // 428 - SYS_OPENDIR = 0x1AD // 429 - SYS_PATHCONF = 0x1AE // 430 - SYS_PAUSE = 0x1AF // 431 - SYS_PIPE = 0x1B0 // 432 - SYS_W_GETPSENT = 0x1B1 // 433 - SYS_READ = 0x1B2 // 434 - SYS_READDIR = 0x1B3 // 435 - SYS_READLINK = 0x1B4 // 436 - SYS_REWINDDIR = 0x1B5 // 437 - SYS_RMDIR = 0x1B6 // 438 - SYS_SETEGID = 0x1B7 // 439 - SYS_SETEUID = 0x1B8 // 440 - SYS_SETGID = 0x1B9 // 441 - SYS_SETPGID = 0x1BA // 442 - SYS_SETSID = 0x1BB // 443 - SYS_SETUID = 0x1BC // 444 - SYS_SIGACTION = 0x1BD // 445 - SYS_SIGADDSET = 0x1BE // 446 - SYS_SIGDELSET = 0x1BF // 447 - SYS_SIGEMPTYSET = 0x1C0 // 448 - SYS_SIGFILLSET = 0x1C1 // 449 - SYS_SIGISMEMBER = 0x1C2 // 450 - SYS_SIGLONGJMP = 0x1C3 // 451 - SYS_SIGPENDING = 0x1C4 // 452 - SYS_SIGPROCMASK = 0x1C5 // 453 - SYS_SIGSETJMP = 0x1C6 // 454 - SYS_SIGSUSPEND = 0x1C7 // 455 - SYS_SLEEP = 0x1C8 // 456 - SYS_STAT = 0x1C9 // 457 - SYS_W_STATFS = 0x1CA // 458 - SYS_SYMLINK = 0x1CB // 459 - SYS_SYSCONF = 0x1CC // 460 - SYS_TCDRAIN = 0x1CD // 461 - SYS_TCFLOW = 0x1CE // 462 - SYS_TCFLUSH = 0x1CF // 463 - SYS_TCGETATTR = 0x1D0 // 464 - SYS_TCGETPGRP = 0x1D1 // 465 - SYS_TCSENDBREAK = 0x1D2 // 466 - SYS_TCSETATTR = 0x1D3 // 467 - SYS_TCSETPGRP = 0x1D4 // 468 - SYS_TIMES = 0x1D5 // 469 - SYS_TTYNAME = 0x1D6 // 470 - SYS_TZSET = 0x1D7 // 471 - SYS_UMASK = 0x1D8 // 472 - SYS_UMOUNT = 0x1D9 // 473 - SYS_UNAME = 0x1DA // 474 - SYS_UNLINK = 0x1DB // 475 - SYS_UTIME = 0x1DC // 476 - SYS_WAIT = 0x1DD // 477 - SYS_WAITPID = 0x1DE // 478 - SYS_WRITE = 0x1DF // 479 - SYS_CHAUDIT = 0x1E0 // 480 - SYS_FCHAUDIT = 0x1E1 // 481 - SYS_GETGROUPSBYNAME = 0x1E2 // 482 - SYS_SIGWAIT = 0x1E3 // 483 - SYS_PTHREAD_EXIT = 0x1E4 // 484 - SYS_PTHREAD_KILL = 0x1E5 // 485 - SYS_PTHREAD_ATTR_INIT = 0x1E6 // 486 - SYS_PTHREAD_ATTR_DESTROY = 0x1E7 // 487 - SYS_PTHREAD_ATTR_SETSTACKSIZE = 0x1E8 // 488 - SYS_PTHREAD_ATTR_GETSTACKSIZE = 0x1E9 // 489 - SYS_PTHREAD_ATTR_SETDETACHSTATE = 0x1EA // 490 - SYS_PTHREAD_ATTR_GETDETACHSTATE = 0x1EB // 491 - SYS_PTHREAD_ATTR_SETWEIGHT_NP = 0x1EC // 492 - SYS_PTHREAD_ATTR_GETWEIGHT_NP = 0x1ED // 493 - SYS_PTHREAD_CANCEL = 0x1EE // 494 - SYS_PTHREAD_CLEANUP_PUSH = 0x1EF // 495 - SYS_PTHREAD_CLEANUP_POP = 0x1F0 // 496 - SYS_PTHREAD_CONDATTR_INIT = 0x1F1 // 497 - SYS_PTHREAD_CONDATTR_DESTROY = 0x1F2 // 498 - SYS_PTHREAD_COND_INIT = 0x1F3 // 499 - SYS_PTHREAD_COND_DESTROY = 0x1F4 // 500 - SYS_PTHREAD_COND_SIGNAL = 0x1F5 // 501 - SYS_PTHREAD_COND_BROADCAST = 0x1F6 // 502 - SYS_PTHREAD_COND_WAIT = 0x1F7 // 503 - SYS_PTHREAD_COND_TIMEDWAIT = 0x1F8 // 504 - SYS_PTHREAD_CREATE = 0x1F9 // 505 - SYS_PTHREAD_DETACH = 0x1FA // 506 - SYS_PTHREAD_EQUAL = 0x1FB // 507 - SYS_PTHREAD_GETSPECIFIC = 0x1FC // 508 - SYS_PTHREAD_JOIN = 0x1FD // 509 - SYS_PTHREAD_KEY_CREATE = 0x1FE // 510 - SYS_PTHREAD_MUTEXATTR_INIT = 0x1FF // 511 - SYS_PTHREAD_MUTEXATTR_DESTROY = 0x200 // 512 - SYS_PTHREAD_MUTEXATTR_SETKIND_NP = 0x201 // 513 - SYS_PTHREAD_MUTEXATTR_GETKIND_NP = 0x202 // 514 - SYS_PTHREAD_MUTEX_INIT = 0x203 // 515 - SYS_PTHREAD_MUTEX_DESTROY = 0x204 // 516 - SYS_PTHREAD_MUTEX_LOCK = 0x205 // 517 - SYS_PTHREAD_MUTEX_TRYLOCK = 0x206 // 518 - SYS_PTHREAD_MUTEX_UNLOCK = 0x207 // 519 - SYS_PTHREAD_ONCE = 0x209 // 521 - SYS_PTHREAD_SELF = 0x20A // 522 - SYS_PTHREAD_SETINTR = 0x20B // 523 - SYS_PTHREAD_SETINTRTYPE = 0x20C // 524 - SYS_PTHREAD_SETSPECIFIC = 0x20D // 525 - SYS_PTHREAD_TESTINTR = 0x20E // 526 - SYS_PTHREAD_YIELD = 0x20F // 527 - SYS_TW_OPEN = 0x210 // 528 - SYS_TW_FCNTL = 0x211 // 529 - SYS_PTHREAD_JOIN_D4_NP = 0x212 // 530 - SYS_PTHREAD_CONDATTR_SETKIND_NP = 0x213 // 531 - SYS_PTHREAD_CONDATTR_GETKIND_NP = 0x214 // 532 - SYS_EXTLINK_NP = 0x215 // 533 - SYS___PASSWD = 0x216 // 534 - SYS_SETGROUPS = 0x217 // 535 - SYS_INITGROUPS = 0x218 // 536 - SYS_WCSPBRK = 0x23F // 575 - SYS_WCSRCHR = 0x240 // 576 - SYS_SVC99 = 0x241 // 577 - SYS___SVC99 = 0x241 // 577 - SYS_WCSWCS = 0x242 // 578 - SYS_LOCALECO = 0x243 // 579 - SYS_LOCALECONV = 0x243 // 579 - SYS___LIBREL = 0x244 // 580 - SYS_RELEASE = 0x245 // 581 - SYS___RLSE = 0x245 // 581 - SYS_FLOCATE = 0x246 // 582 - SYS___FLOCT = 0x246 // 582 - SYS_FDELREC = 0x247 // 583 - SYS___FDLREC = 0x247 // 583 - SYS_FETCH = 0x248 // 584 - SYS___FETCH = 0x248 // 584 - SYS_QSORT = 0x249 // 585 - SYS_GETENV = 0x24A // 586 - SYS_SYSTEM = 0x24B // 587 - SYS_BSEARCH = 0x24C // 588 - SYS_LDIV = 0x24D // 589 - SYS___THROW = 0x25E // 606 - SYS___RETHROW = 0x25F // 607 - SYS___CLEANUPCATCH = 0x260 // 608 - SYS___CATCHMATCH = 0x261 // 609 - SYS___CLEAN2UPCATCH = 0x262 // 610 - SYS_PUTENV = 0x26A // 618 - SYS___GETENV = 0x26F // 623 - SYS_GETPRIORITY = 0x270 // 624 - SYS_NICE = 0x271 // 625 - SYS_SETPRIORITY = 0x272 // 626 - SYS_GETITIMER = 0x273 // 627 - SYS_SETITIMER = 0x274 // 628 - SYS_MSGCTL = 0x275 // 629 - SYS_MSGGET = 0x276 // 630 - SYS_MSGRCV = 0x277 // 631 - SYS_MSGSND = 0x278 // 632 - SYS_MSGXRCV = 0x279 // 633 - SYS___MSGXR = 0x279 // 633 - SYS_SEMCTL = 0x27A // 634 - SYS_SEMGET = 0x27B // 635 - SYS_SEMOP = 0x27C // 636 - SYS_SHMAT = 0x27D // 637 - SYS_SHMCTL = 0x27E // 638 - SYS_SHMDT = 0x27F // 639 - SYS_SHMGET = 0x280 // 640 - SYS___GETIPC = 0x281 // 641 - SYS_SETGRENT = 0x282 // 642 - SYS_GETGRENT = 0x283 // 643 - SYS_ENDGRENT = 0x284 // 644 - SYS_SETPWENT = 0x285 // 645 - SYS_GETPWENT = 0x286 // 646 - SYS_ENDPWENT = 0x287 // 647 - SYS_BSD_SIGNAL = 0x288 // 648 - SYS_KILLPG = 0x289 // 649 - SYS_SIGALTSTACK = 0x28A // 650 - SYS_SIGHOLD = 0x28B // 651 - SYS_SIGIGNORE = 0x28C // 652 - SYS_SIGINTERRUPT = 0x28D // 653 - SYS_SIGPAUSE = 0x28E // 654 - SYS_SIGRELSE = 0x28F // 655 - SYS_SIGSET = 0x290 // 656 - SYS_SIGSTACK = 0x291 // 657 - SYS_GETRLIMIT = 0x292 // 658 - SYS_SETRLIMIT = 0x293 // 659 - SYS_GETRUSAGE = 0x294 // 660 - SYS_MMAP = 0x295 // 661 - SYS_MPROTECT = 0x296 // 662 - SYS_MSYNC = 0x297 // 663 - SYS_MUNMAP = 0x298 // 664 - SYS_CONFSTR = 0x299 // 665 - SYS_GETOPT = 0x29A // 666 - SYS_LCHOWN = 0x29B // 667 - SYS_TRUNCATE = 0x29C // 668 - SYS_GETSUBOPT = 0x29D // 669 - SYS_SETPGRP = 0x29E // 670 - SYS___GDERR = 0x29F // 671 - SYS___TZONE = 0x2A0 // 672 - SYS___DLGHT = 0x2A1 // 673 - SYS___OPARGF = 0x2A2 // 674 - SYS___OPOPTF = 0x2A3 // 675 - SYS___OPINDF = 0x2A4 // 676 - SYS___OPERRF = 0x2A5 // 677 - SYS_GETDATE = 0x2A6 // 678 - SYS_WAIT3 = 0x2A7 // 679 - SYS_WAITID = 0x2A8 // 680 - SYS___CATTRM = 0x2A9 // 681 - SYS___GDTRM = 0x2AA // 682 - SYS___RNDTRM = 0x2AB // 683 - SYS_CRYPT = 0x2AC // 684 - SYS_ENCRYPT = 0x2AD // 685 - SYS_SETKEY = 0x2AE // 686 - SYS___CNVBLK = 0x2AF // 687 - SYS___CRYTRM = 0x2B0 // 688 - SYS___ECRTRM = 0x2B1 // 689 - SYS_DRAND48 = 0x2B2 // 690 - SYS_ERAND48 = 0x2B3 // 691 - SYS_FSTATVFS = 0x2B4 // 692 - SYS_STATVFS = 0x2B5 // 693 - SYS_CATCLOSE = 0x2B6 // 694 - SYS_CATGETS = 0x2B7 // 695 - SYS_CATOPEN = 0x2B8 // 696 - SYS_BCMP = 0x2B9 // 697 - SYS_BCOPY = 0x2BA // 698 - SYS_BZERO = 0x2BB // 699 - SYS_FFS = 0x2BC // 700 - SYS_INDEX = 0x2BD // 701 - SYS_RINDEX = 0x2BE // 702 - SYS_STRCASECMP = 0x2BF // 703 - SYS_STRDUP = 0x2C0 // 704 - SYS_STRNCASECMP = 0x2C1 // 705 - SYS_INITSTATE = 0x2C2 // 706 - SYS_SETSTATE = 0x2C3 // 707 - SYS_RANDOM = 0x2C4 // 708 - SYS_SRANDOM = 0x2C5 // 709 - SYS_HCREATE = 0x2C6 // 710 - SYS_HDESTROY = 0x2C7 // 711 - SYS_HSEARCH = 0x2C8 // 712 - SYS_LFIND = 0x2C9 // 713 - SYS_LSEARCH = 0x2CA // 714 - SYS_TDELETE = 0x2CB // 715 - SYS_TFIND = 0x2CC // 716 - SYS_TSEARCH = 0x2CD // 717 - SYS_TWALK = 0x2CE // 718 - SYS_INSQUE = 0x2CF // 719 - SYS_REMQUE = 0x2D0 // 720 - SYS_POPEN = 0x2D1 // 721 - SYS_PCLOSE = 0x2D2 // 722 - SYS_SWAB = 0x2D3 // 723 - SYS_MEMCCPY = 0x2D4 // 724 - SYS_GETPAGESIZE = 0x2D8 // 728 - SYS_FCHDIR = 0x2D9 // 729 - SYS___OCLCK = 0x2DA // 730 - SYS___ATOE = 0x2DB // 731 - SYS___ATOE_L = 0x2DC // 732 - SYS___ETOA = 0x2DD // 733 - SYS___ETOA_L = 0x2DE // 734 - SYS_SETUTXENT = 0x2DF // 735 - SYS_GETUTXENT = 0x2E0 // 736 - SYS_ENDUTXENT = 0x2E1 // 737 - SYS_GETUTXID = 0x2E2 // 738 - SYS_GETUTXLINE = 0x2E3 // 739 - SYS_PUTUTXLINE = 0x2E4 // 740 - SYS_FMTMSG = 0x2E5 // 741 - SYS_JRAND48 = 0x2E6 // 742 - SYS_LRAND48 = 0x2E7 // 743 - SYS_MRAND48 = 0x2E8 // 744 - SYS_NRAND48 = 0x2E9 // 745 - SYS_LCONG48 = 0x2EA // 746 - SYS_SRAND48 = 0x2EB // 747 - SYS_SEED48 = 0x2EC // 748 - SYS_ISASCII = 0x2ED // 749 - SYS_TOASCII = 0x2EE // 750 - SYS_A64L = 0x2EF // 751 - SYS_L64A = 0x2F0 // 752 - SYS_UALARM = 0x2F1 // 753 - SYS_USLEEP = 0x2F2 // 754 - SYS___UTXTRM = 0x2F3 // 755 - SYS___SRCTRM = 0x2F4 // 756 - SYS_FTIME = 0x2F5 // 757 - SYS_GETTIMEOFDAY = 0x2F6 // 758 - SYS_DBM_CLEARERR = 0x2F7 // 759 - SYS_DBM_CLOSE = 0x2F8 // 760 - SYS_DBM_DELETE = 0x2F9 // 761 - SYS_DBM_ERROR = 0x2FA // 762 - SYS_DBM_FETCH = 0x2FB // 763 - SYS_DBM_FIRSTKEY = 0x2FC // 764 - SYS_DBM_NEXTKEY = 0x2FD // 765 - SYS_DBM_OPEN = 0x2FE // 766 - SYS_DBM_STORE = 0x2FF // 767 - SYS___NDMTRM = 0x300 // 768 - SYS_FTOK = 0x301 // 769 - SYS_BASENAME = 0x302 // 770 - SYS_DIRNAME = 0x303 // 771 - SYS_GETDTABLESIZE = 0x304 // 772 - SYS_MKSTEMP = 0x305 // 773 - SYS_MKTEMP = 0x306 // 774 - SYS_NFTW = 0x307 // 775 - SYS_GETWD = 0x308 // 776 - SYS_LOCKF = 0x309 // 777 - SYS__LONGJMP = 0x30D // 781 - SYS__SETJMP = 0x30E // 782 - SYS_VFORK = 0x30F // 783 - SYS_WORDEXP = 0x310 // 784 - SYS_WORDFREE = 0x311 // 785 - SYS_GETPGID = 0x312 // 786 - SYS_GETSID = 0x313 // 787 - SYS___UTMPXNAME = 0x314 // 788 - SYS_CUSERID = 0x315 // 789 - SYS_GETPASS = 0x316 // 790 - SYS_FNMATCH = 0x317 // 791 - SYS_FTW = 0x318 // 792 - SYS_GETW = 0x319 // 793 - SYS_GLOB = 0x31A // 794 - SYS_GLOBFREE = 0x31B // 795 - SYS_PUTW = 0x31C // 796 - SYS_SEEKDIR = 0x31D // 797 - SYS_TELLDIR = 0x31E // 798 - SYS_TEMPNAM = 0x31F // 799 - SYS_ACOSH = 0x320 // 800 - SYS_ASINH = 0x321 // 801 - SYS_ATANH = 0x322 // 802 - SYS_CBRT = 0x323 // 803 - SYS_EXPM1 = 0x324 // 804 - SYS_ILOGB = 0x325 // 805 - SYS_LOGB = 0x326 // 806 - SYS_LOG1P = 0x327 // 807 - SYS_NEXTAFTER = 0x328 // 808 - SYS_RINT = 0x329 // 809 - SYS_REMAINDER = 0x32A // 810 - SYS_SCALB = 0x32B // 811 - SYS_LGAMMA = 0x32C // 812 - SYS_TTYSLOT = 0x32D // 813 - SYS_GETTIMEOFDAY_R = 0x32E // 814 - SYS_SYNC = 0x32F // 815 - SYS_SPAWN = 0x330 // 816 - SYS_SPAWNP = 0x331 // 817 - SYS_GETLOGIN_UU = 0x332 // 818 - SYS_ECVT = 0x333 // 819 - SYS_FCVT = 0x334 // 820 - SYS_GCVT = 0x335 // 821 - SYS_ACCEPT = 0x336 // 822 - SYS_BIND = 0x337 // 823 - SYS_CONNECT = 0x338 // 824 - SYS_ENDHOSTENT = 0x339 // 825 - SYS_ENDPROTOENT = 0x33A // 826 - SYS_ENDSERVENT = 0x33B // 827 - SYS_GETHOSTBYADDR_R = 0x33C // 828 - SYS_GETHOSTBYADDR = 0x33D // 829 - SYS_GETHOSTBYNAME_R = 0x33E // 830 - SYS_GETHOSTBYNAME = 0x33F // 831 - SYS_GETHOSTENT = 0x340 // 832 - SYS_GETHOSTID = 0x341 // 833 - SYS_GETHOSTNAME = 0x342 // 834 - SYS_GETNETBYADDR = 0x343 // 835 - SYS_GETNETBYNAME = 0x344 // 836 - SYS_GETNETENT = 0x345 // 837 - SYS_GETPEERNAME = 0x346 // 838 - SYS_GETPROTOBYNAME = 0x347 // 839 - SYS_GETPROTOBYNUMBER = 0x348 // 840 - SYS_GETPROTOENT = 0x349 // 841 - SYS_GETSERVBYNAME = 0x34A // 842 - SYS_GETSERVBYPORT = 0x34B // 843 - SYS_GETSERVENT = 0x34C // 844 - SYS_GETSOCKNAME = 0x34D // 845 - SYS_GETSOCKOPT = 0x34E // 846 - SYS_INET_ADDR = 0x34F // 847 - SYS_INET_LNAOF = 0x350 // 848 - SYS_INET_MAKEADDR = 0x351 // 849 - SYS_INET_NETOF = 0x352 // 850 - SYS_INET_NETWORK = 0x353 // 851 - SYS_INET_NTOA = 0x354 // 852 - SYS_IOCTL = 0x355 // 853 - SYS_LISTEN = 0x356 // 854 - SYS_READV = 0x357 // 855 - SYS_RECV = 0x358 // 856 - SYS_RECVFROM = 0x359 // 857 - SYS_SELECT = 0x35B // 859 - SYS_SELECTEX = 0x35C // 860 - SYS_SEND = 0x35D // 861 - SYS_SENDTO = 0x35F // 863 - SYS_SETHOSTENT = 0x360 // 864 - SYS_SETNETENT = 0x361 // 865 - SYS_SETPEER = 0x362 // 866 - SYS_SETPROTOENT = 0x363 // 867 - SYS_SETSERVENT = 0x364 // 868 - SYS_SETSOCKOPT = 0x365 // 869 - SYS_SHUTDOWN = 0x366 // 870 - SYS_SOCKET = 0x367 // 871 - SYS_SOCKETPAIR = 0x368 // 872 - SYS_WRITEV = 0x369 // 873 - SYS_CHROOT = 0x36A // 874 - SYS_W_STATVFS = 0x36B // 875 - SYS_ULIMIT = 0x36C // 876 - SYS_ISNAN = 0x36D // 877 - SYS_UTIMES = 0x36E // 878 - SYS___H_ERRNO = 0x36F // 879 - SYS_ENDNETENT = 0x370 // 880 - SYS_CLOSELOG = 0x371 // 881 - SYS_OPENLOG = 0x372 // 882 - SYS_SETLOGMASK = 0x373 // 883 - SYS_SYSLOG = 0x374 // 884 - SYS_PTSNAME = 0x375 // 885 - SYS_SETREUID = 0x376 // 886 - SYS_SETREGID = 0x377 // 887 - SYS_REALPATH = 0x378 // 888 - SYS___SIGNGAM = 0x379 // 889 - SYS_GRANTPT = 0x37A // 890 - SYS_UNLOCKPT = 0x37B // 891 - SYS_TCGETSID = 0x37C // 892 - SYS___TCGETCP = 0x37D // 893 - SYS___TCSETCP = 0x37E // 894 - SYS___TCSETTABLES = 0x37F // 895 - SYS_POLL = 0x380 // 896 - SYS_REXEC = 0x381 // 897 - SYS___ISASCII2 = 0x382 // 898 - SYS___TOASCII2 = 0x383 // 899 - SYS_CHPRIORITY = 0x384 // 900 - SYS_PTHREAD_ATTR_SETSYNCTYPE_NP = 0x385 // 901 - SYS_PTHREAD_ATTR_GETSYNCTYPE_NP = 0x386 // 902 - SYS_PTHREAD_SET_LIMIT_NP = 0x387 // 903 - SYS___STNETENT = 0x388 // 904 - SYS___STPROTOENT = 0x389 // 905 - SYS___STSERVENT = 0x38A // 906 - SYS___STHOSTENT = 0x38B // 907 - SYS_NLIST = 0x38C // 908 - SYS___IPDBCS = 0x38D // 909 - SYS___IPDSPX = 0x38E // 910 - SYS___IPMSGC = 0x38F // 911 - SYS___SELECT1 = 0x390 // 912 - SYS_PTHREAD_SECURITY_NP = 0x391 // 913 - SYS___CHECK_RESOURCE_AUTH_NP = 0x392 // 914 - SYS___CONVERT_ID_NP = 0x393 // 915 - SYS___OPENVMREL = 0x394 // 916 - SYS_WMEMCHR = 0x395 // 917 - SYS_WMEMCMP = 0x396 // 918 - SYS_WMEMCPY = 0x397 // 919 - SYS_WMEMMOVE = 0x398 // 920 - SYS_WMEMSET = 0x399 // 921 - SYS___FPUTWC = 0x400 // 1024 - SYS___PUTWC = 0x401 // 1025 - SYS___PWCHAR = 0x402 // 1026 - SYS___WCSFTM = 0x403 // 1027 - SYS___WCSTOK = 0x404 // 1028 - SYS___WCWDTH = 0x405 // 1029 - SYS_T_ACCEPT = 0x409 // 1033 - SYS_T_ALLOC = 0x40A // 1034 - SYS_T_BIND = 0x40B // 1035 - SYS_T_CLOSE = 0x40C // 1036 - SYS_T_CONNECT = 0x40D // 1037 - SYS_T_ERROR = 0x40E // 1038 - SYS_T_FREE = 0x40F // 1039 - SYS_T_GETINFO = 0x410 // 1040 - SYS_T_GETPROTADDR = 0x411 // 1041 - SYS_T_GETSTATE = 0x412 // 1042 - SYS_T_LISTEN = 0x413 // 1043 - SYS_T_LOOK = 0x414 // 1044 - SYS_T_OPEN = 0x415 // 1045 - SYS_T_OPTMGMT = 0x416 // 1046 - SYS_T_RCV = 0x417 // 1047 - SYS_T_RCVCONNECT = 0x418 // 1048 - SYS_T_RCVDIS = 0x419 // 1049 - SYS_T_RCVREL = 0x41A // 1050 - SYS_T_RCVUDATA = 0x41B // 1051 - SYS_T_RCVUDERR = 0x41C // 1052 - SYS_T_SND = 0x41D // 1053 - SYS_T_SNDDIS = 0x41E // 1054 - SYS_T_SNDREL = 0x41F // 1055 - SYS_T_SNDUDATA = 0x420 // 1056 - SYS_T_STRERROR = 0x421 // 1057 - SYS_T_SYNC = 0x422 // 1058 - SYS_T_UNBIND = 0x423 // 1059 - SYS___T_ERRNO = 0x424 // 1060 - SYS___RECVMSG2 = 0x425 // 1061 - SYS___SENDMSG2 = 0x426 // 1062 - SYS_FATTACH = 0x427 // 1063 - SYS_FDETACH = 0x428 // 1064 - SYS_GETMSG = 0x429 // 1065 - SYS_GETPMSG = 0x42A // 1066 - SYS_ISASTREAM = 0x42B // 1067 - SYS_PUTMSG = 0x42C // 1068 - SYS_PUTPMSG = 0x42D // 1069 - SYS___ISPOSIXON = 0x42E // 1070 - SYS___OPENMVSREL = 0x42F // 1071 - SYS_GETCONTEXT = 0x430 // 1072 - SYS_SETCONTEXT = 0x431 // 1073 - SYS_MAKECONTEXT = 0x432 // 1074 - SYS_SWAPCONTEXT = 0x433 // 1075 - SYS_PTHREAD_GETSPECIFIC_D8_NP = 0x434 // 1076 - SYS_GETCLIENTID = 0x470 // 1136 - SYS___GETCLIENTID = 0x471 // 1137 - SYS_GETSTABLESIZE = 0x472 // 1138 - SYS_GETIBMOPT = 0x473 // 1139 - SYS_GETIBMSOCKOPT = 0x474 // 1140 - SYS_GIVESOCKET = 0x475 // 1141 - SYS_IBMSFLUSH = 0x476 // 1142 - SYS_MAXDESC = 0x477 // 1143 - SYS_SETIBMOPT = 0x478 // 1144 - SYS_SETIBMSOCKOPT = 0x479 // 1145 - SYS_SOCK_DEBUG = 0x47A // 1146 - SYS_SOCK_DO_TESTSTOR = 0x47D // 1149 - SYS_TAKESOCKET = 0x47E // 1150 - SYS___SERVER_INIT = 0x47F // 1151 - SYS___SERVER_PWU = 0x480 // 1152 - SYS_PTHREAD_TAG_NP = 0x481 // 1153 - SYS___CONSOLE = 0x482 // 1154 - SYS___WSINIT = 0x483 // 1155 - SYS___IPTCPN = 0x489 // 1161 - SYS___SMF_RECORD = 0x48A // 1162 - SYS___IPHOST = 0x48B // 1163 - SYS___IPNODE = 0x48C // 1164 - SYS___SERVER_CLASSIFY_CREATE = 0x48D // 1165 - SYS___SERVER_CLASSIFY_DESTROY = 0x48E // 1166 - SYS___SERVER_CLASSIFY_RESET = 0x48F // 1167 - SYS___SERVER_CLASSIFY = 0x490 // 1168 - SYS___HEAPRPT = 0x496 // 1174 - SYS___FNWSA = 0x49B // 1179 - SYS___SPAWN2 = 0x49D // 1181 - SYS___SPAWNP2 = 0x49E // 1182 - SYS___GDRR = 0x4A1 // 1185 - SYS___HRRNO = 0x4A2 // 1186 - SYS___OPRG = 0x4A3 // 1187 - SYS___OPRR = 0x4A4 // 1188 - SYS___OPND = 0x4A5 // 1189 - SYS___OPPT = 0x4A6 // 1190 - SYS___SIGGM = 0x4A7 // 1191 - SYS___DGHT = 0x4A8 // 1192 - SYS___TZNE = 0x4A9 // 1193 - SYS___TZZN = 0x4AA // 1194 - SYS___TRRNO = 0x4AF // 1199 - SYS___ENVN = 0x4B0 // 1200 - SYS___MLOCKALL = 0x4B1 // 1201 - SYS_CREATEWO = 0x4B2 // 1202 - SYS_CREATEWORKUNIT = 0x4B2 // 1202 - SYS_CONTINUE = 0x4B3 // 1203 - SYS_CONTINUEWORKUNIT = 0x4B3 // 1203 - SYS_CONNECTW = 0x4B4 // 1204 - SYS_CONNECTWORKMGR = 0x4B4 // 1204 - SYS_CONNECTS = 0x4B5 // 1205 - SYS_CONNECTSERVER = 0x4B5 // 1205 - SYS_DISCONNE = 0x4B6 // 1206 - SYS_DISCONNECTSERVER = 0x4B6 // 1206 - SYS_JOINWORK = 0x4B7 // 1207 - SYS_JOINWORKUNIT = 0x4B7 // 1207 - SYS_LEAVEWOR = 0x4B8 // 1208 - SYS_LEAVEWORKUNIT = 0x4B8 // 1208 - SYS_DELETEWO = 0x4B9 // 1209 - SYS_DELETEWORKUNIT = 0x4B9 // 1209 - SYS_QUERYMET = 0x4BA // 1210 - SYS_QUERYMETRICS = 0x4BA // 1210 - SYS_QUERYSCH = 0x4BB // 1211 - SYS_QUERYSCHENV = 0x4BB // 1211 - SYS_CHECKSCH = 0x4BC // 1212 - SYS_CHECKSCHENV = 0x4BC // 1212 - SYS___PID_AFFINITY = 0x4BD // 1213 - SYS___ASINH_B = 0x4BE // 1214 - SYS___ATAN_B = 0x4BF // 1215 - SYS___CBRT_B = 0x4C0 // 1216 - SYS___CEIL_B = 0x4C1 // 1217 - SYS_COPYSIGN = 0x4C2 // 1218 - SYS___COS_B = 0x4C3 // 1219 - SYS___ERF_B = 0x4C4 // 1220 - SYS___ERFC_B = 0x4C5 // 1221 - SYS___EXPM1_B = 0x4C6 // 1222 - SYS___FABS_B = 0x4C7 // 1223 - SYS_FINITE = 0x4C8 // 1224 - SYS___FLOOR_B = 0x4C9 // 1225 - SYS___FREXP_B = 0x4CA // 1226 - SYS___ILOGB_B = 0x4CB // 1227 - SYS___ISNAN_B = 0x4CC // 1228 - SYS___LDEXP_B = 0x4CD // 1229 - SYS___LOG1P_B = 0x4CE // 1230 - SYS___LOGB_B = 0x4CF // 1231 - SYS_MATHERR = 0x4D0 // 1232 - SYS___MODF_B = 0x4D1 // 1233 - SYS___NEXTAFTER_B = 0x4D2 // 1234 - SYS___RINT_B = 0x4D3 // 1235 - SYS_SCALBN = 0x4D4 // 1236 - SYS_SIGNIFIC = 0x4D5 // 1237 - SYS_SIGNIFICAND = 0x4D5 // 1237 - SYS___SIN_B = 0x4D6 // 1238 - SYS___TAN_B = 0x4D7 // 1239 - SYS___TANH_B = 0x4D8 // 1240 - SYS___ACOS_B = 0x4D9 // 1241 - SYS___ACOSH_B = 0x4DA // 1242 - SYS___ASIN_B = 0x4DB // 1243 - SYS___ATAN2_B = 0x4DC // 1244 - SYS___ATANH_B = 0x4DD // 1245 - SYS___COSH_B = 0x4DE // 1246 - SYS___EXP_B = 0x4DF // 1247 - SYS___FMOD_B = 0x4E0 // 1248 - SYS___GAMMA_B = 0x4E1 // 1249 - SYS_GAMMA_R = 0x4E2 // 1250 - SYS___HYPOT_B = 0x4E3 // 1251 - SYS___J0_B = 0x4E4 // 1252 - SYS___Y0_B = 0x4E5 // 1253 - SYS___J1_B = 0x4E6 // 1254 - SYS___Y1_B = 0x4E7 // 1255 - SYS___JN_B = 0x4E8 // 1256 - SYS___YN_B = 0x4E9 // 1257 - SYS___LGAMMA_B = 0x4EA // 1258 - SYS_LGAMMA_R = 0x4EB // 1259 - SYS___LOG_B = 0x4EC // 1260 - SYS___LOG10_B = 0x4ED // 1261 - SYS___POW_B = 0x4EE // 1262 - SYS___REMAINDER_B = 0x4EF // 1263 - SYS___SCALB_B = 0x4F0 // 1264 - SYS___SINH_B = 0x4F1 // 1265 - SYS___SQRT_B = 0x4F2 // 1266 - SYS___OPENDIR2 = 0x4F3 // 1267 - SYS___READDIR2 = 0x4F4 // 1268 - SYS___LOGIN = 0x4F5 // 1269 - SYS___OPEN_STAT = 0x4F6 // 1270 - SYS_ACCEPT_AND_RECV = 0x4F7 // 1271 - SYS___FP_SETMODE = 0x4F8 // 1272 - SYS___SIGACTIONSET = 0x4FB // 1275 - SYS___UCREATE = 0x4FC // 1276 - SYS___UMALLOC = 0x4FD // 1277 - SYS___UFREE = 0x4FE // 1278 - SYS___UHEAPREPORT = 0x4FF // 1279 - SYS___ISBFP = 0x500 // 1280 - SYS___FP_CAST = 0x501 // 1281 - SYS___CERTIFICATE = 0x502 // 1282 - SYS_SEND_FILE = 0x503 // 1283 - SYS_AIO_CANCEL = 0x504 // 1284 - SYS_AIO_ERROR = 0x505 // 1285 - SYS_AIO_READ = 0x506 // 1286 - SYS_AIO_RETURN = 0x507 // 1287 - SYS_AIO_SUSPEND = 0x508 // 1288 - SYS_AIO_WRITE = 0x509 // 1289 - SYS_PTHREAD_MUTEXATTR_GETPSHARED = 0x50A // 1290 - SYS_PTHREAD_MUTEXATTR_SETPSHARED = 0x50B // 1291 - SYS_PTHREAD_RWLOCK_DESTROY = 0x50C // 1292 - SYS_PTHREAD_RWLOCK_INIT = 0x50D // 1293 - SYS_PTHREAD_RWLOCK_RDLOCK = 0x50E // 1294 - SYS_PTHREAD_RWLOCK_TRYRDLOCK = 0x50F // 1295 - SYS_PTHREAD_RWLOCK_TRYWRLOCK = 0x510 // 1296 - SYS_PTHREAD_RWLOCK_UNLOCK = 0x511 // 1297 - SYS_PTHREAD_RWLOCK_WRLOCK = 0x512 // 1298 - SYS_PTHREAD_RWLOCKATTR_GETPSHARED = 0x513 // 1299 - SYS_PTHREAD_RWLOCKATTR_SETPSHARED = 0x514 // 1300 - SYS_PTHREAD_RWLOCKATTR_INIT = 0x515 // 1301 - SYS_PTHREAD_RWLOCKATTR_DESTROY = 0x516 // 1302 - SYS___CTTBL = 0x517 // 1303 - SYS_PTHREAD_MUTEXATTR_SETTYPE = 0x518 // 1304 - SYS_PTHREAD_MUTEXATTR_GETTYPE = 0x519 // 1305 - SYS___FP_CLR_FLAG = 0x51A // 1306 - SYS___FP_READ_FLAG = 0x51B // 1307 - SYS___FP_RAISE_XCP = 0x51C // 1308 - SYS___FP_CLASS = 0x51D // 1309 - SYS___FP_FINITE = 0x51E // 1310 - SYS___FP_ISNAN = 0x51F // 1311 - SYS___FP_UNORDERED = 0x520 // 1312 - SYS___FP_READ_RND = 0x521 // 1313 - SYS___FP_READ_RND_B = 0x522 // 1314 - SYS___FP_SWAP_RND = 0x523 // 1315 - SYS___FP_SWAP_RND_B = 0x524 // 1316 - SYS___FP_LEVEL = 0x525 // 1317 - SYS___FP_BTOH = 0x526 // 1318 - SYS___FP_HTOB = 0x527 // 1319 - SYS___FPC_RD = 0x528 // 1320 - SYS___FPC_WR = 0x529 // 1321 - SYS___FPC_RW = 0x52A // 1322 - SYS___FPC_SM = 0x52B // 1323 - SYS___FPC_RS = 0x52C // 1324 - SYS_SIGTIMEDWAIT = 0x52D // 1325 - SYS_SIGWAITINFO = 0x52E // 1326 - SYS___CHKBFP = 0x52F // 1327 - SYS___W_PIOCTL = 0x59E // 1438 - SYS___OSENV = 0x59F // 1439 - SYS_EXPORTWO = 0x5A1 // 1441 - SYS_EXPORTWORKUNIT = 0x5A1 // 1441 - SYS_UNDOEXPO = 0x5A2 // 1442 - SYS_UNDOEXPORTWORKUNIT = 0x5A2 // 1442 - SYS_IMPORTWO = 0x5A3 // 1443 - SYS_IMPORTWORKUNIT = 0x5A3 // 1443 - SYS_UNDOIMPO = 0x5A4 // 1444 - SYS_UNDOIMPORTWORKUNIT = 0x5A4 // 1444 - SYS_EXTRACTW = 0x5A5 // 1445 - SYS_EXTRACTWORKUNIT = 0x5A5 // 1445 - SYS___CPL = 0x5A6 // 1446 - SYS___MAP_INIT = 0x5A7 // 1447 - SYS___MAP_SERVICE = 0x5A8 // 1448 - SYS_SIGQUEUE = 0x5A9 // 1449 - SYS___MOUNT = 0x5AA // 1450 - SYS___GETUSERID = 0x5AB // 1451 - SYS___IPDOMAINNAME = 0x5AC // 1452 - SYS_QUERYENC = 0x5AD // 1453 - SYS_QUERYWORKUNITCLASSIFICATION = 0x5AD // 1453 - SYS_CONNECTE = 0x5AE // 1454 - SYS_CONNECTEXPORTIMPORT = 0x5AE // 1454 - SYS___FP_SWAPMODE = 0x5AF // 1455 - SYS_STRTOLL = 0x5B0 // 1456 - SYS_STRTOULL = 0x5B1 // 1457 - SYS___DSA_PREV = 0x5B2 // 1458 - SYS___EP_FIND = 0x5B3 // 1459 - SYS___SERVER_THREADS_QUERY = 0x5B4 // 1460 - SYS___MSGRCV_TIMED = 0x5B7 // 1463 - SYS___SEMOP_TIMED = 0x5B8 // 1464 - SYS___GET_CPUID = 0x5B9 // 1465 - SYS___GET_SYSTEM_SETTINGS = 0x5BA // 1466 - SYS_FTELLO = 0x5C8 // 1480 - SYS_FSEEKO = 0x5C9 // 1481 - SYS_LLDIV = 0x5CB // 1483 - SYS_WCSTOLL = 0x5CC // 1484 - SYS_WCSTOULL = 0x5CD // 1485 - SYS_LLABS = 0x5CE // 1486 - SYS___CONSOLE2 = 0x5D2 // 1490 - SYS_INET_NTOP = 0x5D3 // 1491 - SYS_INET_PTON = 0x5D4 // 1492 - SYS___RES = 0x5D6 // 1494 - SYS_RES_MKQUERY = 0x5D7 // 1495 - SYS_RES_INIT = 0x5D8 // 1496 - SYS_RES_QUERY = 0x5D9 // 1497 - SYS_RES_SEARCH = 0x5DA // 1498 - SYS_RES_SEND = 0x5DB // 1499 - SYS_RES_QUERYDOMAIN = 0x5DC // 1500 - SYS_DN_EXPAND = 0x5DD // 1501 - SYS_DN_SKIPNAME = 0x5DE // 1502 - SYS_DN_COMP = 0x5DF // 1503 - SYS_ASCTIME_R = 0x5E0 // 1504 - SYS_CTIME_R = 0x5E1 // 1505 - SYS_GMTIME_R = 0x5E2 // 1506 - SYS_LOCALTIME_R = 0x5E3 // 1507 - SYS_RAND_R = 0x5E4 // 1508 - SYS_STRTOK_R = 0x5E5 // 1509 - SYS_READDIR_R = 0x5E6 // 1510 - SYS_GETGRGID_R = 0x5E7 // 1511 - SYS_GETGRNAM_R = 0x5E8 // 1512 - SYS_GETLOGIN_R = 0x5E9 // 1513 - SYS_GETPWNAM_R = 0x5EA // 1514 - SYS_GETPWUID_R = 0x5EB // 1515 - SYS_TTYNAME_R = 0x5EC // 1516 - SYS_PTHREAD_ATFORK = 0x5ED // 1517 - SYS_PTHREAD_ATTR_GETGUARDSIZE = 0x5EE // 1518 - SYS_PTHREAD_ATTR_GETSTACKADDR = 0x5EF // 1519 - SYS_PTHREAD_ATTR_SETGUARDSIZE = 0x5F0 // 1520 - SYS_PTHREAD_ATTR_SETSTACKADDR = 0x5F1 // 1521 - SYS_PTHREAD_CONDATTR_GETPSHARED = 0x5F2 // 1522 - SYS_PTHREAD_CONDATTR_SETPSHARED = 0x5F3 // 1523 - SYS_PTHREAD_GETCONCURRENCY = 0x5F4 // 1524 - SYS_PTHREAD_KEY_DELETE = 0x5F5 // 1525 - SYS_PTHREAD_SETCONCURRENCY = 0x5F6 // 1526 - SYS_PTHREAD_SIGMASK = 0x5F7 // 1527 - SYS___DISCARDDATA = 0x5F8 // 1528 - SYS_PTHREAD_ATTR_GETSCHEDPARAM = 0x5F9 // 1529 - SYS_PTHREAD_ATTR_SETSCHEDPARAM = 0x5FA // 1530 - SYS_PTHREAD_ATTR_GETDETACHSTATE_U98 = 0x5FB // 1531 - SYS_PTHREAD_ATTR_SETDETACHSTATE_U98 = 0x5FC // 1532 - SYS_PTHREAD_DETACH_U98 = 0x5FD // 1533 - SYS_PTHREAD_GETSPECIFIC_U98 = 0x5FE // 1534 - SYS_PTHREAD_SETCANCELSTATE = 0x5FF // 1535 - SYS_PTHREAD_SETCANCELTYPE = 0x600 // 1536 - SYS_PTHREAD_TESTCANCEL = 0x601 // 1537 - SYS___ATANF_B = 0x602 // 1538 - SYS___ATANL_B = 0x603 // 1539 - SYS___CEILF_B = 0x604 // 1540 - SYS___CEILL_B = 0x605 // 1541 - SYS___COSF_B = 0x606 // 1542 - SYS___COSL_B = 0x607 // 1543 - SYS___FABSF_B = 0x608 // 1544 - SYS___FABSL_B = 0x609 // 1545 - SYS___FLOORF_B = 0x60A // 1546 - SYS___FLOORL_B = 0x60B // 1547 - SYS___FREXPF_B = 0x60C // 1548 - SYS___FREXPL_B = 0x60D // 1549 - SYS___LDEXPF_B = 0x60E // 1550 - SYS___LDEXPL_B = 0x60F // 1551 - SYS___SINF_B = 0x610 // 1552 - SYS___SINL_B = 0x611 // 1553 - SYS___TANF_B = 0x612 // 1554 - SYS___TANL_B = 0x613 // 1555 - SYS___TANHF_B = 0x614 // 1556 - SYS___TANHL_B = 0x615 // 1557 - SYS___ACOSF_B = 0x616 // 1558 - SYS___ACOSL_B = 0x617 // 1559 - SYS___ASINF_B = 0x618 // 1560 - SYS___ASINL_B = 0x619 // 1561 - SYS___ATAN2F_B = 0x61A // 1562 - SYS___ATAN2L_B = 0x61B // 1563 - SYS___COSHF_B = 0x61C // 1564 - SYS___COSHL_B = 0x61D // 1565 - SYS___EXPF_B = 0x61E // 1566 - SYS___EXPL_B = 0x61F // 1567 - SYS___LOGF_B = 0x620 // 1568 - SYS___LOGL_B = 0x621 // 1569 - SYS___LOG10F_B = 0x622 // 1570 - SYS___LOG10L_B = 0x623 // 1571 - SYS___POWF_B = 0x624 // 1572 - SYS___POWL_B = 0x625 // 1573 - SYS___SINHF_B = 0x626 // 1574 - SYS___SINHL_B = 0x627 // 1575 - SYS___SQRTF_B = 0x628 // 1576 - SYS___SQRTL_B = 0x629 // 1577 - SYS___ABSF_B = 0x62A // 1578 - SYS___ABS_B = 0x62B // 1579 - SYS___ABSL_B = 0x62C // 1580 - SYS___FMODF_B = 0x62D // 1581 - SYS___FMODL_B = 0x62E // 1582 - SYS___MODFF_B = 0x62F // 1583 - SYS___MODFL_B = 0x630 // 1584 - SYS_ABSF = 0x631 // 1585 - SYS_ABSL = 0x632 // 1586 - SYS_ACOSF = 0x633 // 1587 - SYS_ACOSL = 0x634 // 1588 - SYS_ASINF = 0x635 // 1589 - SYS_ASINL = 0x636 // 1590 - SYS_ATAN2F = 0x637 // 1591 - SYS_ATAN2L = 0x638 // 1592 - SYS_ATANF = 0x639 // 1593 - SYS_ATANL = 0x63A // 1594 - SYS_CEILF = 0x63B // 1595 - SYS_CEILL = 0x63C // 1596 - SYS_COSF = 0x63D // 1597 - SYS_COSL = 0x63E // 1598 - SYS_COSHF = 0x63F // 1599 - SYS_COSHL = 0x640 // 1600 - SYS_EXPF = 0x641 // 1601 - SYS_EXPL = 0x642 // 1602 - SYS_TANHF = 0x643 // 1603 - SYS_TANHL = 0x644 // 1604 - SYS_LOG10F = 0x645 // 1605 - SYS_LOG10L = 0x646 // 1606 - SYS_LOGF = 0x647 // 1607 - SYS_LOGL = 0x648 // 1608 - SYS_POWF = 0x649 // 1609 - SYS_POWL = 0x64A // 1610 - SYS_SINF = 0x64B // 1611 - SYS_SINL = 0x64C // 1612 - SYS_SQRTF = 0x64D // 1613 - SYS_SQRTL = 0x64E // 1614 - SYS_SINHF = 0x64F // 1615 - SYS_SINHL = 0x650 // 1616 - SYS_TANF = 0x651 // 1617 - SYS_TANL = 0x652 // 1618 - SYS_FABSF = 0x653 // 1619 - SYS_FABSL = 0x654 // 1620 - SYS_FLOORF = 0x655 // 1621 - SYS_FLOORL = 0x656 // 1622 - SYS_FMODF = 0x657 // 1623 - SYS_FMODL = 0x658 // 1624 - SYS_FREXPF = 0x659 // 1625 - SYS_FREXPL = 0x65A // 1626 - SYS_LDEXPF = 0x65B // 1627 - SYS_LDEXPL = 0x65C // 1628 - SYS_MODFF = 0x65D // 1629 - SYS_MODFL = 0x65E // 1630 - SYS_BTOWC = 0x65F // 1631 - SYS___CHATTR = 0x660 // 1632 - SYS___FCHATTR = 0x661 // 1633 - SYS___TOCCSID = 0x662 // 1634 - SYS___CSNAMETYPE = 0x663 // 1635 - SYS___TOCSNAME = 0x664 // 1636 - SYS___CCSIDTYPE = 0x665 // 1637 - SYS___AE_CORRESTBL_QUERY = 0x666 // 1638 - SYS___AE_AUTOCONVERT_STATE = 0x667 // 1639 - SYS_DN_FIND = 0x668 // 1640 - SYS___GETHOSTBYADDR_A = 0x669 // 1641 - SYS___GETHOSTBYNAME_A = 0x66A // 1642 - SYS___RES_INIT_A = 0x66B // 1643 - SYS___GETHOSTBYADDR_R_A = 0x66C // 1644 - SYS___GETHOSTBYNAME_R_A = 0x66D // 1645 - SYS___CHARMAP_INIT_A = 0x66E // 1646 - SYS___MBLEN_A = 0x66F // 1647 - SYS___MBLEN_SB_A = 0x670 // 1648 - SYS___MBLEN_STD_A = 0x671 // 1649 - SYS___MBLEN_UTF = 0x672 // 1650 - SYS___MBSTOWCS_A = 0x673 // 1651 - SYS___MBSTOWCS_STD_A = 0x674 // 1652 - SYS___MBTOWC_A = 0x675 // 1653 - SYS___MBTOWC_ISO1 = 0x676 // 1654 - SYS___MBTOWC_SBCS = 0x677 // 1655 - SYS___MBTOWC_MBCS = 0x678 // 1656 - SYS___MBTOWC_UTF = 0x679 // 1657 - SYS___WCSTOMBS_A = 0x67A // 1658 - SYS___WCSTOMBS_STD_A = 0x67B // 1659 - SYS___WCSWIDTH_A = 0x67C // 1660 - SYS___GETGRGID_R_A = 0x67D // 1661 - SYS___WCSWIDTH_STD_A = 0x67E // 1662 - SYS___WCSWIDTH_ASIA = 0x67F // 1663 - SYS___CSID_A = 0x680 // 1664 - SYS___CSID_STD_A = 0x681 // 1665 - SYS___WCSID_A = 0x682 // 1666 - SYS___WCSID_STD_A = 0x683 // 1667 - SYS___WCTOMB_A = 0x684 // 1668 - SYS___WCTOMB_ISO1 = 0x685 // 1669 - SYS___WCTOMB_STD_A = 0x686 // 1670 - SYS___WCTOMB_UTF = 0x687 // 1671 - SYS___WCWIDTH_A = 0x688 // 1672 - SYS___GETGRNAM_R_A = 0x689 // 1673 - SYS___WCWIDTH_STD_A = 0x68A // 1674 - SYS___WCWIDTH_ASIA = 0x68B // 1675 - SYS___GETPWNAM_R_A = 0x68C // 1676 - SYS___GETPWUID_R_A = 0x68D // 1677 - SYS___GETLOGIN_R_A = 0x68E // 1678 - SYS___TTYNAME_R_A = 0x68F // 1679 - SYS___READDIR_R_A = 0x690 // 1680 - SYS___E2A_S = 0x691 // 1681 - SYS___FNMATCH_A = 0x692 // 1682 - SYS___FNMATCH_C_A = 0x693 // 1683 - SYS___EXECL_A = 0x694 // 1684 - SYS___FNMATCH_STD_A = 0x695 // 1685 - SYS___REGCOMP_A = 0x696 // 1686 - SYS___REGCOMP_STD_A = 0x697 // 1687 - SYS___REGERROR_A = 0x698 // 1688 - SYS___REGERROR_STD_A = 0x699 // 1689 - SYS___REGEXEC_A = 0x69A // 1690 - SYS___REGEXEC_STD_A = 0x69B // 1691 - SYS___REGFREE_A = 0x69C // 1692 - SYS___REGFREE_STD_A = 0x69D // 1693 - SYS___STRCOLL_A = 0x69E // 1694 - SYS___STRCOLL_C_A = 0x69F // 1695 - SYS___EXECLE_A = 0x6A0 // 1696 - SYS___STRCOLL_STD_A = 0x6A1 // 1697 - SYS___STRXFRM_A = 0x6A2 // 1698 - SYS___STRXFRM_C_A = 0x6A3 // 1699 - SYS___EXECLP_A = 0x6A4 // 1700 - SYS___STRXFRM_STD_A = 0x6A5 // 1701 - SYS___WCSCOLL_A = 0x6A6 // 1702 - SYS___WCSCOLL_C_A = 0x6A7 // 1703 - SYS___WCSCOLL_STD_A = 0x6A8 // 1704 - SYS___WCSXFRM_A = 0x6A9 // 1705 - SYS___WCSXFRM_C_A = 0x6AA // 1706 - SYS___WCSXFRM_STD_A = 0x6AB // 1707 - SYS___COLLATE_INIT_A = 0x6AC // 1708 - SYS___WCTYPE_A = 0x6AD // 1709 - SYS___GET_WCTYPE_STD_A = 0x6AE // 1710 - SYS___CTYPE_INIT_A = 0x6AF // 1711 - SYS___ISWCTYPE_A = 0x6B0 // 1712 - SYS___EXECV_A = 0x6B1 // 1713 - SYS___IS_WCTYPE_STD_A = 0x6B2 // 1714 - SYS___TOWLOWER_A = 0x6B3 // 1715 - SYS___TOWLOWER_STD_A = 0x6B4 // 1716 - SYS___TOWUPPER_A = 0x6B5 // 1717 - SYS___TOWUPPER_STD_A = 0x6B6 // 1718 - SYS___LOCALE_INIT_A = 0x6B7 // 1719 - SYS___LOCALECONV_A = 0x6B8 // 1720 - SYS___LOCALECONV_STD_A = 0x6B9 // 1721 - SYS___NL_LANGINFO_A = 0x6BA // 1722 - SYS___NL_LNAGINFO_STD_A = 0x6BB // 1723 - SYS___MONETARY_INIT_A = 0x6BC // 1724 - SYS___STRFMON_A = 0x6BD // 1725 - SYS___STRFMON_STD_A = 0x6BE // 1726 - SYS___GETADDRINFO_A = 0x6BF // 1727 - SYS___CATGETS_A = 0x6C0 // 1728 - SYS___EXECVE_A = 0x6C1 // 1729 - SYS___EXECVP_A = 0x6C2 // 1730 - SYS___SPAWN_A = 0x6C3 // 1731 - SYS___GETNAMEINFO_A = 0x6C4 // 1732 - SYS___SPAWNP_A = 0x6C5 // 1733 - SYS___NUMERIC_INIT_A = 0x6C6 // 1734 - SYS___RESP_INIT_A = 0x6C7 // 1735 - SYS___RPMATCH_A = 0x6C8 // 1736 - SYS___RPMATCH_C_A = 0x6C9 // 1737 - SYS___RPMATCH_STD_A = 0x6CA // 1738 - SYS___TIME_INIT_A = 0x6CB // 1739 - SYS___STRFTIME_A = 0x6CC // 1740 - SYS___STRFTIME_STD_A = 0x6CD // 1741 - SYS___STRPTIME_A = 0x6CE // 1742 - SYS___STRPTIME_STD_A = 0x6CF // 1743 - SYS___WCSFTIME_A = 0x6D0 // 1744 - SYS___WCSFTIME_STD_A = 0x6D1 // 1745 - SYS_____SPAWN2_A = 0x6D2 // 1746 - SYS_____SPAWNP2_A = 0x6D3 // 1747 - SYS___SYNTAX_INIT_A = 0x6D4 // 1748 - SYS___TOD_INIT_A = 0x6D5 // 1749 - SYS___NL_CSINFO_A = 0x6D6 // 1750 - SYS___NL_MONINFO_A = 0x6D7 // 1751 - SYS___NL_NUMINFO_A = 0x6D8 // 1752 - SYS___NL_RESPINFO_A = 0x6D9 // 1753 - SYS___NL_TIMINFO_A = 0x6DA // 1754 - SYS___IF_NAMETOINDEX_A = 0x6DB // 1755 - SYS___IF_INDEXTONAME_A = 0x6DC // 1756 - SYS___PRINTF_A = 0x6DD // 1757 - SYS___ICONV_OPEN_A = 0x6DE // 1758 - SYS___DLLLOAD_A = 0x6DF // 1759 - SYS___DLLQUERYFN_A = 0x6E0 // 1760 - SYS___DLLQUERYVAR_A = 0x6E1 // 1761 - SYS_____CHATTR_A = 0x6E2 // 1762 - SYS___E2A_L = 0x6E3 // 1763 - SYS_____TOCCSID_A = 0x6E4 // 1764 - SYS_____TOCSNAME_A = 0x6E5 // 1765 - SYS_____CCSIDTYPE_A = 0x6E6 // 1766 - SYS_____CSNAMETYPE_A = 0x6E7 // 1767 - SYS___CHMOD_A = 0x6E8 // 1768 - SYS___MKDIR_A = 0x6E9 // 1769 - SYS___STAT_A = 0x6EA // 1770 - SYS___STAT_O_A = 0x6EB // 1771 - SYS___MKFIFO_A = 0x6EC // 1772 - SYS_____OPEN_STAT_A = 0x6ED // 1773 - SYS___LSTAT_A = 0x6EE // 1774 - SYS___LSTAT_O_A = 0x6EF // 1775 - SYS___MKNOD_A = 0x6F0 // 1776 - SYS___MOUNT_A = 0x6F1 // 1777 - SYS___UMOUNT_A = 0x6F2 // 1778 - SYS___CHAUDIT_A = 0x6F4 // 1780 - SYS___W_GETMNTENT_A = 0x6F5 // 1781 - SYS___CREAT_A = 0x6F6 // 1782 - SYS___OPEN_A = 0x6F7 // 1783 - SYS___SETLOCALE_A = 0x6F9 // 1785 - SYS___FPRINTF_A = 0x6FA // 1786 - SYS___SPRINTF_A = 0x6FB // 1787 - SYS___VFPRINTF_A = 0x6FC // 1788 - SYS___VPRINTF_A = 0x6FD // 1789 - SYS___VSPRINTF_A = 0x6FE // 1790 - SYS___VSWPRINTF_A = 0x6FF // 1791 - SYS___SWPRINTF_A = 0x700 // 1792 - SYS___FSCANF_A = 0x701 // 1793 - SYS___SCANF_A = 0x702 // 1794 - SYS___SSCANF_A = 0x703 // 1795 - SYS___SWSCANF_A = 0x704 // 1796 - SYS___ATOF_A = 0x705 // 1797 - SYS___ATOI_A = 0x706 // 1798 - SYS___ATOL_A = 0x707 // 1799 - SYS___STRTOD_A = 0x708 // 1800 - SYS___STRTOL_A = 0x709 // 1801 - SYS___STRTOUL_A = 0x70A // 1802 - SYS_____AE_CORRESTBL_QUERY_A = 0x70B // 1803 - SYS___A64L_A = 0x70C // 1804 - SYS___ECVT_A = 0x70D // 1805 - SYS___FCVT_A = 0x70E // 1806 - SYS___GCVT_A = 0x70F // 1807 - SYS___L64A_A = 0x710 // 1808 - SYS___STRERROR_A = 0x711 // 1809 - SYS___PERROR_A = 0x712 // 1810 - SYS___FETCH_A = 0x713 // 1811 - SYS___GETENV_A = 0x714 // 1812 - SYS___MKSTEMP_A = 0x717 // 1815 - SYS___PTSNAME_A = 0x718 // 1816 - SYS___PUTENV_A = 0x719 // 1817 - SYS___REALPATH_A = 0x71A // 1818 - SYS___SETENV_A = 0x71B // 1819 - SYS___SYSTEM_A = 0x71C // 1820 - SYS___GETOPT_A = 0x71D // 1821 - SYS___CATOPEN_A = 0x71E // 1822 - SYS___ACCESS_A = 0x71F // 1823 - SYS___CHDIR_A = 0x720 // 1824 - SYS___CHOWN_A = 0x721 // 1825 - SYS___CHROOT_A = 0x722 // 1826 - SYS___GETCWD_A = 0x723 // 1827 - SYS___GETWD_A = 0x724 // 1828 - SYS___LCHOWN_A = 0x725 // 1829 - SYS___LINK_A = 0x726 // 1830 - SYS___PATHCONF_A = 0x727 // 1831 - SYS___IF_NAMEINDEX_A = 0x728 // 1832 - SYS___READLINK_A = 0x729 // 1833 - SYS___RMDIR_A = 0x72A // 1834 - SYS___STATVFS_A = 0x72B // 1835 - SYS___SYMLINK_A = 0x72C // 1836 - SYS___TRUNCATE_A = 0x72D // 1837 - SYS___UNLINK_A = 0x72E // 1838 - SYS___GAI_STRERROR_A = 0x72F // 1839 - SYS___EXTLINK_NP_A = 0x730 // 1840 - SYS___ISALNUM_A = 0x731 // 1841 - SYS___ISALPHA_A = 0x732 // 1842 - SYS___A2E_S = 0x733 // 1843 - SYS___ISCNTRL_A = 0x734 // 1844 - SYS___ISDIGIT_A = 0x735 // 1845 - SYS___ISGRAPH_A = 0x736 // 1846 - SYS___ISLOWER_A = 0x737 // 1847 - SYS___ISPRINT_A = 0x738 // 1848 - SYS___ISPUNCT_A = 0x739 // 1849 - SYS___ISSPACE_A = 0x73A // 1850 - SYS___ISUPPER_A = 0x73B // 1851 - SYS___ISXDIGIT_A = 0x73C // 1852 - SYS___TOLOWER_A = 0x73D // 1853 - SYS___TOUPPER_A = 0x73E // 1854 - SYS___ISWALNUM_A = 0x73F // 1855 - SYS___ISWALPHA_A = 0x740 // 1856 - SYS___A2E_L = 0x741 // 1857 - SYS___ISWCNTRL_A = 0x742 // 1858 - SYS___ISWDIGIT_A = 0x743 // 1859 - SYS___ISWGRAPH_A = 0x744 // 1860 - SYS___ISWLOWER_A = 0x745 // 1861 - SYS___ISWPRINT_A = 0x746 // 1862 - SYS___ISWPUNCT_A = 0x747 // 1863 - SYS___ISWSPACE_A = 0x748 // 1864 - SYS___ISWUPPER_A = 0x749 // 1865 - SYS___ISWXDIGIT_A = 0x74A // 1866 - SYS___CONFSTR_A = 0x74B // 1867 - SYS___FTOK_A = 0x74C // 1868 - SYS___MKTEMP_A = 0x74D // 1869 - SYS___FDOPEN_A = 0x74E // 1870 - SYS___FLDATA_A = 0x74F // 1871 - SYS___REMOVE_A = 0x750 // 1872 - SYS___RENAME_A = 0x751 // 1873 - SYS___TMPNAM_A = 0x752 // 1874 - SYS___FOPEN_A = 0x753 // 1875 - SYS___FREOPEN_A = 0x754 // 1876 - SYS___CUSERID_A = 0x755 // 1877 - SYS___POPEN_A = 0x756 // 1878 - SYS___TEMPNAM_A = 0x757 // 1879 - SYS___FTW_A = 0x758 // 1880 - SYS___GETGRENT_A = 0x759 // 1881 - SYS___GETGRGID_A = 0x75A // 1882 - SYS___GETGRNAM_A = 0x75B // 1883 - SYS___GETGROUPSBYNAME_A = 0x75C // 1884 - SYS___GETHOSTENT_A = 0x75D // 1885 - SYS___GETHOSTNAME_A = 0x75E // 1886 - SYS___GETLOGIN_A = 0x75F // 1887 - SYS___INET_NTOP_A = 0x760 // 1888 - SYS___GETPASS_A = 0x761 // 1889 - SYS___GETPWENT_A = 0x762 // 1890 - SYS___GETPWNAM_A = 0x763 // 1891 - SYS___GETPWUID_A = 0x764 // 1892 - SYS_____CHECK_RESOURCE_AUTH_NP_A = 0x765 // 1893 - SYS___CHECKSCHENV_A = 0x766 // 1894 - SYS___CONNECTSERVER_A = 0x767 // 1895 - SYS___CONNECTWORKMGR_A = 0x768 // 1896 - SYS_____CONSOLE_A = 0x769 // 1897 - SYS___CREATEWORKUNIT_A = 0x76A // 1898 - SYS___CTERMID_A = 0x76B // 1899 - SYS___FMTMSG_A = 0x76C // 1900 - SYS___INITGROUPS_A = 0x76D // 1901 - SYS_____LOGIN_A = 0x76E // 1902 - SYS___MSGRCV_A = 0x76F // 1903 - SYS___MSGSND_A = 0x770 // 1904 - SYS___MSGXRCV_A = 0x771 // 1905 - SYS___NFTW_A = 0x772 // 1906 - SYS_____PASSWD_A = 0x773 // 1907 - SYS___PTHREAD_SECURITY_NP_A = 0x774 // 1908 - SYS___QUERYMETRICS_A = 0x775 // 1909 - SYS___QUERYSCHENV = 0x776 // 1910 - SYS___READV_A = 0x777 // 1911 - SYS_____SERVER_CLASSIFY_A = 0x778 // 1912 - SYS_____SERVER_INIT_A = 0x779 // 1913 - SYS_____SERVER_PWU_A = 0x77A // 1914 - SYS___STRCASECMP_A = 0x77B // 1915 - SYS___STRNCASECMP_A = 0x77C // 1916 - SYS___TTYNAME_A = 0x77D // 1917 - SYS___UNAME_A = 0x77E // 1918 - SYS___UTIMES_A = 0x77F // 1919 - SYS___W_GETPSENT_A = 0x780 // 1920 - SYS___WRITEV_A = 0x781 // 1921 - SYS___W_STATFS_A = 0x782 // 1922 - SYS___W_STATVFS_A = 0x783 // 1923 - SYS___FPUTC_A = 0x784 // 1924 - SYS___PUTCHAR_A = 0x785 // 1925 - SYS___PUTS_A = 0x786 // 1926 - SYS___FGETS_A = 0x787 // 1927 - SYS___GETS_A = 0x788 // 1928 - SYS___FPUTS_A = 0x789 // 1929 - SYS___FREAD_A = 0x78A // 1930 - SYS___FWRITE_A = 0x78B // 1931 - SYS___OPEN_O_A = 0x78C // 1932 - SYS___ISASCII = 0x78D // 1933 - SYS___CREAT_O_A = 0x78E // 1934 - SYS___ENVNA = 0x78F // 1935 - SYS___PUTC_A = 0x790 // 1936 - SYS___AE_THREAD_SETMODE = 0x791 // 1937 - SYS___AE_THREAD_SWAPMODE = 0x792 // 1938 - SYS___GETNETBYADDR_A = 0x793 // 1939 - SYS___GETNETBYNAME_A = 0x794 // 1940 - SYS___GETNETENT_A = 0x795 // 1941 - SYS___GETPROTOBYNAME_A = 0x796 // 1942 - SYS___GETPROTOBYNUMBER_A = 0x797 // 1943 - SYS___GETPROTOENT_A = 0x798 // 1944 - SYS___GETSERVBYNAME_A = 0x799 // 1945 - SYS___GETSERVBYPORT_A = 0x79A // 1946 - SYS___GETSERVENT_A = 0x79B // 1947 - SYS___ASCTIME_A = 0x79C // 1948 - SYS___CTIME_A = 0x79D // 1949 - SYS___GETDATE_A = 0x79E // 1950 - SYS___TZSET_A = 0x79F // 1951 - SYS___UTIME_A = 0x7A0 // 1952 - SYS___ASCTIME_R_A = 0x7A1 // 1953 - SYS___CTIME_R_A = 0x7A2 // 1954 - SYS___STRTOLL_A = 0x7A3 // 1955 - SYS___STRTOULL_A = 0x7A4 // 1956 - SYS___FPUTWC_A = 0x7A5 // 1957 - SYS___PUTWC_A = 0x7A6 // 1958 - SYS___PUTWCHAR_A = 0x7A7 // 1959 - SYS___FPUTWS_A = 0x7A8 // 1960 - SYS___UNGETWC_A = 0x7A9 // 1961 - SYS___FGETWC_A = 0x7AA // 1962 - SYS___GETWC_A = 0x7AB // 1963 - SYS___GETWCHAR_A = 0x7AC // 1964 - SYS___FGETWS_A = 0x7AD // 1965 - SYS___GETTIMEOFDAY_A = 0x7AE // 1966 - SYS___GMTIME_A = 0x7AF // 1967 - SYS___GMTIME_R_A = 0x7B0 // 1968 - SYS___LOCALTIME_A = 0x7B1 // 1969 - SYS___LOCALTIME_R_A = 0x7B2 // 1970 - SYS___MKTIME_A = 0x7B3 // 1971 - SYS___TZZNA = 0x7B4 // 1972 - SYS_UNATEXIT = 0x7B5 // 1973 - SYS___CEE3DMP_A = 0x7B6 // 1974 - SYS___CDUMP_A = 0x7B7 // 1975 - SYS___CSNAP_A = 0x7B8 // 1976 - SYS___CTEST_A = 0x7B9 // 1977 - SYS___CTRACE_A = 0x7BA // 1978 - SYS___VSWPRNTF2_A = 0x7BB // 1979 - SYS___INET_PTON_A = 0x7BC // 1980 - SYS___SYSLOG_A = 0x7BD // 1981 - SYS___CRYPT_A = 0x7BE // 1982 - SYS_____OPENDIR2_A = 0x7BF // 1983 - SYS_____READDIR2_A = 0x7C0 // 1984 - SYS___OPENDIR_A = 0x7C2 // 1986 - SYS___READDIR_A = 0x7C3 // 1987 - SYS_PREAD = 0x7C7 // 1991 - SYS_PWRITE = 0x7C8 // 1992 - SYS_M_CREATE_LAYOUT = 0x7C9 // 1993 - SYS_M_DESTROY_LAYOUT = 0x7CA // 1994 - SYS_M_GETVALUES_LAYOUT = 0x7CB // 1995 - SYS_M_SETVALUES_LAYOUT = 0x7CC // 1996 - SYS_M_TRANSFORM_LAYOUT = 0x7CD // 1997 - SYS_M_WTRANSFORM_LAYOUT = 0x7CE // 1998 - SYS_FWPRINTF = 0x7D1 // 2001 - SYS_WPRINTF = 0x7D2 // 2002 - SYS_VFWPRINT = 0x7D3 // 2003 - SYS_VFWPRINTF = 0x7D3 // 2003 - SYS_VWPRINTF = 0x7D4 // 2004 - SYS_FWSCANF = 0x7D5 // 2005 - SYS_WSCANF = 0x7D6 // 2006 - SYS_WCTRANS = 0x7D7 // 2007 - SYS_TOWCTRAN = 0x7D8 // 2008 - SYS_TOWCTRANS = 0x7D8 // 2008 - SYS___WCSTOD_A = 0x7D9 // 2009 - SYS___WCSTOL_A = 0x7DA // 2010 - SYS___WCSTOUL_A = 0x7DB // 2011 - SYS___BASENAME_A = 0x7DC // 2012 - SYS___DIRNAME_A = 0x7DD // 2013 - SYS___GLOB_A = 0x7DE // 2014 - SYS_FWIDE = 0x7DF // 2015 - SYS___OSNAME = 0x7E0 // 2016 - SYS_____OSNAME_A = 0x7E1 // 2017 - SYS___BTOWC_A = 0x7E4 // 2020 - SYS___WCTOB_A = 0x7E5 // 2021 - SYS___DBM_OPEN_A = 0x7E6 // 2022 - SYS___VFPRINTF2_A = 0x7E7 // 2023 - SYS___VPRINTF2_A = 0x7E8 // 2024 - SYS___VSPRINTF2_A = 0x7E9 // 2025 - SYS___CEIL_H = 0x7EA // 2026 - SYS___FLOOR_H = 0x7EB // 2027 - SYS___MODF_H = 0x7EC // 2028 - SYS___FABS_H = 0x7ED // 2029 - SYS___J0_H = 0x7EE // 2030 - SYS___J1_H = 0x7EF // 2031 - SYS___JN_H = 0x7F0 // 2032 - SYS___Y0_H = 0x7F1 // 2033 - SYS___Y1_H = 0x7F2 // 2034 - SYS___YN_H = 0x7F3 // 2035 - SYS___CEILF_H = 0x7F4 // 2036 - SYS___CEILL_H = 0x7F5 // 2037 - SYS___FLOORF_H = 0x7F6 // 2038 - SYS___FLOORL_H = 0x7F7 // 2039 - SYS___MODFF_H = 0x7F8 // 2040 - SYS___MODFL_H = 0x7F9 // 2041 - SYS___FABSF_H = 0x7FA // 2042 - SYS___FABSL_H = 0x7FB // 2043 - SYS___MALLOC24 = 0x7FC // 2044 - SYS___MALLOC31 = 0x7FD // 2045 - SYS_ACL_INIT = 0x7FE // 2046 - SYS_ACL_FREE = 0x7FF // 2047 - SYS_ACL_FIRST_ENTRY = 0x800 // 2048 - SYS_ACL_GET_ENTRY = 0x801 // 2049 - SYS_ACL_VALID = 0x802 // 2050 - SYS_ACL_CREATE_ENTRY = 0x803 // 2051 - SYS_ACL_DELETE_ENTRY = 0x804 // 2052 - SYS_ACL_UPDATE_ENTRY = 0x805 // 2053 - SYS_ACL_DELETE_FD = 0x806 // 2054 - SYS_ACL_DELETE_FILE = 0x807 // 2055 - SYS_ACL_GET_FD = 0x808 // 2056 - SYS_ACL_GET_FILE = 0x809 // 2057 - SYS_ACL_SET_FD = 0x80A // 2058 - SYS_ACL_SET_FILE = 0x80B // 2059 - SYS_ACL_FROM_TEXT = 0x80C // 2060 - SYS_ACL_TO_TEXT = 0x80D // 2061 - SYS_ACL_SORT = 0x80E // 2062 - SYS___SHUTDOWN_REGISTRATION = 0x80F // 2063 - SYS___ERFL_B = 0x810 // 2064 - SYS___ERFCL_B = 0x811 // 2065 - SYS___LGAMMAL_B = 0x812 // 2066 - SYS___SETHOOKEVENTS = 0x813 // 2067 - SYS_IF_NAMETOINDEX = 0x814 // 2068 - SYS_IF_INDEXTONAME = 0x815 // 2069 - SYS_IF_NAMEINDEX = 0x816 // 2070 - SYS_IF_FREENAMEINDEX = 0x817 // 2071 - SYS_GETADDRINFO = 0x818 // 2072 - SYS_GETNAMEINFO = 0x819 // 2073 - SYS_FREEADDRINFO = 0x81A // 2074 - SYS_GAI_STRERROR = 0x81B // 2075 - SYS_REXEC_AF = 0x81C // 2076 - SYS___POE = 0x81D // 2077 - SYS___DYNALLOC_A = 0x81F // 2079 - SYS___DYNFREE_A = 0x820 // 2080 - SYS___RES_QUERY_A = 0x821 // 2081 - SYS___RES_SEARCH_A = 0x822 // 2082 - SYS___RES_QUERYDOMAIN_A = 0x823 // 2083 - SYS___RES_MKQUERY_A = 0x824 // 2084 - SYS___RES_SEND_A = 0x825 // 2085 - SYS___DN_EXPAND_A = 0x826 // 2086 - SYS___DN_SKIPNAME_A = 0x827 // 2087 - SYS___DN_COMP_A = 0x828 // 2088 - SYS___DN_FIND_A = 0x829 // 2089 - SYS___NLIST_A = 0x82A // 2090 - SYS_____TCGETCP_A = 0x82B // 2091 - SYS_____TCSETCP_A = 0x82C // 2092 - SYS_____W_PIOCTL_A = 0x82E // 2094 - SYS___INET_ADDR_A = 0x82F // 2095 - SYS___INET_NTOA_A = 0x830 // 2096 - SYS___INET_NETWORK_A = 0x831 // 2097 - SYS___ACCEPT_A = 0x832 // 2098 - SYS___ACCEPT_AND_RECV_A = 0x833 // 2099 - SYS___BIND_A = 0x834 // 2100 - SYS___CONNECT_A = 0x835 // 2101 - SYS___GETPEERNAME_A = 0x836 // 2102 - SYS___GETSOCKNAME_A = 0x837 // 2103 - SYS___RECVFROM_A = 0x838 // 2104 - SYS___SENDTO_A = 0x839 // 2105 - SYS___SENDMSG_A = 0x83A // 2106 - SYS___RECVMSG_A = 0x83B // 2107 - SYS_____LCHATTR_A = 0x83C // 2108 - SYS___CABEND = 0x83D // 2109 - SYS___LE_CIB_GET = 0x83E // 2110 - SYS___SET_LAA_FOR_JIT = 0x83F // 2111 - SYS___LCHATTR = 0x840 // 2112 - SYS___WRITEDOWN = 0x841 // 2113 - SYS_PTHREAD_MUTEX_INIT2 = 0x842 // 2114 - SYS___ACOSHF_B = 0x843 // 2115 - SYS___ACOSHL_B = 0x844 // 2116 - SYS___ASINHF_B = 0x845 // 2117 - SYS___ASINHL_B = 0x846 // 2118 - SYS___ATANHF_B = 0x847 // 2119 - SYS___ATANHL_B = 0x848 // 2120 - SYS___CBRTF_B = 0x849 // 2121 - SYS___CBRTL_B = 0x84A // 2122 - SYS___COPYSIGNF_B = 0x84B // 2123 - SYS___COPYSIGNL_B = 0x84C // 2124 - SYS___COTANF_B = 0x84D // 2125 - SYS___COTAN_B = 0x84E // 2126 - SYS___COTANL_B = 0x84F // 2127 - SYS___EXP2F_B = 0x850 // 2128 - SYS___EXP2L_B = 0x851 // 2129 - SYS___EXPM1F_B = 0x852 // 2130 - SYS___EXPM1L_B = 0x853 // 2131 - SYS___FDIMF_B = 0x854 // 2132 - SYS___FDIM_B = 0x855 // 2133 - SYS___FDIML_B = 0x856 // 2134 - SYS___HYPOTF_B = 0x857 // 2135 - SYS___HYPOTL_B = 0x858 // 2136 - SYS___LOG1PF_B = 0x859 // 2137 - SYS___LOG1PL_B = 0x85A // 2138 - SYS___LOG2F_B = 0x85B // 2139 - SYS___LOG2_B = 0x85C // 2140 - SYS___LOG2L_B = 0x85D // 2141 - SYS___REMAINDERF_B = 0x85E // 2142 - SYS___REMAINDERL_B = 0x85F // 2143 - SYS___REMQUOF_B = 0x860 // 2144 - SYS___REMQUO_B = 0x861 // 2145 - SYS___REMQUOL_B = 0x862 // 2146 - SYS___TGAMMAF_B = 0x863 // 2147 - SYS___TGAMMA_B = 0x864 // 2148 - SYS___TGAMMAL_B = 0x865 // 2149 - SYS___TRUNCF_B = 0x866 // 2150 - SYS___TRUNC_B = 0x867 // 2151 - SYS___TRUNCL_B = 0x868 // 2152 - SYS___LGAMMAF_B = 0x869 // 2153 - SYS___LROUNDF_B = 0x86A // 2154 - SYS___LROUND_B = 0x86B // 2155 - SYS___ERFF_B = 0x86C // 2156 - SYS___ERFCF_B = 0x86D // 2157 - SYS_ACOSHF = 0x86E // 2158 - SYS_ACOSHL = 0x86F // 2159 - SYS_ASINHF = 0x870 // 2160 - SYS_ASINHL = 0x871 // 2161 - SYS_ATANHF = 0x872 // 2162 - SYS_ATANHL = 0x873 // 2163 - SYS_CBRTF = 0x874 // 2164 - SYS_CBRTL = 0x875 // 2165 - SYS_COPYSIGNF = 0x876 // 2166 - SYS_CPYSIGNF = 0x876 // 2166 - SYS_COPYSIGNL = 0x877 // 2167 - SYS_CPYSIGNL = 0x877 // 2167 - SYS_COTANF = 0x878 // 2168 - SYS___COTANF = 0x878 // 2168 - SYS_COTAN = 0x879 // 2169 - SYS___COTAN = 0x879 // 2169 - SYS_COTANL = 0x87A // 2170 - SYS___COTANL = 0x87A // 2170 - SYS_EXP2F = 0x87B // 2171 - SYS_EXP2L = 0x87C // 2172 - SYS_EXPM1F = 0x87D // 2173 - SYS_EXPM1L = 0x87E // 2174 - SYS_FDIMF = 0x87F // 2175 - SYS_FDIM = 0x881 // 2177 - SYS_FDIML = 0x882 // 2178 - SYS_HYPOTF = 0x883 // 2179 - SYS_HYPOTL = 0x884 // 2180 - SYS_LOG1PF = 0x885 // 2181 - SYS_LOG1PL = 0x886 // 2182 - SYS_LOG2F = 0x887 // 2183 - SYS_LOG2 = 0x888 // 2184 - SYS_LOG2L = 0x889 // 2185 - SYS_REMAINDERF = 0x88A // 2186 - SYS_REMAINDF = 0x88A // 2186 - SYS_REMAINDERL = 0x88B // 2187 - SYS_REMAINDL = 0x88B // 2187 - SYS_REMQUOF = 0x88C // 2188 - SYS_REMQUO = 0x88D // 2189 - SYS_REMQUOL = 0x88E // 2190 - SYS_TGAMMAF = 0x88F // 2191 - SYS_TGAMMA = 0x890 // 2192 - SYS_TGAMMAL = 0x891 // 2193 - SYS_TRUNCF = 0x892 // 2194 - SYS_TRUNC = 0x893 // 2195 - SYS_TRUNCL = 0x894 // 2196 - SYS_LGAMMAF = 0x895 // 2197 - SYS_LGAMMAL = 0x896 // 2198 - SYS_LROUNDF = 0x897 // 2199 - SYS_LROUND = 0x898 // 2200 - SYS_ERFF = 0x899 // 2201 - SYS_ERFL = 0x89A // 2202 - SYS_ERFCF = 0x89B // 2203 - SYS_ERFCL = 0x89C // 2204 - SYS___EXP2_B = 0x89D // 2205 - SYS_EXP2 = 0x89E // 2206 - SYS___FAR_JUMP = 0x89F // 2207 - SYS___TCGETATTR_A = 0x8A1 // 2209 - SYS___TCSETATTR_A = 0x8A2 // 2210 - SYS___SUPERKILL = 0x8A4 // 2212 - SYS___LE_CONDITION_TOKEN_BUILD = 0x8A5 // 2213 - SYS___LE_MSG_ADD_INSERT = 0x8A6 // 2214 - SYS___LE_MSG_GET = 0x8A7 // 2215 - SYS___LE_MSG_GET_AND_WRITE = 0x8A8 // 2216 - SYS___LE_MSG_WRITE = 0x8A9 // 2217 - SYS___ITOA = 0x8AA // 2218 - SYS___UTOA = 0x8AB // 2219 - SYS___LTOA = 0x8AC // 2220 - SYS___ULTOA = 0x8AD // 2221 - SYS___LLTOA = 0x8AE // 2222 - SYS___ULLTOA = 0x8AF // 2223 - SYS___ITOA_A = 0x8B0 // 2224 - SYS___UTOA_A = 0x8B1 // 2225 - SYS___LTOA_A = 0x8B2 // 2226 - SYS___ULTOA_A = 0x8B3 // 2227 - SYS___LLTOA_A = 0x8B4 // 2228 - SYS___ULLTOA_A = 0x8B5 // 2229 - SYS_____GETENV_A = 0x8C3 // 2243 - SYS___REXEC_A = 0x8C4 // 2244 - SYS___REXEC_AF_A = 0x8C5 // 2245 - SYS___GETUTXENT_A = 0x8C6 // 2246 - SYS___GETUTXID_A = 0x8C7 // 2247 - SYS___GETUTXLINE_A = 0x8C8 // 2248 - SYS___PUTUTXLINE_A = 0x8C9 // 2249 - SYS_____UTMPXNAME_A = 0x8CA // 2250 - SYS___PUTC_UNLOCKED_A = 0x8CB // 2251 - SYS___PUTCHAR_UNLOCKED_A = 0x8CC // 2252 - SYS___SNPRINTF_A = 0x8CD // 2253 - SYS___VSNPRINTF_A = 0x8CE // 2254 - SYS___DLOPEN_A = 0x8D0 // 2256 - SYS___DLSYM_A = 0x8D1 // 2257 - SYS___DLERROR_A = 0x8D2 // 2258 - SYS_FLOCKFILE = 0x8D3 // 2259 - SYS_FTRYLOCKFILE = 0x8D4 // 2260 - SYS_FUNLOCKFILE = 0x8D5 // 2261 - SYS_GETC_UNLOCKED = 0x8D6 // 2262 - SYS_GETCHAR_UNLOCKED = 0x8D7 // 2263 - SYS_PUTC_UNLOCKED = 0x8D8 // 2264 - SYS_PUTCHAR_UNLOCKED = 0x8D9 // 2265 - SYS_SNPRINTF = 0x8DA // 2266 - SYS_VSNPRINTF = 0x8DB // 2267 - SYS_DLOPEN = 0x8DD // 2269 - SYS_DLSYM = 0x8DE // 2270 - SYS_DLCLOSE = 0x8DF // 2271 - SYS_DLERROR = 0x8E0 // 2272 - SYS___SET_EXCEPTION_HANDLER = 0x8E2 // 2274 - SYS___RESET_EXCEPTION_HANDLER = 0x8E3 // 2275 - SYS___VHM_EVENT = 0x8E4 // 2276 - SYS___ABS_H = 0x8E6 // 2278 - SYS___ABSF_H = 0x8E7 // 2279 - SYS___ABSL_H = 0x8E8 // 2280 - SYS___ACOS_H = 0x8E9 // 2281 - SYS___ACOSF_H = 0x8EA // 2282 - SYS___ACOSL_H = 0x8EB // 2283 - SYS___ACOSH_H = 0x8EC // 2284 - SYS___ASIN_H = 0x8ED // 2285 - SYS___ASINF_H = 0x8EE // 2286 - SYS___ASINL_H = 0x8EF // 2287 - SYS___ASINH_H = 0x8F0 // 2288 - SYS___ATAN_H = 0x8F1 // 2289 - SYS___ATANF_H = 0x8F2 // 2290 - SYS___ATANL_H = 0x8F3 // 2291 - SYS___ATANH_H = 0x8F4 // 2292 - SYS___ATANHF_H = 0x8F5 // 2293 - SYS___ATANHL_H = 0x8F6 // 2294 - SYS___ATAN2_H = 0x8F7 // 2295 - SYS___ATAN2F_H = 0x8F8 // 2296 - SYS___ATAN2L_H = 0x8F9 // 2297 - SYS___CBRT_H = 0x8FA // 2298 - SYS___COPYSIGNF_H = 0x8FB // 2299 - SYS___COPYSIGNL_H = 0x8FC // 2300 - SYS___COS_H = 0x8FD // 2301 - SYS___COSF_H = 0x8FE // 2302 - SYS___COSL_H = 0x8FF // 2303 - SYS___COSHF_H = 0x900 // 2304 - SYS___COSHL_H = 0x901 // 2305 - SYS___COTAN_H = 0x902 // 2306 - SYS___COTANF_H = 0x903 // 2307 - SYS___COTANL_H = 0x904 // 2308 - SYS___ERF_H = 0x905 // 2309 - SYS___ERFF_H = 0x906 // 2310 - SYS___ERFL_H = 0x907 // 2311 - SYS___ERFC_H = 0x908 // 2312 - SYS___ERFCF_H = 0x909 // 2313 - SYS___ERFCL_H = 0x90A // 2314 - SYS___EXP_H = 0x90B // 2315 - SYS___EXPF_H = 0x90C // 2316 - SYS___EXPL_H = 0x90D // 2317 - SYS___EXPM1_H = 0x90E // 2318 - SYS___FDIM_H = 0x90F // 2319 - SYS___FDIMF_H = 0x910 // 2320 - SYS___FDIML_H = 0x911 // 2321 - SYS___FMOD_H = 0x912 // 2322 - SYS___FMODF_H = 0x913 // 2323 - SYS___FMODL_H = 0x914 // 2324 - SYS___GAMMA_H = 0x915 // 2325 - SYS___HYPOT_H = 0x916 // 2326 - SYS___ILOGB_H = 0x917 // 2327 - SYS___LGAMMA_H = 0x918 // 2328 - SYS___LGAMMAF_H = 0x919 // 2329 - SYS___LOG_H = 0x91A // 2330 - SYS___LOGF_H = 0x91B // 2331 - SYS___LOGL_H = 0x91C // 2332 - SYS___LOGB_H = 0x91D // 2333 - SYS___LOG2_H = 0x91E // 2334 - SYS___LOG2F_H = 0x91F // 2335 - SYS___LOG2L_H = 0x920 // 2336 - SYS___LOG1P_H = 0x921 // 2337 - SYS___LOG10_H = 0x922 // 2338 - SYS___LOG10F_H = 0x923 // 2339 - SYS___LOG10L_H = 0x924 // 2340 - SYS___LROUND_H = 0x925 // 2341 - SYS___LROUNDF_H = 0x926 // 2342 - SYS___NEXTAFTER_H = 0x927 // 2343 - SYS___POW_H = 0x928 // 2344 - SYS___POWF_H = 0x929 // 2345 - SYS___POWL_H = 0x92A // 2346 - SYS___REMAINDER_H = 0x92B // 2347 - SYS___RINT_H = 0x92C // 2348 - SYS___SCALB_H = 0x92D // 2349 - SYS___SIN_H = 0x92E // 2350 - SYS___SINF_H = 0x92F // 2351 - SYS___SINL_H = 0x930 // 2352 - SYS___SINH_H = 0x931 // 2353 - SYS___SINHF_H = 0x932 // 2354 - SYS___SINHL_H = 0x933 // 2355 - SYS___SQRT_H = 0x934 // 2356 - SYS___SQRTF_H = 0x935 // 2357 - SYS___SQRTL_H = 0x936 // 2358 - SYS___TAN_H = 0x937 // 2359 - SYS___TANF_H = 0x938 // 2360 - SYS___TANL_H = 0x939 // 2361 - SYS___TANH_H = 0x93A // 2362 - SYS___TANHF_H = 0x93B // 2363 - SYS___TANHL_H = 0x93C // 2364 - SYS___TGAMMA_H = 0x93D // 2365 - SYS___TGAMMAF_H = 0x93E // 2366 - SYS___TRUNC_H = 0x93F // 2367 - SYS___TRUNCF_H = 0x940 // 2368 - SYS___TRUNCL_H = 0x941 // 2369 - SYS___COSH_H = 0x942 // 2370 - SYS___LE_DEBUG_SET_RESUME_MCH = 0x943 // 2371 - SYS_VFSCANF = 0x944 // 2372 - SYS_VSCANF = 0x946 // 2374 - SYS_VSSCANF = 0x948 // 2376 - SYS_VFWSCANF = 0x94A // 2378 - SYS_VWSCANF = 0x94C // 2380 - SYS_VSWSCANF = 0x94E // 2382 - SYS_IMAXABS = 0x950 // 2384 - SYS_IMAXDIV = 0x951 // 2385 - SYS_STRTOIMAX = 0x952 // 2386 - SYS_STRTOUMAX = 0x953 // 2387 - SYS_WCSTOIMAX = 0x954 // 2388 - SYS_WCSTOUMAX = 0x955 // 2389 - SYS_ATOLL = 0x956 // 2390 - SYS_STRTOF = 0x957 // 2391 - SYS_STRTOLD = 0x958 // 2392 - SYS_WCSTOF = 0x959 // 2393 - SYS_WCSTOLD = 0x95A // 2394 - SYS_INET6_RTH_SPACE = 0x95B // 2395 - SYS_INET6_RTH_INIT = 0x95C // 2396 - SYS_INET6_RTH_ADD = 0x95D // 2397 - SYS_INET6_RTH_REVERSE = 0x95E // 2398 - SYS_INET6_RTH_SEGMENTS = 0x95F // 2399 - SYS_INET6_RTH_GETADDR = 0x960 // 2400 - SYS_INET6_OPT_INIT = 0x961 // 2401 - SYS_INET6_OPT_APPEND = 0x962 // 2402 - SYS_INET6_OPT_FINISH = 0x963 // 2403 - SYS_INET6_OPT_SET_VAL = 0x964 // 2404 - SYS_INET6_OPT_NEXT = 0x965 // 2405 - SYS_INET6_OPT_FIND = 0x966 // 2406 - SYS_INET6_OPT_GET_VAL = 0x967 // 2407 - SYS___POW_I = 0x987 // 2439 - SYS___POW_I_B = 0x988 // 2440 - SYS___POW_I_H = 0x989 // 2441 - SYS___POW_II = 0x98A // 2442 - SYS___POW_II_B = 0x98B // 2443 - SYS___POW_II_H = 0x98C // 2444 - SYS_CABS = 0x98E // 2446 - SYS___CABS_B = 0x98F // 2447 - SYS___CABS_H = 0x990 // 2448 - SYS_CABSF = 0x991 // 2449 - SYS___CABSF_B = 0x992 // 2450 - SYS___CABSF_H = 0x993 // 2451 - SYS_CABSL = 0x994 // 2452 - SYS___CABSL_B = 0x995 // 2453 - SYS___CABSL_H = 0x996 // 2454 - SYS_CACOS = 0x997 // 2455 - SYS___CACOS_B = 0x998 // 2456 - SYS___CACOS_H = 0x999 // 2457 - SYS_CACOSF = 0x99A // 2458 - SYS___CACOSF_B = 0x99B // 2459 - SYS___CACOSF_H = 0x99C // 2460 - SYS_CACOSL = 0x99D // 2461 - SYS___CACOSL_B = 0x99E // 2462 - SYS___CACOSL_H = 0x99F // 2463 - SYS_CACOSH = 0x9A0 // 2464 - SYS___CACOSH_B = 0x9A1 // 2465 - SYS___CACOSH_H = 0x9A2 // 2466 - SYS_CACOSHF = 0x9A3 // 2467 - SYS___CACOSHF_B = 0x9A4 // 2468 - SYS___CACOSHF_H = 0x9A5 // 2469 - SYS_CACOSHL = 0x9A6 // 2470 - SYS___CACOSHL_B = 0x9A7 // 2471 - SYS___CACOSHL_H = 0x9A8 // 2472 - SYS_CARG = 0x9A9 // 2473 - SYS___CARG_B = 0x9AA // 2474 - SYS___CARG_H = 0x9AB // 2475 - SYS_CARGF = 0x9AC // 2476 - SYS___CARGF_B = 0x9AD // 2477 - SYS___CARGF_H = 0x9AE // 2478 - SYS_CARGL = 0x9AF // 2479 - SYS___CARGL_B = 0x9B0 // 2480 - SYS___CARGL_H = 0x9B1 // 2481 - SYS_CASIN = 0x9B2 // 2482 - SYS___CASIN_B = 0x9B3 // 2483 - SYS___CASIN_H = 0x9B4 // 2484 - SYS_CASINF = 0x9B5 // 2485 - SYS___CASINF_B = 0x9B6 // 2486 - SYS___CASINF_H = 0x9B7 // 2487 - SYS_CASINL = 0x9B8 // 2488 - SYS___CASINL_B = 0x9B9 // 2489 - SYS___CASINL_H = 0x9BA // 2490 - SYS_CASINH = 0x9BB // 2491 - SYS___CASINH_B = 0x9BC // 2492 - SYS___CASINH_H = 0x9BD // 2493 - SYS_CASINHF = 0x9BE // 2494 - SYS___CASINHF_B = 0x9BF // 2495 - SYS___CASINHF_H = 0x9C0 // 2496 - SYS_CASINHL = 0x9C1 // 2497 - SYS___CASINHL_B = 0x9C2 // 2498 - SYS___CASINHL_H = 0x9C3 // 2499 - SYS_CATAN = 0x9C4 // 2500 - SYS___CATAN_B = 0x9C5 // 2501 - SYS___CATAN_H = 0x9C6 // 2502 - SYS_CATANF = 0x9C7 // 2503 - SYS___CATANF_B = 0x9C8 // 2504 - SYS___CATANF_H = 0x9C9 // 2505 - SYS_CATANL = 0x9CA // 2506 - SYS___CATANL_B = 0x9CB // 2507 - SYS___CATANL_H = 0x9CC // 2508 - SYS_CATANH = 0x9CD // 2509 - SYS___CATANH_B = 0x9CE // 2510 - SYS___CATANH_H = 0x9CF // 2511 - SYS_CATANHF = 0x9D0 // 2512 - SYS___CATANHF_B = 0x9D1 // 2513 - SYS___CATANHF_H = 0x9D2 // 2514 - SYS_CATANHL = 0x9D3 // 2515 - SYS___CATANHL_B = 0x9D4 // 2516 - SYS___CATANHL_H = 0x9D5 // 2517 - SYS_CCOS = 0x9D6 // 2518 - SYS___CCOS_B = 0x9D7 // 2519 - SYS___CCOS_H = 0x9D8 // 2520 - SYS_CCOSF = 0x9D9 // 2521 - SYS___CCOSF_B = 0x9DA // 2522 - SYS___CCOSF_H = 0x9DB // 2523 - SYS_CCOSL = 0x9DC // 2524 - SYS___CCOSL_B = 0x9DD // 2525 - SYS___CCOSL_H = 0x9DE // 2526 - SYS_CCOSH = 0x9DF // 2527 - SYS___CCOSH_B = 0x9E0 // 2528 - SYS___CCOSH_H = 0x9E1 // 2529 - SYS_CCOSHF = 0x9E2 // 2530 - SYS___CCOSHF_B = 0x9E3 // 2531 - SYS___CCOSHF_H = 0x9E4 // 2532 - SYS_CCOSHL = 0x9E5 // 2533 - SYS___CCOSHL_B = 0x9E6 // 2534 - SYS___CCOSHL_H = 0x9E7 // 2535 - SYS_CEXP = 0x9E8 // 2536 - SYS___CEXP_B = 0x9E9 // 2537 - SYS___CEXP_H = 0x9EA // 2538 - SYS_CEXPF = 0x9EB // 2539 - SYS___CEXPF_B = 0x9EC // 2540 - SYS___CEXPF_H = 0x9ED // 2541 - SYS_CEXPL = 0x9EE // 2542 - SYS___CEXPL_B = 0x9EF // 2543 - SYS___CEXPL_H = 0x9F0 // 2544 - SYS_CIMAG = 0x9F1 // 2545 - SYS___CIMAG_B = 0x9F2 // 2546 - SYS___CIMAG_H = 0x9F3 // 2547 - SYS_CIMAGF = 0x9F4 // 2548 - SYS___CIMAGF_B = 0x9F5 // 2549 - SYS___CIMAGF_H = 0x9F6 // 2550 - SYS_CIMAGL = 0x9F7 // 2551 - SYS___CIMAGL_B = 0x9F8 // 2552 - SYS___CIMAGL_H = 0x9F9 // 2553 - SYS___CLOG = 0x9FA // 2554 - SYS___CLOG_B = 0x9FB // 2555 - SYS___CLOG_H = 0x9FC // 2556 - SYS_CLOGF = 0x9FD // 2557 - SYS___CLOGF_B = 0x9FE // 2558 - SYS___CLOGF_H = 0x9FF // 2559 - SYS_CLOGL = 0xA00 // 2560 - SYS___CLOGL_B = 0xA01 // 2561 - SYS___CLOGL_H = 0xA02 // 2562 - SYS_CONJ = 0xA03 // 2563 - SYS___CONJ_B = 0xA04 // 2564 - SYS___CONJ_H = 0xA05 // 2565 - SYS_CONJF = 0xA06 // 2566 - SYS___CONJF_B = 0xA07 // 2567 - SYS___CONJF_H = 0xA08 // 2568 - SYS_CONJL = 0xA09 // 2569 - SYS___CONJL_B = 0xA0A // 2570 - SYS___CONJL_H = 0xA0B // 2571 - SYS_CPOW = 0xA0C // 2572 - SYS___CPOW_B = 0xA0D // 2573 - SYS___CPOW_H = 0xA0E // 2574 - SYS_CPOWF = 0xA0F // 2575 - SYS___CPOWF_B = 0xA10 // 2576 - SYS___CPOWF_H = 0xA11 // 2577 - SYS_CPOWL = 0xA12 // 2578 - SYS___CPOWL_B = 0xA13 // 2579 - SYS___CPOWL_H = 0xA14 // 2580 - SYS_CPROJ = 0xA15 // 2581 - SYS___CPROJ_B = 0xA16 // 2582 - SYS___CPROJ_H = 0xA17 // 2583 - SYS_CPROJF = 0xA18 // 2584 - SYS___CPROJF_B = 0xA19 // 2585 - SYS___CPROJF_H = 0xA1A // 2586 - SYS_CPROJL = 0xA1B // 2587 - SYS___CPROJL_B = 0xA1C // 2588 - SYS___CPROJL_H = 0xA1D // 2589 - SYS_CREAL = 0xA1E // 2590 - SYS___CREAL_B = 0xA1F // 2591 - SYS___CREAL_H = 0xA20 // 2592 - SYS_CREALF = 0xA21 // 2593 - SYS___CREALF_B = 0xA22 // 2594 - SYS___CREALF_H = 0xA23 // 2595 - SYS_CREALL = 0xA24 // 2596 - SYS___CREALL_B = 0xA25 // 2597 - SYS___CREALL_H = 0xA26 // 2598 - SYS_CSIN = 0xA27 // 2599 - SYS___CSIN_B = 0xA28 // 2600 - SYS___CSIN_H = 0xA29 // 2601 - SYS_CSINF = 0xA2A // 2602 - SYS___CSINF_B = 0xA2B // 2603 - SYS___CSINF_H = 0xA2C // 2604 - SYS_CSINL = 0xA2D // 2605 - SYS___CSINL_B = 0xA2E // 2606 - SYS___CSINL_H = 0xA2F // 2607 - SYS_CSINH = 0xA30 // 2608 - SYS___CSINH_B = 0xA31 // 2609 - SYS___CSINH_H = 0xA32 // 2610 - SYS_CSINHF = 0xA33 // 2611 - SYS___CSINHF_B = 0xA34 // 2612 - SYS___CSINHF_H = 0xA35 // 2613 - SYS_CSINHL = 0xA36 // 2614 - SYS___CSINHL_B = 0xA37 // 2615 - SYS___CSINHL_H = 0xA38 // 2616 - SYS_CSQRT = 0xA39 // 2617 - SYS___CSQRT_B = 0xA3A // 2618 - SYS___CSQRT_H = 0xA3B // 2619 - SYS_CSQRTF = 0xA3C // 2620 - SYS___CSQRTF_B = 0xA3D // 2621 - SYS___CSQRTF_H = 0xA3E // 2622 - SYS_CSQRTL = 0xA3F // 2623 - SYS___CSQRTL_B = 0xA40 // 2624 - SYS___CSQRTL_H = 0xA41 // 2625 - SYS_CTAN = 0xA42 // 2626 - SYS___CTAN_B = 0xA43 // 2627 - SYS___CTAN_H = 0xA44 // 2628 - SYS_CTANF = 0xA45 // 2629 - SYS___CTANF_B = 0xA46 // 2630 - SYS___CTANF_H = 0xA47 // 2631 - SYS_CTANL = 0xA48 // 2632 - SYS___CTANL_B = 0xA49 // 2633 - SYS___CTANL_H = 0xA4A // 2634 - SYS_CTANH = 0xA4B // 2635 - SYS___CTANH_B = 0xA4C // 2636 - SYS___CTANH_H = 0xA4D // 2637 - SYS_CTANHF = 0xA4E // 2638 - SYS___CTANHF_B = 0xA4F // 2639 - SYS___CTANHF_H = 0xA50 // 2640 - SYS_CTANHL = 0xA51 // 2641 - SYS___CTANHL_B = 0xA52 // 2642 - SYS___CTANHL_H = 0xA53 // 2643 - SYS___ACOSHF_H = 0xA54 // 2644 - SYS___ACOSHL_H = 0xA55 // 2645 - SYS___ASINHF_H = 0xA56 // 2646 - SYS___ASINHL_H = 0xA57 // 2647 - SYS___CBRTF_H = 0xA58 // 2648 - SYS___CBRTL_H = 0xA59 // 2649 - SYS___COPYSIGN_B = 0xA5A // 2650 - SYS___EXPM1F_H = 0xA5B // 2651 - SYS___EXPM1L_H = 0xA5C // 2652 - SYS___EXP2_H = 0xA5D // 2653 - SYS___EXP2F_H = 0xA5E // 2654 - SYS___EXP2L_H = 0xA5F // 2655 - SYS___LOG1PF_H = 0xA60 // 2656 - SYS___LOG1PL_H = 0xA61 // 2657 - SYS___LGAMMAL_H = 0xA62 // 2658 - SYS_FMA = 0xA63 // 2659 - SYS___FMA_B = 0xA64 // 2660 - SYS___FMA_H = 0xA65 // 2661 - SYS_FMAF = 0xA66 // 2662 - SYS___FMAF_B = 0xA67 // 2663 - SYS___FMAF_H = 0xA68 // 2664 - SYS_FMAL = 0xA69 // 2665 - SYS___FMAL_B = 0xA6A // 2666 - SYS___FMAL_H = 0xA6B // 2667 - SYS_FMAX = 0xA6C // 2668 - SYS___FMAX_B = 0xA6D // 2669 - SYS___FMAX_H = 0xA6E // 2670 - SYS_FMAXF = 0xA6F // 2671 - SYS___FMAXF_B = 0xA70 // 2672 - SYS___FMAXF_H = 0xA71 // 2673 - SYS_FMAXL = 0xA72 // 2674 - SYS___FMAXL_B = 0xA73 // 2675 - SYS___FMAXL_H = 0xA74 // 2676 - SYS_FMIN = 0xA75 // 2677 - SYS___FMIN_B = 0xA76 // 2678 - SYS___FMIN_H = 0xA77 // 2679 - SYS_FMINF = 0xA78 // 2680 - SYS___FMINF_B = 0xA79 // 2681 - SYS___FMINF_H = 0xA7A // 2682 - SYS_FMINL = 0xA7B // 2683 - SYS___FMINL_B = 0xA7C // 2684 - SYS___FMINL_H = 0xA7D // 2685 - SYS_ILOGBF = 0xA7E // 2686 - SYS___ILOGBF_B = 0xA7F // 2687 - SYS___ILOGBF_H = 0xA80 // 2688 - SYS_ILOGBL = 0xA81 // 2689 - SYS___ILOGBL_B = 0xA82 // 2690 - SYS___ILOGBL_H = 0xA83 // 2691 - SYS_LLRINT = 0xA84 // 2692 - SYS___LLRINT_B = 0xA85 // 2693 - SYS___LLRINT_H = 0xA86 // 2694 - SYS_LLRINTF = 0xA87 // 2695 - SYS___LLRINTF_B = 0xA88 // 2696 - SYS___LLRINTF_H = 0xA89 // 2697 - SYS_LLRINTL = 0xA8A // 2698 - SYS___LLRINTL_B = 0xA8B // 2699 - SYS___LLRINTL_H = 0xA8C // 2700 - SYS_LLROUND = 0xA8D // 2701 - SYS___LLROUND_B = 0xA8E // 2702 - SYS___LLROUND_H = 0xA8F // 2703 - SYS_LLROUNDF = 0xA90 // 2704 - SYS___LLROUNDF_B = 0xA91 // 2705 - SYS___LLROUNDF_H = 0xA92 // 2706 - SYS_LLROUNDL = 0xA93 // 2707 - SYS___LLROUNDL_B = 0xA94 // 2708 - SYS___LLROUNDL_H = 0xA95 // 2709 - SYS_LOGBF = 0xA96 // 2710 - SYS___LOGBF_B = 0xA97 // 2711 - SYS___LOGBF_H = 0xA98 // 2712 - SYS_LOGBL = 0xA99 // 2713 - SYS___LOGBL_B = 0xA9A // 2714 - SYS___LOGBL_H = 0xA9B // 2715 - SYS_LRINT = 0xA9C // 2716 - SYS___LRINT_B = 0xA9D // 2717 - SYS___LRINT_H = 0xA9E // 2718 - SYS_LRINTF = 0xA9F // 2719 - SYS___LRINTF_B = 0xAA0 // 2720 - SYS___LRINTF_H = 0xAA1 // 2721 - SYS_LRINTL = 0xAA2 // 2722 - SYS___LRINTL_B = 0xAA3 // 2723 - SYS___LRINTL_H = 0xAA4 // 2724 - SYS_LROUNDL = 0xAA5 // 2725 - SYS___LROUNDL_B = 0xAA6 // 2726 - SYS___LROUNDL_H = 0xAA7 // 2727 - SYS_NAN = 0xAA8 // 2728 - SYS___NAN_B = 0xAA9 // 2729 - SYS_NANF = 0xAAA // 2730 - SYS___NANF_B = 0xAAB // 2731 - SYS_NANL = 0xAAC // 2732 - SYS___NANL_B = 0xAAD // 2733 - SYS_NEARBYINT = 0xAAE // 2734 - SYS___NEARBYINT_B = 0xAAF // 2735 - SYS___NEARBYINT_H = 0xAB0 // 2736 - SYS_NEARBYINTF = 0xAB1 // 2737 - SYS___NEARBYINTF_B = 0xAB2 // 2738 - SYS___NEARBYINTF_H = 0xAB3 // 2739 - SYS_NEARBYINTL = 0xAB4 // 2740 - SYS___NEARBYINTL_B = 0xAB5 // 2741 - SYS___NEARBYINTL_H = 0xAB6 // 2742 - SYS_NEXTAFTERF = 0xAB7 // 2743 - SYS___NEXTAFTERF_B = 0xAB8 // 2744 - SYS___NEXTAFTERF_H = 0xAB9 // 2745 - SYS_NEXTAFTERL = 0xABA // 2746 - SYS___NEXTAFTERL_B = 0xABB // 2747 - SYS___NEXTAFTERL_H = 0xABC // 2748 - SYS_NEXTTOWARD = 0xABD // 2749 - SYS___NEXTTOWARD_B = 0xABE // 2750 - SYS___NEXTTOWARD_H = 0xABF // 2751 - SYS_NEXTTOWARDF = 0xAC0 // 2752 - SYS___NEXTTOWARDF_B = 0xAC1 // 2753 - SYS___NEXTTOWARDF_H = 0xAC2 // 2754 - SYS_NEXTTOWARDL = 0xAC3 // 2755 - SYS___NEXTTOWARDL_B = 0xAC4 // 2756 - SYS___NEXTTOWARDL_H = 0xAC5 // 2757 - SYS___REMAINDERF_H = 0xAC6 // 2758 - SYS___REMAINDERL_H = 0xAC7 // 2759 - SYS___REMQUO_H = 0xAC8 // 2760 - SYS___REMQUOF_H = 0xAC9 // 2761 - SYS___REMQUOL_H = 0xACA // 2762 - SYS_RINTF = 0xACB // 2763 - SYS___RINTF_B = 0xACC // 2764 - SYS_RINTL = 0xACD // 2765 - SYS___RINTL_B = 0xACE // 2766 - SYS_ROUND = 0xACF // 2767 - SYS___ROUND_B = 0xAD0 // 2768 - SYS___ROUND_H = 0xAD1 // 2769 - SYS_ROUNDF = 0xAD2 // 2770 - SYS___ROUNDF_B = 0xAD3 // 2771 - SYS___ROUNDF_H = 0xAD4 // 2772 - SYS_ROUNDL = 0xAD5 // 2773 - SYS___ROUNDL_B = 0xAD6 // 2774 - SYS___ROUNDL_H = 0xAD7 // 2775 - SYS_SCALBLN = 0xAD8 // 2776 - SYS___SCALBLN_B = 0xAD9 // 2777 - SYS___SCALBLN_H = 0xADA // 2778 - SYS_SCALBLNF = 0xADB // 2779 - SYS___SCALBLNF_B = 0xADC // 2780 - SYS___SCALBLNF_H = 0xADD // 2781 - SYS_SCALBLNL = 0xADE // 2782 - SYS___SCALBLNL_B = 0xADF // 2783 - SYS___SCALBLNL_H = 0xAE0 // 2784 - SYS___SCALBN_B = 0xAE1 // 2785 - SYS___SCALBN_H = 0xAE2 // 2786 - SYS_SCALBNF = 0xAE3 // 2787 - SYS___SCALBNF_B = 0xAE4 // 2788 - SYS___SCALBNF_H = 0xAE5 // 2789 - SYS_SCALBNL = 0xAE6 // 2790 - SYS___SCALBNL_B = 0xAE7 // 2791 - SYS___SCALBNL_H = 0xAE8 // 2792 - SYS___TGAMMAL_H = 0xAE9 // 2793 - SYS_FECLEAREXCEPT = 0xAEA // 2794 - SYS_FEGETENV = 0xAEB // 2795 - SYS_FEGETEXCEPTFLAG = 0xAEC // 2796 - SYS_FEGETROUND = 0xAED // 2797 - SYS_FEHOLDEXCEPT = 0xAEE // 2798 - SYS_FERAISEEXCEPT = 0xAEF // 2799 - SYS_FESETENV = 0xAF0 // 2800 - SYS_FESETEXCEPTFLAG = 0xAF1 // 2801 - SYS_FESETROUND = 0xAF2 // 2802 - SYS_FETESTEXCEPT = 0xAF3 // 2803 - SYS_FEUPDATEENV = 0xAF4 // 2804 - SYS___COPYSIGN_H = 0xAF5 // 2805 - SYS___HYPOTF_H = 0xAF6 // 2806 - SYS___HYPOTL_H = 0xAF7 // 2807 - SYS___CLASS = 0xAFA // 2810 - SYS___CLASS_B = 0xAFB // 2811 - SYS___CLASS_H = 0xAFC // 2812 - SYS___ISBLANK_A = 0xB2E // 2862 - SYS___ISWBLANK_A = 0xB2F // 2863 - SYS___LROUND_FIXUP = 0xB30 // 2864 - SYS___LROUNDF_FIXUP = 0xB31 // 2865 - SYS_SCHED_YIELD = 0xB32 // 2866 - SYS_STRERROR_R = 0xB33 // 2867 - SYS_UNSETENV = 0xB34 // 2868 - SYS___LGAMMA_H_C99 = 0xB38 // 2872 - SYS___LGAMMA_B_C99 = 0xB39 // 2873 - SYS___LGAMMA_R_C99 = 0xB3A // 2874 - SYS___FTELL2 = 0xB3B // 2875 - SYS___FSEEK2 = 0xB3C // 2876 - SYS___STATIC_REINIT = 0xB3D // 2877 - SYS_PTHREAD_ATTR_GETSTACK = 0xB3E // 2878 - SYS_PTHREAD_ATTR_SETSTACK = 0xB3F // 2879 - SYS___TGAMMA_H_C99 = 0xB78 // 2936 - SYS___TGAMMAF_H_C99 = 0xB79 // 2937 - SYS___LE_TRACEBACK = 0xB7A // 2938 - SYS___MUST_STAY_CLEAN = 0xB7C // 2940 - SYS___O_ENV = 0xB7D // 2941 - SYS_ACOSD32 = 0xB7E // 2942 - SYS_ACOSD64 = 0xB7F // 2943 - SYS_ACOSD128 = 0xB80 // 2944 - SYS_ACOSHD32 = 0xB81 // 2945 - SYS_ACOSHD64 = 0xB82 // 2946 - SYS_ACOSHD128 = 0xB83 // 2947 - SYS_ASIND32 = 0xB84 // 2948 - SYS_ASIND64 = 0xB85 // 2949 - SYS_ASIND128 = 0xB86 // 2950 - SYS_ASINHD32 = 0xB87 // 2951 - SYS_ASINHD64 = 0xB88 // 2952 - SYS_ASINHD128 = 0xB89 // 2953 - SYS_ATAND32 = 0xB8A // 2954 - SYS_ATAND64 = 0xB8B // 2955 - SYS_ATAND128 = 0xB8C // 2956 - SYS_ATAN2D32 = 0xB8D // 2957 - SYS_ATAN2D64 = 0xB8E // 2958 - SYS_ATAN2D128 = 0xB8F // 2959 - SYS_ATANHD32 = 0xB90 // 2960 - SYS_ATANHD64 = 0xB91 // 2961 - SYS_ATANHD128 = 0xB92 // 2962 - SYS_CBRTD32 = 0xB93 // 2963 - SYS_CBRTD64 = 0xB94 // 2964 - SYS_CBRTD128 = 0xB95 // 2965 - SYS_CEILD32 = 0xB96 // 2966 - SYS_CEILD64 = 0xB97 // 2967 - SYS_CEILD128 = 0xB98 // 2968 - SYS___CLASS2 = 0xB99 // 2969 - SYS___CLASS2_B = 0xB9A // 2970 - SYS___CLASS2_H = 0xB9B // 2971 - SYS_COPYSIGND32 = 0xB9C // 2972 - SYS_COPYSIGND64 = 0xB9D // 2973 - SYS_COPYSIGND128 = 0xB9E // 2974 - SYS_COSD32 = 0xB9F // 2975 - SYS_COSD64 = 0xBA0 // 2976 - SYS_COSD128 = 0xBA1 // 2977 - SYS_COSHD32 = 0xBA2 // 2978 - SYS_COSHD64 = 0xBA3 // 2979 - SYS_COSHD128 = 0xBA4 // 2980 - SYS_ERFD32 = 0xBA5 // 2981 - SYS_ERFD64 = 0xBA6 // 2982 - SYS_ERFD128 = 0xBA7 // 2983 - SYS_ERFCD32 = 0xBA8 // 2984 - SYS_ERFCD64 = 0xBA9 // 2985 - SYS_ERFCD128 = 0xBAA // 2986 - SYS_EXPD32 = 0xBAB // 2987 - SYS_EXPD64 = 0xBAC // 2988 - SYS_EXPD128 = 0xBAD // 2989 - SYS_EXP2D32 = 0xBAE // 2990 - SYS_EXP2D64 = 0xBAF // 2991 - SYS_EXP2D128 = 0xBB0 // 2992 - SYS_EXPM1D32 = 0xBB1 // 2993 - SYS_EXPM1D64 = 0xBB2 // 2994 - SYS_EXPM1D128 = 0xBB3 // 2995 - SYS_FABSD32 = 0xBB4 // 2996 - SYS_FABSD64 = 0xBB5 // 2997 - SYS_FABSD128 = 0xBB6 // 2998 - SYS_FDIMD32 = 0xBB7 // 2999 - SYS_FDIMD64 = 0xBB8 // 3000 - SYS_FDIMD128 = 0xBB9 // 3001 - SYS_FE_DEC_GETROUND = 0xBBA // 3002 - SYS_FE_DEC_SETROUND = 0xBBB // 3003 - SYS_FLOORD32 = 0xBBC // 3004 - SYS_FLOORD64 = 0xBBD // 3005 - SYS_FLOORD128 = 0xBBE // 3006 - SYS_FMAD32 = 0xBBF // 3007 - SYS_FMAD64 = 0xBC0 // 3008 - SYS_FMAD128 = 0xBC1 // 3009 - SYS_FMAXD32 = 0xBC2 // 3010 - SYS_FMAXD64 = 0xBC3 // 3011 - SYS_FMAXD128 = 0xBC4 // 3012 - SYS_FMIND32 = 0xBC5 // 3013 - SYS_FMIND64 = 0xBC6 // 3014 - SYS_FMIND128 = 0xBC7 // 3015 - SYS_FMODD32 = 0xBC8 // 3016 - SYS_FMODD64 = 0xBC9 // 3017 - SYS_FMODD128 = 0xBCA // 3018 - SYS___FP_CAST_D = 0xBCB // 3019 - SYS_FREXPD32 = 0xBCC // 3020 - SYS_FREXPD64 = 0xBCD // 3021 - SYS_FREXPD128 = 0xBCE // 3022 - SYS_HYPOTD32 = 0xBCF // 3023 - SYS_HYPOTD64 = 0xBD0 // 3024 - SYS_HYPOTD128 = 0xBD1 // 3025 - SYS_ILOGBD32 = 0xBD2 // 3026 - SYS_ILOGBD64 = 0xBD3 // 3027 - SYS_ILOGBD128 = 0xBD4 // 3028 - SYS_LDEXPD32 = 0xBD5 // 3029 - SYS_LDEXPD64 = 0xBD6 // 3030 - SYS_LDEXPD128 = 0xBD7 // 3031 - SYS_LGAMMAD32 = 0xBD8 // 3032 - SYS_LGAMMAD64 = 0xBD9 // 3033 - SYS_LGAMMAD128 = 0xBDA // 3034 - SYS_LLRINTD32 = 0xBDB // 3035 - SYS_LLRINTD64 = 0xBDC // 3036 - SYS_LLRINTD128 = 0xBDD // 3037 - SYS_LLROUNDD32 = 0xBDE // 3038 - SYS_LLROUNDD64 = 0xBDF // 3039 - SYS_LLROUNDD128 = 0xBE0 // 3040 - SYS_LOGD32 = 0xBE1 // 3041 - SYS_LOGD64 = 0xBE2 // 3042 - SYS_LOGD128 = 0xBE3 // 3043 - SYS_LOG10D32 = 0xBE4 // 3044 - SYS_LOG10D64 = 0xBE5 // 3045 - SYS_LOG10D128 = 0xBE6 // 3046 - SYS_LOG1PD32 = 0xBE7 // 3047 - SYS_LOG1PD64 = 0xBE8 // 3048 - SYS_LOG1PD128 = 0xBE9 // 3049 - SYS_LOG2D32 = 0xBEA // 3050 - SYS_LOG2D64 = 0xBEB // 3051 - SYS_LOG2D128 = 0xBEC // 3052 - SYS_LOGBD32 = 0xBED // 3053 - SYS_LOGBD64 = 0xBEE // 3054 - SYS_LOGBD128 = 0xBEF // 3055 - SYS_LRINTD32 = 0xBF0 // 3056 - SYS_LRINTD64 = 0xBF1 // 3057 - SYS_LRINTD128 = 0xBF2 // 3058 - SYS_LROUNDD32 = 0xBF3 // 3059 - SYS_LROUNDD64 = 0xBF4 // 3060 - SYS_LROUNDD128 = 0xBF5 // 3061 - SYS_MODFD32 = 0xBF6 // 3062 - SYS_MODFD64 = 0xBF7 // 3063 - SYS_MODFD128 = 0xBF8 // 3064 - SYS_NAND32 = 0xBF9 // 3065 - SYS_NAND64 = 0xBFA // 3066 - SYS_NAND128 = 0xBFB // 3067 - SYS_NEARBYINTD32 = 0xBFC // 3068 - SYS_NEARBYINTD64 = 0xBFD // 3069 - SYS_NEARBYINTD128 = 0xBFE // 3070 - SYS_NEXTAFTERD32 = 0xBFF // 3071 - SYS_NEXTAFTERD64 = 0xC00 // 3072 - SYS_NEXTAFTERD128 = 0xC01 // 3073 - SYS_NEXTTOWARDD32 = 0xC02 // 3074 - SYS_NEXTTOWARDD64 = 0xC03 // 3075 - SYS_NEXTTOWARDD128 = 0xC04 // 3076 - SYS_POWD32 = 0xC05 // 3077 - SYS_POWD64 = 0xC06 // 3078 - SYS_POWD128 = 0xC07 // 3079 - SYS_QUANTIZED32 = 0xC08 // 3080 - SYS_QUANTIZED64 = 0xC09 // 3081 - SYS_QUANTIZED128 = 0xC0A // 3082 - SYS_REMAINDERD32 = 0xC0B // 3083 - SYS_REMAINDERD64 = 0xC0C // 3084 - SYS_REMAINDERD128 = 0xC0D // 3085 - SYS___REMQUOD32 = 0xC0E // 3086 - SYS___REMQUOD64 = 0xC0F // 3087 - SYS___REMQUOD128 = 0xC10 // 3088 - SYS_RINTD32 = 0xC11 // 3089 - SYS_RINTD64 = 0xC12 // 3090 - SYS_RINTD128 = 0xC13 // 3091 - SYS_ROUNDD32 = 0xC14 // 3092 - SYS_ROUNDD64 = 0xC15 // 3093 - SYS_ROUNDD128 = 0xC16 // 3094 - SYS_SAMEQUANTUMD32 = 0xC17 // 3095 - SYS_SAMEQUANTUMD64 = 0xC18 // 3096 - SYS_SAMEQUANTUMD128 = 0xC19 // 3097 - SYS_SCALBLND32 = 0xC1A // 3098 - SYS_SCALBLND64 = 0xC1B // 3099 - SYS_SCALBLND128 = 0xC1C // 3100 - SYS_SCALBND32 = 0xC1D // 3101 - SYS_SCALBND64 = 0xC1E // 3102 - SYS_SCALBND128 = 0xC1F // 3103 - SYS_SIND32 = 0xC20 // 3104 - SYS_SIND64 = 0xC21 // 3105 - SYS_SIND128 = 0xC22 // 3106 - SYS_SINHD32 = 0xC23 // 3107 - SYS_SINHD64 = 0xC24 // 3108 - SYS_SINHD128 = 0xC25 // 3109 - SYS_SQRTD32 = 0xC26 // 3110 - SYS_SQRTD64 = 0xC27 // 3111 - SYS_SQRTD128 = 0xC28 // 3112 - SYS_STRTOD32 = 0xC29 // 3113 - SYS_STRTOD64 = 0xC2A // 3114 - SYS_STRTOD128 = 0xC2B // 3115 - SYS_TAND32 = 0xC2C // 3116 - SYS_TAND64 = 0xC2D // 3117 - SYS_TAND128 = 0xC2E // 3118 - SYS_TANHD32 = 0xC2F // 3119 - SYS_TANHD64 = 0xC30 // 3120 - SYS_TANHD128 = 0xC31 // 3121 - SYS_TGAMMAD32 = 0xC32 // 3122 - SYS_TGAMMAD64 = 0xC33 // 3123 - SYS_TGAMMAD128 = 0xC34 // 3124 - SYS_TRUNCD32 = 0xC3E // 3134 - SYS_TRUNCD64 = 0xC3F // 3135 - SYS_TRUNCD128 = 0xC40 // 3136 - SYS_WCSTOD32 = 0xC41 // 3137 - SYS_WCSTOD64 = 0xC42 // 3138 - SYS_WCSTOD128 = 0xC43 // 3139 - SYS___CODEPAGE_INFO = 0xC64 // 3172 - SYS_POSIX_OPENPT = 0xC66 // 3174 - SYS_PSELECT = 0xC67 // 3175 - SYS_SOCKATMARK = 0xC68 // 3176 - SYS_AIO_FSYNC = 0xC69 // 3177 - SYS_LIO_LISTIO = 0xC6A // 3178 - SYS___ATANPID32 = 0xC6B // 3179 - SYS___ATANPID64 = 0xC6C // 3180 - SYS___ATANPID128 = 0xC6D // 3181 - SYS___COSPID32 = 0xC6E // 3182 - SYS___COSPID64 = 0xC6F // 3183 - SYS___COSPID128 = 0xC70 // 3184 - SYS___SINPID32 = 0xC71 // 3185 - SYS___SINPID64 = 0xC72 // 3186 - SYS___SINPID128 = 0xC73 // 3187 - SYS_SETIPV4SOURCEFILTER = 0xC76 // 3190 - SYS_GETIPV4SOURCEFILTER = 0xC77 // 3191 - SYS_SETSOURCEFILTER = 0xC78 // 3192 - SYS_GETSOURCEFILTER = 0xC79 // 3193 - SYS_FWRITE_UNLOCKED = 0xC7A // 3194 - SYS_FREAD_UNLOCKED = 0xC7B // 3195 - SYS_FGETS_UNLOCKED = 0xC7C // 3196 - SYS_GETS_UNLOCKED = 0xC7D // 3197 - SYS_FPUTS_UNLOCKED = 0xC7E // 3198 - SYS_PUTS_UNLOCKED = 0xC7F // 3199 - SYS_FGETC_UNLOCKED = 0xC80 // 3200 - SYS_FPUTC_UNLOCKED = 0xC81 // 3201 - SYS_DLADDR = 0xC82 // 3202 - SYS_SHM_OPEN = 0xC8C // 3212 - SYS_SHM_UNLINK = 0xC8D // 3213 - SYS___CLASS2F = 0xC91 // 3217 - SYS___CLASS2L = 0xC92 // 3218 - SYS___CLASS2F_B = 0xC93 // 3219 - SYS___CLASS2F_H = 0xC94 // 3220 - SYS___CLASS2L_B = 0xC95 // 3221 - SYS___CLASS2L_H = 0xC96 // 3222 - SYS___CLASS2D32 = 0xC97 // 3223 - SYS___CLASS2D64 = 0xC98 // 3224 - SYS___CLASS2D128 = 0xC99 // 3225 - SYS___TOCSNAME2 = 0xC9A // 3226 - SYS___D1TOP = 0xC9B // 3227 - SYS___D2TOP = 0xC9C // 3228 - SYS___D4TOP = 0xC9D // 3229 - SYS___PTOD1 = 0xC9E // 3230 - SYS___PTOD2 = 0xC9F // 3231 - SYS___PTOD4 = 0xCA0 // 3232 - SYS_CLEARERR_UNLOCKED = 0xCA1 // 3233 - SYS_FDELREC_UNLOCKED = 0xCA2 // 3234 - SYS_FEOF_UNLOCKED = 0xCA3 // 3235 - SYS_FERROR_UNLOCKED = 0xCA4 // 3236 - SYS_FFLUSH_UNLOCKED = 0xCA5 // 3237 - SYS_FGETPOS_UNLOCKED = 0xCA6 // 3238 - SYS_FGETWC_UNLOCKED = 0xCA7 // 3239 - SYS_FGETWS_UNLOCKED = 0xCA8 // 3240 - SYS_FILENO_UNLOCKED = 0xCA9 // 3241 - SYS_FLDATA_UNLOCKED = 0xCAA // 3242 - SYS_FLOCATE_UNLOCKED = 0xCAB // 3243 - SYS_FPRINTF_UNLOCKED = 0xCAC // 3244 - SYS_FPUTWC_UNLOCKED = 0xCAD // 3245 - SYS_FPUTWS_UNLOCKED = 0xCAE // 3246 - SYS_FSCANF_UNLOCKED = 0xCAF // 3247 - SYS_FSEEK_UNLOCKED = 0xCB0 // 3248 - SYS_FSEEKO_UNLOCKED = 0xCB1 // 3249 - SYS_FSETPOS_UNLOCKED = 0xCB3 // 3251 - SYS_FTELL_UNLOCKED = 0xCB4 // 3252 - SYS_FTELLO_UNLOCKED = 0xCB5 // 3253 - SYS_FUPDATE_UNLOCKED = 0xCB7 // 3255 - SYS_FWIDE_UNLOCKED = 0xCB8 // 3256 - SYS_FWPRINTF_UNLOCKED = 0xCB9 // 3257 - SYS_FWSCANF_UNLOCKED = 0xCBA // 3258 - SYS_GETWC_UNLOCKED = 0xCBB // 3259 - SYS_GETWCHAR_UNLOCKED = 0xCBC // 3260 - SYS_PERROR_UNLOCKED = 0xCBD // 3261 - SYS_PRINTF_UNLOCKED = 0xCBE // 3262 - SYS_PUTWC_UNLOCKED = 0xCBF // 3263 - SYS_PUTWCHAR_UNLOCKED = 0xCC0 // 3264 - SYS_REWIND_UNLOCKED = 0xCC1 // 3265 - SYS_SCANF_UNLOCKED = 0xCC2 // 3266 - SYS_UNGETC_UNLOCKED = 0xCC3 // 3267 - SYS_UNGETWC_UNLOCKED = 0xCC4 // 3268 - SYS_VFPRINTF_UNLOCKED = 0xCC5 // 3269 - SYS_VFSCANF_UNLOCKED = 0xCC7 // 3271 - SYS_VFWPRINTF_UNLOCKED = 0xCC9 // 3273 - SYS_VFWSCANF_UNLOCKED = 0xCCB // 3275 - SYS_VPRINTF_UNLOCKED = 0xCCD // 3277 - SYS_VSCANF_UNLOCKED = 0xCCF // 3279 - SYS_VWPRINTF_UNLOCKED = 0xCD1 // 3281 - SYS_VWSCANF_UNLOCKED = 0xCD3 // 3283 - SYS_WPRINTF_UNLOCKED = 0xCD5 // 3285 - SYS_WSCANF_UNLOCKED = 0xCD6 // 3286 - SYS_ASCTIME64 = 0xCD7 // 3287 - SYS_ASCTIME64_R = 0xCD8 // 3288 - SYS_CTIME64 = 0xCD9 // 3289 - SYS_CTIME64_R = 0xCDA // 3290 - SYS_DIFFTIME64 = 0xCDB // 3291 - SYS_GMTIME64 = 0xCDC // 3292 - SYS_GMTIME64_R = 0xCDD // 3293 - SYS_LOCALTIME64 = 0xCDE // 3294 - SYS_LOCALTIME64_R = 0xCDF // 3295 - SYS_MKTIME64 = 0xCE0 // 3296 - SYS_TIME64 = 0xCE1 // 3297 - SYS___LOGIN_APPLID = 0xCE2 // 3298 - SYS___PASSWD_APPLID = 0xCE3 // 3299 - SYS_PTHREAD_SECURITY_APPLID_NP = 0xCE4 // 3300 - SYS___GETTHENT = 0xCE5 // 3301 - SYS_FREEIFADDRS = 0xCE6 // 3302 - SYS_GETIFADDRS = 0xCE7 // 3303 - SYS_POSIX_FALLOCATE = 0xCE8 // 3304 - SYS_POSIX_MEMALIGN = 0xCE9 // 3305 - SYS_SIZEOF_ALLOC = 0xCEA // 3306 - SYS_RESIZE_ALLOC = 0xCEB // 3307 - SYS_FREAD_NOUPDATE = 0xCEC // 3308 - SYS_FREAD_NOUPDATE_UNLOCKED = 0xCED // 3309 - SYS_FGETPOS64 = 0xCEE // 3310 - SYS_FSEEK64 = 0xCEF // 3311 - SYS_FSEEKO64 = 0xCF0 // 3312 - SYS_FSETPOS64 = 0xCF1 // 3313 - SYS_FTELL64 = 0xCF2 // 3314 - SYS_FTELLO64 = 0xCF3 // 3315 - SYS_FGETPOS64_UNLOCKED = 0xCF4 // 3316 - SYS_FSEEK64_UNLOCKED = 0xCF5 // 3317 - SYS_FSEEKO64_UNLOCKED = 0xCF6 // 3318 - SYS_FSETPOS64_UNLOCKED = 0xCF7 // 3319 - SYS_FTELL64_UNLOCKED = 0xCF8 // 3320 - SYS_FTELLO64_UNLOCKED = 0xCF9 // 3321 - SYS_FOPEN_UNLOCKED = 0xCFA // 3322 - SYS_FREOPEN_UNLOCKED = 0xCFB // 3323 - SYS_FDOPEN_UNLOCKED = 0xCFC // 3324 - SYS_TMPFILE_UNLOCKED = 0xCFD // 3325 - SYS___MOSERVICES = 0xD3D // 3389 - SYS___GETTOD = 0xD3E // 3390 - SYS_C16RTOMB = 0xD40 // 3392 - SYS_C32RTOMB = 0xD41 // 3393 - SYS_MBRTOC16 = 0xD42 // 3394 - SYS_MBRTOC32 = 0xD43 // 3395 - SYS_QUANTEXPD32 = 0xD44 // 3396 - SYS_QUANTEXPD64 = 0xD45 // 3397 - SYS_QUANTEXPD128 = 0xD46 // 3398 - SYS___LOCALE_CTL = 0xD47 // 3399 - SYS___SMF_RECORD2 = 0xD48 // 3400 - SYS_FOPEN64 = 0xD49 // 3401 - SYS_FOPEN64_UNLOCKED = 0xD4A // 3402 - SYS_FREOPEN64 = 0xD4B // 3403 - SYS_FREOPEN64_UNLOCKED = 0xD4C // 3404 - SYS_TMPFILE64 = 0xD4D // 3405 - SYS_TMPFILE64_UNLOCKED = 0xD4E // 3406 - SYS_GETDATE64 = 0xD4F // 3407 - SYS_GETTIMEOFDAY64 = 0xD50 // 3408 - SYS_BIND2ADDRSEL = 0xD59 // 3417 - SYS_INET6_IS_SRCADDR = 0xD5A // 3418 - SYS___GETGRGID1 = 0xD5B // 3419 - SYS___GETGRNAM1 = 0xD5C // 3420 - SYS___FBUFSIZE = 0xD60 // 3424 - SYS___FPENDING = 0xD61 // 3425 - SYS___FLBF = 0xD62 // 3426 - SYS___FREADABLE = 0xD63 // 3427 - SYS___FWRITABLE = 0xD64 // 3428 - SYS___FREADING = 0xD65 // 3429 - SYS___FWRITING = 0xD66 // 3430 - SYS___FSETLOCKING = 0xD67 // 3431 - SYS__FLUSHLBF = 0xD68 // 3432 - SYS___FPURGE = 0xD69 // 3433 - SYS___FREADAHEAD = 0xD6A // 3434 - SYS___FSETERR = 0xD6B // 3435 - SYS___FPENDING_UNLOCKED = 0xD6C // 3436 - SYS___FREADING_UNLOCKED = 0xD6D // 3437 - SYS___FWRITING_UNLOCKED = 0xD6E // 3438 - SYS__FLUSHLBF_UNLOCKED = 0xD6F // 3439 - SYS___FPURGE_UNLOCKED = 0xD70 // 3440 - SYS___FREADAHEAD_UNLOCKED = 0xD71 // 3441 - SYS___LE_CEEGTJS = 0xD72 // 3442 - SYS___LE_RECORD_DUMP = 0xD73 // 3443 - SYS_FSTAT64 = 0xD74 // 3444 - SYS_LSTAT64 = 0xD75 // 3445 - SYS_STAT64 = 0xD76 // 3446 - SYS___READDIR2_64 = 0xD77 // 3447 - SYS___OPEN_STAT64 = 0xD78 // 3448 - SYS_FTW64 = 0xD79 // 3449 - SYS_NFTW64 = 0xD7A // 3450 - SYS_UTIME64 = 0xD7B // 3451 - SYS_UTIMES64 = 0xD7C // 3452 - SYS___GETIPC64 = 0xD7D // 3453 - SYS_MSGCTL64 = 0xD7E // 3454 - SYS_SEMCTL64 = 0xD7F // 3455 - SYS_SHMCTL64 = 0xD80 // 3456 - SYS_MSGXRCV64 = 0xD81 // 3457 - SYS___MGXR64 = 0xD81 // 3457 - SYS_W_GETPSENT64 = 0xD82 // 3458 - SYS_PTHREAD_COND_TIMEDWAIT64 = 0xD83 // 3459 - SYS_FTIME64 = 0xD85 // 3461 - SYS_GETUTXENT64 = 0xD86 // 3462 - SYS_GETUTXID64 = 0xD87 // 3463 - SYS_GETUTXLINE64 = 0xD88 // 3464 - SYS_PUTUTXLINE64 = 0xD89 // 3465 - SYS_NEWLOCALE = 0xD8A // 3466 - SYS_FREELOCALE = 0xD8B // 3467 - SYS_USELOCALE = 0xD8C // 3468 - SYS_DUPLOCALE = 0xD8D // 3469 - SYS___CHATTR64 = 0xD9C // 3484 - SYS___LCHATTR64 = 0xD9D // 3485 - SYS___FCHATTR64 = 0xD9E // 3486 - SYS_____CHATTR64_A = 0xD9F // 3487 - SYS_____LCHATTR64_A = 0xDA0 // 3488 - SYS___LE_CEEUSGD = 0xDA1 // 3489 - SYS___LE_IFAM_CON = 0xDA2 // 3490 - SYS___LE_IFAM_DSC = 0xDA3 // 3491 - SYS___LE_IFAM_GET = 0xDA4 // 3492 - SYS___LE_IFAM_QRY = 0xDA5 // 3493 - SYS_ALIGNED_ALLOC = 0xDA6 // 3494 - SYS_ACCEPT4 = 0xDA7 // 3495 - SYS___ACCEPT4_A = 0xDA8 // 3496 - SYS_COPYFILERANGE = 0xDA9 // 3497 - SYS_GETLINE = 0xDAA // 3498 - SYS___GETLINE_A = 0xDAB // 3499 - SYS_DIRFD = 0xDAC // 3500 - SYS_CLOCK_GETTIME = 0xDAD // 3501 - SYS_DUP3 = 0xDAE // 3502 - SYS_EPOLL_CREATE = 0xDAF // 3503 - SYS_EPOLL_CREATE1 = 0xDB0 // 3504 - SYS_EPOLL_CTL = 0xDB1 // 3505 - SYS_EPOLL_WAIT = 0xDB2 // 3506 - SYS_EPOLL_PWAIT = 0xDB3 // 3507 - SYS_EVENTFD = 0xDB4 // 3508 - SYS_STATFS = 0xDB5 // 3509 - SYS___STATFS_A = 0xDB6 // 3510 - SYS_FSTATFS = 0xDB7 // 3511 - SYS_INOTIFY_INIT = 0xDB8 // 3512 - SYS_INOTIFY_INIT1 = 0xDB9 // 3513 - SYS_INOTIFY_ADD_WATCH = 0xDBA // 3514 - SYS___INOTIFY_ADD_WATCH_A = 0xDBB // 3515 - SYS_INOTIFY_RM_WATCH = 0xDBC // 3516 - SYS_PIPE2 = 0xDBD // 3517 - SYS_PIVOT_ROOT = 0xDBE // 3518 - SYS___PIVOT_ROOT_A = 0xDBF // 3519 - SYS_PRCTL = 0xDC0 // 3520 - SYS_PRLIMIT = 0xDC1 // 3521 - SYS_SETHOSTNAME = 0xDC2 // 3522 - SYS___SETHOSTNAME_A = 0xDC3 // 3523 - SYS_SETRESUID = 0xDC4 // 3524 - SYS_SETRESGID = 0xDC5 // 3525 - SYS_PTHREAD_CONDATTR_GETCLOCK = 0xDC6 // 3526 - SYS_FLOCK = 0xDC7 // 3527 - SYS_FGETXATTR = 0xDC8 // 3528 - SYS___FGETXATTR_A = 0xDC9 // 3529 - SYS_FLISTXATTR = 0xDCA // 3530 - SYS___FLISTXATTR_A = 0xDCB // 3531 - SYS_FREMOVEXATTR = 0xDCC // 3532 - SYS___FREMOVEXATTR_A = 0xDCD // 3533 - SYS_FSETXATTR = 0xDCE // 3534 - SYS___FSETXATTR_A = 0xDCF // 3535 - SYS_GETXATTR = 0xDD0 // 3536 - SYS___GETXATTR_A = 0xDD1 // 3537 - SYS_LGETXATTR = 0xDD2 // 3538 - SYS___LGETXATTR_A = 0xDD3 // 3539 - SYS_LISTXATTR = 0xDD4 // 3540 - SYS___LISTXATTR_A = 0xDD5 // 3541 - SYS_LLISTXATTR = 0xDD6 // 3542 - SYS___LLISTXATTR_A = 0xDD7 // 3543 - SYS_LREMOVEXATTR = 0xDD8 // 3544 - SYS___LREMOVEXATTR_A = 0xDD9 // 3545 - SYS_LSETXATTR = 0xDDA // 3546 - SYS___LSETXATTR_A = 0xDDB // 3547 - SYS_REMOVEXATTR = 0xDDC // 3548 - SYS___REMOVEXATTR_A = 0xDDD // 3549 - SYS_SETXATTR = 0xDDE // 3550 - SYS___SETXATTR_A = 0xDDF // 3551 - SYS_FDATASYNC = 0xDE0 // 3552 - SYS_SYNCFS = 0xDE1 // 3553 - SYS_FUTIMES = 0xDE2 // 3554 - SYS_FUTIMESAT = 0xDE3 // 3555 - SYS___FUTIMESAT_A = 0xDE4 // 3556 - SYS_LUTIMES = 0xDE5 // 3557 - SYS___LUTIMES_A = 0xDE6 // 3558 - SYS_INET_ATON = 0xDE7 // 3559 - SYS_GETRANDOM = 0xDE8 // 3560 - SYS_GETTID = 0xDE9 // 3561 - SYS_MEMFD_CREATE = 0xDEA // 3562 - SYS___MEMFD_CREATE_A = 0xDEB // 3563 - SYS_FACCESSAT = 0xDEC // 3564 - SYS___FACCESSAT_A = 0xDED // 3565 - SYS_FCHMODAT = 0xDEE // 3566 - SYS___FCHMODAT_A = 0xDEF // 3567 - SYS_FCHOWNAT = 0xDF0 // 3568 - SYS___FCHOWNAT_A = 0xDF1 // 3569 - SYS_FSTATAT = 0xDF2 // 3570 - SYS___FSTATAT_A = 0xDF3 // 3571 - SYS_LINKAT = 0xDF4 // 3572 - SYS___LINKAT_A = 0xDF5 // 3573 - SYS_MKDIRAT = 0xDF6 // 3574 - SYS___MKDIRAT_A = 0xDF7 // 3575 - SYS_MKFIFOAT = 0xDF8 // 3576 - SYS___MKFIFOAT_A = 0xDF9 // 3577 - SYS_MKNODAT = 0xDFA // 3578 - SYS___MKNODAT_A = 0xDFB // 3579 - SYS_OPENAT = 0xDFC // 3580 - SYS___OPENAT_A = 0xDFD // 3581 - SYS_READLINKAT = 0xDFE // 3582 - SYS___READLINKAT_A = 0xDFF // 3583 - SYS_RENAMEAT = 0xE00 // 3584 - SYS___RENAMEAT_A = 0xE01 // 3585 - SYS_RENAMEAT2 = 0xE02 // 3586 - SYS___RENAMEAT2_A = 0xE03 // 3587 - SYS_SYMLINKAT = 0xE04 // 3588 - SYS___SYMLINKAT_A = 0xE05 // 3589 - SYS_UNLINKAT = 0xE06 // 3590 - SYS___UNLINKAT_A = 0xE07 // 3591 - SYS_SYSINFO = 0xE08 // 3592 - SYS_WAIT4 = 0xE0A // 3594 - SYS_CLONE = 0xE0B // 3595 - SYS_UNSHARE = 0xE0C // 3596 - SYS_SETNS = 0xE0D // 3597 - SYS_CAPGET = 0xE0E // 3598 - SYS_CAPSET = 0xE0F // 3599 - SYS_STRCHRNUL = 0xE10 // 3600 - SYS_PTHREAD_CONDATTR_SETCLOCK = 0xE12 // 3602 - SYS_OPEN_BY_HANDLE_AT = 0xE13 // 3603 - SYS___OPEN_BY_HANDLE_AT_A = 0xE14 // 3604 - SYS___INET_ATON_A = 0xE15 // 3605 - SYS_MOUNT1 = 0xE16 // 3606 - SYS___MOUNT1_A = 0xE17 // 3607 - SYS_UMOUNT1 = 0xE18 // 3608 - SYS___UMOUNT1_A = 0xE19 // 3609 - SYS_UMOUNT2 = 0xE1A // 3610 - SYS___UMOUNT2_A = 0xE1B // 3611 - SYS___PRCTL_A = 0xE1C // 3612 - SYS_LOCALTIME_R2 = 0xE1D // 3613 - SYS___LOCALTIME_R2_A = 0xE1E // 3614 - SYS_OPENAT2 = 0xE1F // 3615 - SYS___OPENAT2_A = 0xE20 // 3616 - SYS___LE_CEEMICT = 0xE21 // 3617 - SYS_GETENTROPY = 0xE22 // 3618 - SYS_NANOSLEEP = 0xE23 // 3619 - SYS_UTIMENSAT = 0xE24 // 3620 - SYS___UTIMENSAT_A = 0xE25 // 3621 - SYS_ASPRINTF = 0xE26 // 3622 - SYS___ASPRINTF_A = 0xE27 // 3623 - SYS_VASPRINTF = 0xE28 // 3624 - SYS___VASPRINTF_A = 0xE29 // 3625 - SYS_DPRINTF = 0xE2A // 3626 - SYS___DPRINTF_A = 0xE2B // 3627 - SYS_GETOPT_LONG = 0xE2C // 3628 - SYS___GETOPT_LONG_A = 0xE2D // 3629 - SYS_PSIGNAL = 0xE2E // 3630 - SYS___PSIGNAL_A = 0xE2F // 3631 - SYS_PSIGNAL_UNLOCKED = 0xE30 // 3632 - SYS___PSIGNAL_UNLOCKED_A = 0xE31 // 3633 - SYS_FSTATAT_O = 0xE32 // 3634 - SYS___FSTATAT_O_A = 0xE33 // 3635 - SYS_FSTATAT64 = 0xE34 // 3636 - SYS___FSTATAT64_A = 0xE35 // 3637 - SYS___CHATTRAT = 0xE36 // 3638 - SYS_____CHATTRAT_A = 0xE37 // 3639 - SYS___CHATTRAT64 = 0xE38 // 3640 - SYS_____CHATTRAT64_A = 0xE39 // 3641 - SYS_MADVISE = 0xE3A // 3642 - SYS___AUTHENTICATE = 0xE3B // 3643 +// TODO: auto-generate. +const ( + SYS_ACOSD128 = 0xB80 + SYS_ACOSD32 = 0xB7E + SYS_ACOSD64 = 0xB7F + SYS_ACOSHD128 = 0xB83 + SYS_ACOSHD32 = 0xB81 + SYS_ACOSHD64 = 0xB82 + SYS_AIO_FSYNC = 0xC69 + SYS_ASCTIME = 0x0AE + SYS_ASCTIME64 = 0xCD7 + SYS_ASCTIME64_R = 0xCD8 + SYS_ASIND128 = 0xB86 + SYS_ASIND32 = 0xB84 + SYS_ASIND64 = 0xB85 + SYS_ASINHD128 = 0xB89 + SYS_ASINHD32 = 0xB87 + SYS_ASINHD64 = 0xB88 + SYS_ATAN2D128 = 0xB8F + SYS_ATAN2D32 = 0xB8D + SYS_ATAN2D64 = 0xB8E + SYS_ATAND128 = 0xB8C + SYS_ATAND32 = 0xB8A + SYS_ATAND64 = 0xB8B + SYS_ATANHD128 = 0xB92 + SYS_ATANHD32 = 0xB90 + SYS_ATANHD64 = 0xB91 + SYS_BIND2ADDRSEL = 0xD59 + SYS_C16RTOMB = 0xD40 + SYS_C32RTOMB = 0xD41 + SYS_CBRTD128 = 0xB95 + SYS_CBRTD32 = 0xB93 + SYS_CBRTD64 = 0xB94 + SYS_CEILD128 = 0xB98 + SYS_CEILD32 = 0xB96 + SYS_CEILD64 = 0xB97 + SYS_CLEARENV = 0x0C9 + SYS_CLEARERR_UNLOCKED = 0xCA1 + SYS_CLOCK = 0x0AA + SYS_CLOGL = 0xA00 + SYS_CLRMEMF = 0x0BD + SYS_CONJ = 0xA03 + SYS_CONJF = 0xA06 + SYS_CONJL = 0xA09 + SYS_COPYSIGND128 = 0xB9E + SYS_COPYSIGND32 = 0xB9C + SYS_COPYSIGND64 = 0xB9D + SYS_COSD128 = 0xBA1 + SYS_COSD32 = 0xB9F + SYS_COSD64 = 0xBA0 + SYS_COSHD128 = 0xBA4 + SYS_COSHD32 = 0xBA2 + SYS_COSHD64 = 0xBA3 + SYS_CPOW = 0xA0C + SYS_CPOWF = 0xA0F + SYS_CPOWL = 0xA12 + SYS_CPROJ = 0xA15 + SYS_CPROJF = 0xA18 + SYS_CPROJL = 0xA1B + SYS_CREAL = 0xA1E + SYS_CREALF = 0xA21 + SYS_CREALL = 0xA24 + SYS_CSIN = 0xA27 + SYS_CSINF = 0xA2A + SYS_CSINH = 0xA30 + SYS_CSINHF = 0xA33 + SYS_CSINHL = 0xA36 + SYS_CSINL = 0xA2D + SYS_CSNAP = 0x0C5 + SYS_CSQRT = 0xA39 + SYS_CSQRTF = 0xA3C + SYS_CSQRTL = 0xA3F + SYS_CTAN = 0xA42 + SYS_CTANF = 0xA45 + SYS_CTANH = 0xA4B + SYS_CTANHF = 0xA4E + SYS_CTANHL = 0xA51 + SYS_CTANL = 0xA48 + SYS_CTIME = 0x0AB + SYS_CTIME64 = 0xCD9 + SYS_CTIME64_R = 0xCDA + SYS_CTRACE = 0x0C6 + SYS_DIFFTIME = 0x0A7 + SYS_DIFFTIME64 = 0xCDB + SYS_DLADDR = 0xC82 + SYS_DYNALLOC = 0x0C3 + SYS_DYNFREE = 0x0C2 + SYS_ERFCD128 = 0xBAA + SYS_ERFCD32 = 0xBA8 + SYS_ERFCD64 = 0xBA9 + SYS_ERFD128 = 0xBA7 + SYS_ERFD32 = 0xBA5 + SYS_ERFD64 = 0xBA6 + SYS_EXP2D128 = 0xBB0 + SYS_EXP2D32 = 0xBAE + SYS_EXP2D64 = 0xBAF + SYS_EXPD128 = 0xBAD + SYS_EXPD32 = 0xBAB + SYS_EXPD64 = 0xBAC + SYS_EXPM1D128 = 0xBB3 + SYS_EXPM1D32 = 0xBB1 + SYS_EXPM1D64 = 0xBB2 + SYS_FABSD128 = 0xBB6 + SYS_FABSD32 = 0xBB4 + SYS_FABSD64 = 0xBB5 + SYS_FDELREC_UNLOCKED = 0xCA2 + SYS_FDIMD128 = 0xBB9 + SYS_FDIMD32 = 0xBB7 + SYS_FDIMD64 = 0xBB8 + SYS_FDOPEN_UNLOCKED = 0xCFC + SYS_FECLEAREXCEPT = 0xAEA + SYS_FEGETENV = 0xAEB + SYS_FEGETEXCEPTFLAG = 0xAEC + SYS_FEGETROUND = 0xAED + SYS_FEHOLDEXCEPT = 0xAEE + SYS_FEOF_UNLOCKED = 0xCA3 + SYS_FERAISEEXCEPT = 0xAEF + SYS_FERROR_UNLOCKED = 0xCA4 + SYS_FESETENV = 0xAF0 + SYS_FESETEXCEPTFLAG = 0xAF1 + SYS_FESETROUND = 0xAF2 + SYS_FETCHEP = 0x0BF + SYS_FETESTEXCEPT = 0xAF3 + SYS_FEUPDATEENV = 0xAF4 + SYS_FE_DEC_GETROUND = 0xBBA + SYS_FE_DEC_SETROUND = 0xBBB + SYS_FFLUSH_UNLOCKED = 0xCA5 + SYS_FGETC_UNLOCKED = 0xC80 + SYS_FGETPOS64 = 0xCEE + SYS_FGETPOS64_UNLOCKED = 0xCF4 + SYS_FGETPOS_UNLOCKED = 0xCA6 + SYS_FGETS_UNLOCKED = 0xC7C + SYS_FGETWC_UNLOCKED = 0xCA7 + SYS_FGETWS_UNLOCKED = 0xCA8 + SYS_FILENO_UNLOCKED = 0xCA9 + SYS_FLDATA = 0x0C1 + SYS_FLDATA_UNLOCKED = 0xCAA + SYS_FLOCATE_UNLOCKED = 0xCAB + SYS_FLOORD128 = 0xBBE + SYS_FLOORD32 = 0xBBC + SYS_FLOORD64 = 0xBBD + SYS_FMA = 0xA63 + SYS_FMAD128 = 0xBC1 + SYS_FMAD32 = 0xBBF + SYS_FMAD64 = 0xBC0 + SYS_FMAF = 0xA66 + SYS_FMAL = 0xA69 + SYS_FMAX = 0xA6C + SYS_FMAXD128 = 0xBC4 + SYS_FMAXD32 = 0xBC2 + SYS_FMAXD64 = 0xBC3 + SYS_FMAXF = 0xA6F + SYS_FMAXL = 0xA72 + SYS_FMIN = 0xA75 + SYS_FMIND128 = 0xBC7 + SYS_FMIND32 = 0xBC5 + SYS_FMIND64 = 0xBC6 + SYS_FMINF = 0xA78 + SYS_FMINL = 0xA7B + SYS_FMODD128 = 0xBCA + SYS_FMODD32 = 0xBC8 + SYS_FMODD64 = 0xBC9 + SYS_FOPEN64 = 0xD49 + SYS_FOPEN64_UNLOCKED = 0xD4A + SYS_FOPEN_UNLOCKED = 0xCFA + SYS_FPRINTF_UNLOCKED = 0xCAC + SYS_FPUTC_UNLOCKED = 0xC81 + SYS_FPUTS_UNLOCKED = 0xC7E + SYS_FPUTWC_UNLOCKED = 0xCAD + SYS_FPUTWS_UNLOCKED = 0xCAE + SYS_FREAD_NOUPDATE = 0xCEC + SYS_FREAD_NOUPDATE_UNLOCKED = 0xCED + SYS_FREAD_UNLOCKED = 0xC7B + SYS_FREEIFADDRS = 0xCE6 + SYS_FREOPEN64 = 0xD4B + SYS_FREOPEN64_UNLOCKED = 0xD4C + SYS_FREOPEN_UNLOCKED = 0xCFB + SYS_FREXPD128 = 0xBCE + SYS_FREXPD32 = 0xBCC + SYS_FREXPD64 = 0xBCD + SYS_FSCANF_UNLOCKED = 0xCAF + SYS_FSEEK64 = 0xCEF + SYS_FSEEK64_UNLOCKED = 0xCF5 + SYS_FSEEKO64 = 0xCF0 + SYS_FSEEKO64_UNLOCKED = 0xCF6 + SYS_FSEEKO_UNLOCKED = 0xCB1 + SYS_FSEEK_UNLOCKED = 0xCB0 + SYS_FSETPOS64 = 0xCF1 + SYS_FSETPOS64_UNLOCKED = 0xCF7 + SYS_FSETPOS_UNLOCKED = 0xCB3 + SYS_FTELL64 = 0xCF2 + SYS_FTELL64_UNLOCKED = 0xCF8 + SYS_FTELLO64 = 0xCF3 + SYS_FTELLO64_UNLOCKED = 0xCF9 + SYS_FTELLO_UNLOCKED = 0xCB5 + SYS_FTELL_UNLOCKED = 0xCB4 + SYS_FUPDATE = 0x0B5 + SYS_FUPDATE_UNLOCKED = 0xCB7 + SYS_FWIDE_UNLOCKED = 0xCB8 + SYS_FWPRINTF_UNLOCKED = 0xCB9 + SYS_FWRITE_UNLOCKED = 0xC7A + SYS_FWSCANF_UNLOCKED = 0xCBA + SYS_GETDATE64 = 0xD4F + SYS_GETIFADDRS = 0xCE7 + SYS_GETIPV4SOURCEFILTER = 0xC77 + SYS_GETSOURCEFILTER = 0xC79 + SYS_GETSYNTX = 0x0FD + SYS_GETS_UNLOCKED = 0xC7D + SYS_GETTIMEOFDAY64 = 0xD50 + SYS_GETWCHAR_UNLOCKED = 0xCBC + SYS_GETWC_UNLOCKED = 0xCBB + SYS_GMTIME = 0x0B0 + SYS_GMTIME64 = 0xCDC + SYS_GMTIME64_R = 0xCDD + SYS_HYPOTD128 = 0xBD1 + SYS_HYPOTD32 = 0xBCF + SYS_HYPOTD64 = 0xBD0 + SYS_ILOGBD128 = 0xBD4 + SYS_ILOGBD32 = 0xBD2 + SYS_ILOGBD64 = 0xBD3 + SYS_ILOGBF = 0xA7E + SYS_ILOGBL = 0xA81 + SYS_INET6_IS_SRCADDR = 0xD5A + SYS_ISBLANK = 0x0FE + SYS_ISWALNUM = 0x0FF + SYS_LDEXPD128 = 0xBD7 + SYS_LDEXPD32 = 0xBD5 + SYS_LDEXPD64 = 0xBD6 + SYS_LGAMMAD128 = 0xBDA + SYS_LGAMMAD32 = 0xBD8 + SYS_LGAMMAD64 = 0xBD9 + SYS_LIO_LISTIO = 0xC6A + SYS_LLRINT = 0xA84 + SYS_LLRINTD128 = 0xBDD + SYS_LLRINTD32 = 0xBDB + SYS_LLRINTD64 = 0xBDC + SYS_LLRINTF = 0xA87 + SYS_LLRINTL = 0xA8A + SYS_LLROUND = 0xA8D + SYS_LLROUNDD128 = 0xBE0 + SYS_LLROUNDD32 = 0xBDE + SYS_LLROUNDD64 = 0xBDF + SYS_LLROUNDF = 0xA90 + SYS_LLROUNDL = 0xA93 + SYS_LOCALTIM = 0x0B1 + SYS_LOCALTIME = 0x0B1 + SYS_LOCALTIME64 = 0xCDE + SYS_LOCALTIME64_R = 0xCDF + SYS_LOG10D128 = 0xBE6 + SYS_LOG10D32 = 0xBE4 + SYS_LOG10D64 = 0xBE5 + SYS_LOG1PD128 = 0xBE9 + SYS_LOG1PD32 = 0xBE7 + SYS_LOG1PD64 = 0xBE8 + SYS_LOG2D128 = 0xBEC + SYS_LOG2D32 = 0xBEA + SYS_LOG2D64 = 0xBEB + SYS_LOGBD128 = 0xBEF + SYS_LOGBD32 = 0xBED + SYS_LOGBD64 = 0xBEE + SYS_LOGBF = 0xA96 + SYS_LOGBL = 0xA99 + SYS_LOGD128 = 0xBE3 + SYS_LOGD32 = 0xBE1 + SYS_LOGD64 = 0xBE2 + SYS_LRINT = 0xA9C + SYS_LRINTD128 = 0xBF2 + SYS_LRINTD32 = 0xBF0 + SYS_LRINTD64 = 0xBF1 + SYS_LRINTF = 0xA9F + SYS_LRINTL = 0xAA2 + SYS_LROUNDD128 = 0xBF5 + SYS_LROUNDD32 = 0xBF3 + SYS_LROUNDD64 = 0xBF4 + SYS_LROUNDL = 0xAA5 + SYS_MBLEN = 0x0AF + SYS_MBRTOC16 = 0xD42 + SYS_MBRTOC32 = 0xD43 + SYS_MEMSET = 0x0A3 + SYS_MKTIME = 0x0AC + SYS_MKTIME64 = 0xCE0 + SYS_MODFD128 = 0xBF8 + SYS_MODFD32 = 0xBF6 + SYS_MODFD64 = 0xBF7 + SYS_NAN = 0xAA8 + SYS_NAND128 = 0xBFB + SYS_NAND32 = 0xBF9 + SYS_NAND64 = 0xBFA + SYS_NANF = 0xAAA + SYS_NANL = 0xAAC + SYS_NEARBYINT = 0xAAE + SYS_NEARBYINTD128 = 0xBFE + SYS_NEARBYINTD32 = 0xBFC + SYS_NEARBYINTD64 = 0xBFD + SYS_NEARBYINTF = 0xAB1 + SYS_NEARBYINTL = 0xAB4 + SYS_NEXTAFTERD128 = 0xC01 + SYS_NEXTAFTERD32 = 0xBFF + SYS_NEXTAFTERD64 = 0xC00 + SYS_NEXTAFTERF = 0xAB7 + SYS_NEXTAFTERL = 0xABA + SYS_NEXTTOWARD = 0xABD + SYS_NEXTTOWARDD128 = 0xC04 + SYS_NEXTTOWARDD32 = 0xC02 + SYS_NEXTTOWARDD64 = 0xC03 + SYS_NEXTTOWARDF = 0xAC0 + SYS_NEXTTOWARDL = 0xAC3 + SYS_NL_LANGINFO = 0x0FC + SYS_PERROR_UNLOCKED = 0xCBD + SYS_POSIX_FALLOCATE = 0xCE8 + SYS_POSIX_MEMALIGN = 0xCE9 + SYS_POSIX_OPENPT = 0xC66 + SYS_POWD128 = 0xC07 + SYS_POWD32 = 0xC05 + SYS_POWD64 = 0xC06 + SYS_PRINTF_UNLOCKED = 0xCBE + SYS_PSELECT = 0xC67 + SYS_PTHREAD_ATTR_GETSTACK = 0xB3E + SYS_PTHREAD_ATTR_SETSTACK = 0xB3F + SYS_PTHREAD_SECURITY_APPLID_NP = 0xCE4 + SYS_PUTS_UNLOCKED = 0xC7F + SYS_PUTWCHAR_UNLOCKED = 0xCC0 + SYS_PUTWC_UNLOCKED = 0xCBF + SYS_QUANTEXPD128 = 0xD46 + SYS_QUANTEXPD32 = 0xD44 + SYS_QUANTEXPD64 = 0xD45 + SYS_QUANTIZED128 = 0xC0A + SYS_QUANTIZED32 = 0xC08 + SYS_QUANTIZED64 = 0xC09 + SYS_REMAINDERD128 = 0xC0D + SYS_REMAINDERD32 = 0xC0B + SYS_REMAINDERD64 = 0xC0C + SYS_RESIZE_ALLOC = 0xCEB + SYS_REWIND_UNLOCKED = 0xCC1 + SYS_RINTD128 = 0xC13 + SYS_RINTD32 = 0xC11 + SYS_RINTD64 = 0xC12 + SYS_RINTF = 0xACB + SYS_RINTL = 0xACD + SYS_ROUND = 0xACF + SYS_ROUNDD128 = 0xC16 + SYS_ROUNDD32 = 0xC14 + SYS_ROUNDD64 = 0xC15 + SYS_ROUNDF = 0xAD2 + SYS_ROUNDL = 0xAD5 + SYS_SAMEQUANTUMD128 = 0xC19 + SYS_SAMEQUANTUMD32 = 0xC17 + SYS_SAMEQUANTUMD64 = 0xC18 + SYS_SCALBLN = 0xAD8 + SYS_SCALBLND128 = 0xC1C + SYS_SCALBLND32 = 0xC1A + SYS_SCALBLND64 = 0xC1B + SYS_SCALBLNF = 0xADB + SYS_SCALBLNL = 0xADE + SYS_SCALBND128 = 0xC1F + SYS_SCALBND32 = 0xC1D + SYS_SCALBND64 = 0xC1E + SYS_SCALBNF = 0xAE3 + SYS_SCALBNL = 0xAE6 + SYS_SCANF_UNLOCKED = 0xCC2 + SYS_SCHED_YIELD = 0xB32 + SYS_SETENV = 0x0C8 + SYS_SETIPV4SOURCEFILTER = 0xC76 + SYS_SETSOURCEFILTER = 0xC78 + SYS_SHM_OPEN = 0xC8C + SYS_SHM_UNLINK = 0xC8D + SYS_SIND128 = 0xC22 + SYS_SIND32 = 0xC20 + SYS_SIND64 = 0xC21 + SYS_SINHD128 = 0xC25 + SYS_SINHD32 = 0xC23 + SYS_SINHD64 = 0xC24 + SYS_SIZEOF_ALLOC = 0xCEA + SYS_SOCKATMARK = 0xC68 + SYS_SQRTD128 = 0xC28 + SYS_SQRTD32 = 0xC26 + SYS_SQRTD64 = 0xC27 + SYS_STRCHR = 0x0A0 + SYS_STRCSPN = 0x0A1 + SYS_STRERROR = 0x0A8 + SYS_STRERROR_R = 0xB33 + SYS_STRFTIME = 0x0B2 + SYS_STRLEN = 0x0A9 + SYS_STRPBRK = 0x0A2 + SYS_STRSPN = 0x0A4 + SYS_STRSTR = 0x0A5 + SYS_STRTOD128 = 0xC2B + SYS_STRTOD32 = 0xC29 + SYS_STRTOD64 = 0xC2A + SYS_STRTOK = 0x0A6 + SYS_TAND128 = 0xC2E + SYS_TAND32 = 0xC2C + SYS_TAND64 = 0xC2D + SYS_TANHD128 = 0xC31 + SYS_TANHD32 = 0xC2F + SYS_TANHD64 = 0xC30 + SYS_TGAMMAD128 = 0xC34 + SYS_TGAMMAD32 = 0xC32 + SYS_TGAMMAD64 = 0xC33 + SYS_TIME = 0x0AD + SYS_TIME64 = 0xCE1 + SYS_TMPFILE64 = 0xD4D + SYS_TMPFILE64_UNLOCKED = 0xD4E + SYS_TMPFILE_UNLOCKED = 0xCFD + SYS_TRUNCD128 = 0xC40 + SYS_TRUNCD32 = 0xC3E + SYS_TRUNCD64 = 0xC3F + SYS_UNGETC_UNLOCKED = 0xCC3 + SYS_UNGETWC_UNLOCKED = 0xCC4 + SYS_UNSETENV = 0xB34 + SYS_VFPRINTF_UNLOCKED = 0xCC5 + SYS_VFSCANF_UNLOCKED = 0xCC7 + SYS_VFWPRINTF_UNLOCKED = 0xCC9 + SYS_VFWSCANF_UNLOCKED = 0xCCB + SYS_VPRINTF_UNLOCKED = 0xCCD + SYS_VSCANF_UNLOCKED = 0xCCF + SYS_VWPRINTF_UNLOCKED = 0xCD1 + SYS_VWSCANF_UNLOCKED = 0xCD3 + SYS_WCSTOD128 = 0xC43 + SYS_WCSTOD32 = 0xC41 + SYS_WCSTOD64 = 0xC42 + SYS_WPRINTF_UNLOCKED = 0xCD5 + SYS_WSCANF_UNLOCKED = 0xCD6 + SYS__FLUSHLBF = 0xD68 + SYS__FLUSHLBF_UNLOCKED = 0xD6F + SYS___ACOSHF_H = 0xA54 + SYS___ACOSHL_H = 0xA55 + SYS___ASINHF_H = 0xA56 + SYS___ASINHL_H = 0xA57 + SYS___ATANPID128 = 0xC6D + SYS___ATANPID32 = 0xC6B + SYS___ATANPID64 = 0xC6C + SYS___CBRTF_H = 0xA58 + SYS___CBRTL_H = 0xA59 + SYS___CDUMP = 0x0C4 + SYS___CLASS = 0xAFA + SYS___CLASS2 = 0xB99 + SYS___CLASS2D128 = 0xC99 + SYS___CLASS2D32 = 0xC97 + SYS___CLASS2D64 = 0xC98 + SYS___CLASS2F = 0xC91 + SYS___CLASS2F_B = 0xC93 + SYS___CLASS2F_H = 0xC94 + SYS___CLASS2L = 0xC92 + SYS___CLASS2L_B = 0xC95 + SYS___CLASS2L_H = 0xC96 + SYS___CLASS2_B = 0xB9A + SYS___CLASS2_H = 0xB9B + SYS___CLASS_B = 0xAFB + SYS___CLASS_H = 0xAFC + SYS___CLOGL_B = 0xA01 + SYS___CLOGL_H = 0xA02 + SYS___CLRENV = 0x0C9 + SYS___CLRMF = 0x0BD + SYS___CODEPAGE_INFO = 0xC64 + SYS___CONJF_B = 0xA07 + SYS___CONJF_H = 0xA08 + SYS___CONJL_B = 0xA0A + SYS___CONJL_H = 0xA0B + SYS___CONJ_B = 0xA04 + SYS___CONJ_H = 0xA05 + SYS___COPYSIGN_B = 0xA5A + SYS___COPYSIGN_H = 0xAF5 + SYS___COSPID128 = 0xC70 + SYS___COSPID32 = 0xC6E + SYS___COSPID64 = 0xC6F + SYS___CPOWF_B = 0xA10 + SYS___CPOWF_H = 0xA11 + SYS___CPOWL_B = 0xA13 + SYS___CPOWL_H = 0xA14 + SYS___CPOW_B = 0xA0D + SYS___CPOW_H = 0xA0E + SYS___CPROJF_B = 0xA19 + SYS___CPROJF_H = 0xA1A + SYS___CPROJL_B = 0xA1C + SYS___CPROJL_H = 0xA1D + SYS___CPROJ_B = 0xA16 + SYS___CPROJ_H = 0xA17 + SYS___CREALF_B = 0xA22 + SYS___CREALF_H = 0xA23 + SYS___CREALL_B = 0xA25 + SYS___CREALL_H = 0xA26 + SYS___CREAL_B = 0xA1F + SYS___CREAL_H = 0xA20 + SYS___CSINF_B = 0xA2B + SYS___CSINF_H = 0xA2C + SYS___CSINHF_B = 0xA34 + SYS___CSINHF_H = 0xA35 + SYS___CSINHL_B = 0xA37 + SYS___CSINHL_H = 0xA38 + SYS___CSINH_B = 0xA31 + SYS___CSINH_H = 0xA32 + SYS___CSINL_B = 0xA2E + SYS___CSINL_H = 0xA2F + SYS___CSIN_B = 0xA28 + SYS___CSIN_H = 0xA29 + SYS___CSNAP = 0x0C5 + SYS___CSQRTF_B = 0xA3D + SYS___CSQRTF_H = 0xA3E + SYS___CSQRTL_B = 0xA40 + SYS___CSQRTL_H = 0xA41 + SYS___CSQRT_B = 0xA3A + SYS___CSQRT_H = 0xA3B + SYS___CTANF_B = 0xA46 + SYS___CTANF_H = 0xA47 + SYS___CTANHF_B = 0xA4F + SYS___CTANHF_H = 0xA50 + SYS___CTANHL_B = 0xA52 + SYS___CTANHL_H = 0xA53 + SYS___CTANH_B = 0xA4C + SYS___CTANH_H = 0xA4D + SYS___CTANL_B = 0xA49 + SYS___CTANL_H = 0xA4A + SYS___CTAN_B = 0xA43 + SYS___CTAN_H = 0xA44 + SYS___CTEST = 0x0C7 + SYS___CTRACE = 0x0C6 + SYS___D1TOP = 0xC9B + SYS___D2TOP = 0xC9C + SYS___D4TOP = 0xC9D + SYS___DYNALL = 0x0C3 + SYS___DYNFRE = 0x0C2 + SYS___EXP2F_H = 0xA5E + SYS___EXP2L_H = 0xA5F + SYS___EXP2_H = 0xA5D + SYS___EXPM1F_H = 0xA5B + SYS___EXPM1L_H = 0xA5C + SYS___FBUFSIZE = 0xD60 + SYS___FLBF = 0xD62 + SYS___FLDATA = 0x0C1 + SYS___FMAF_B = 0xA67 + SYS___FMAF_H = 0xA68 + SYS___FMAL_B = 0xA6A + SYS___FMAL_H = 0xA6B + SYS___FMAXF_B = 0xA70 + SYS___FMAXF_H = 0xA71 + SYS___FMAXL_B = 0xA73 + SYS___FMAXL_H = 0xA74 + SYS___FMAX_B = 0xA6D + SYS___FMAX_H = 0xA6E + SYS___FMA_B = 0xA64 + SYS___FMA_H = 0xA65 + SYS___FMINF_B = 0xA79 + SYS___FMINF_H = 0xA7A + SYS___FMINL_B = 0xA7C + SYS___FMINL_H = 0xA7D + SYS___FMIN_B = 0xA76 + SYS___FMIN_H = 0xA77 + SYS___FPENDING = 0xD61 + SYS___FPENDING_UNLOCKED = 0xD6C + SYS___FPURGE = 0xD69 + SYS___FPURGE_UNLOCKED = 0xD70 + SYS___FP_CAST_D = 0xBCB + SYS___FREADABLE = 0xD63 + SYS___FREADAHEAD = 0xD6A + SYS___FREADAHEAD_UNLOCKED = 0xD71 + SYS___FREADING = 0xD65 + SYS___FREADING_UNLOCKED = 0xD6D + SYS___FSEEK2 = 0xB3C + SYS___FSETERR = 0xD6B + SYS___FSETLOCKING = 0xD67 + SYS___FTCHEP = 0x0BF + SYS___FTELL2 = 0xB3B + SYS___FUPDT = 0x0B5 + SYS___FWRITABLE = 0xD64 + SYS___FWRITING = 0xD66 + SYS___FWRITING_UNLOCKED = 0xD6E + SYS___GETCB = 0x0B4 + SYS___GETGRGID1 = 0xD5B + SYS___GETGRNAM1 = 0xD5C + SYS___GETTHENT = 0xCE5 + SYS___GETTOD = 0xD3E + SYS___HYPOTF_H = 0xAF6 + SYS___HYPOTL_H = 0xAF7 + SYS___ILOGBF_B = 0xA7F + SYS___ILOGBF_H = 0xA80 + SYS___ILOGBL_B = 0xA82 + SYS___ILOGBL_H = 0xA83 + SYS___ISBLANK_A = 0xB2E + SYS___ISBLNK = 0x0FE + SYS___ISWBLANK_A = 0xB2F + SYS___LE_CEEGTJS = 0xD72 + SYS___LE_TRACEBACK = 0xB7A + SYS___LGAMMAL_H = 0xA62 + SYS___LGAMMA_B_C99 = 0xB39 + SYS___LGAMMA_H_C99 = 0xB38 + SYS___LGAMMA_R_C99 = 0xB3A + SYS___LLRINTF_B = 0xA88 + SYS___LLRINTF_H = 0xA89 + SYS___LLRINTL_B = 0xA8B + SYS___LLRINTL_H = 0xA8C + SYS___LLRINT_B = 0xA85 + SYS___LLRINT_H = 0xA86 + SYS___LLROUNDF_B = 0xA91 + SYS___LLROUNDF_H = 0xA92 + SYS___LLROUNDL_B = 0xA94 + SYS___LLROUNDL_H = 0xA95 + SYS___LLROUND_B = 0xA8E + SYS___LLROUND_H = 0xA8F + SYS___LOCALE_CTL = 0xD47 + SYS___LOG1PF_H = 0xA60 + SYS___LOG1PL_H = 0xA61 + SYS___LOGBF_B = 0xA97 + SYS___LOGBF_H = 0xA98 + SYS___LOGBL_B = 0xA9A + SYS___LOGBL_H = 0xA9B + SYS___LOGIN_APPLID = 0xCE2 + SYS___LRINTF_B = 0xAA0 + SYS___LRINTF_H = 0xAA1 + SYS___LRINTL_B = 0xAA3 + SYS___LRINTL_H = 0xAA4 + SYS___LRINT_B = 0xA9D + SYS___LRINT_H = 0xA9E + SYS___LROUNDF_FIXUP = 0xB31 + SYS___LROUNDL_B = 0xAA6 + SYS___LROUNDL_H = 0xAA7 + SYS___LROUND_FIXUP = 0xB30 + SYS___MOSERVICES = 0xD3D + SYS___MUST_STAY_CLEAN = 0xB7C + SYS___NANF_B = 0xAAB + SYS___NANL_B = 0xAAD + SYS___NAN_B = 0xAA9 + SYS___NEARBYINTF_B = 0xAB2 + SYS___NEARBYINTF_H = 0xAB3 + SYS___NEARBYINTL_B = 0xAB5 + SYS___NEARBYINTL_H = 0xAB6 + SYS___NEARBYINT_B = 0xAAF + SYS___NEARBYINT_H = 0xAB0 + SYS___NEXTAFTERF_B = 0xAB8 + SYS___NEXTAFTERF_H = 0xAB9 + SYS___NEXTAFTERL_B = 0xABB + SYS___NEXTAFTERL_H = 0xABC + SYS___NEXTTOWARDF_B = 0xAC1 + SYS___NEXTTOWARDF_H = 0xAC2 + SYS___NEXTTOWARDL_B = 0xAC4 + SYS___NEXTTOWARDL_H = 0xAC5 + SYS___NEXTTOWARD_B = 0xABE + SYS___NEXTTOWARD_H = 0xABF + SYS___O_ENV = 0xB7D + SYS___PASSWD_APPLID = 0xCE3 + SYS___PTOD1 = 0xC9E + SYS___PTOD2 = 0xC9F + SYS___PTOD4 = 0xCA0 + SYS___REGCOMP_STD = 0x0EA + SYS___REMAINDERF_H = 0xAC6 + SYS___REMAINDERL_H = 0xAC7 + SYS___REMQUOD128 = 0xC10 + SYS___REMQUOD32 = 0xC0E + SYS___REMQUOD64 = 0xC0F + SYS___REMQUOF_H = 0xAC9 + SYS___REMQUOL_H = 0xACA + SYS___REMQUO_H = 0xAC8 + SYS___RINTF_B = 0xACC + SYS___RINTL_B = 0xACE + SYS___ROUNDF_B = 0xAD3 + SYS___ROUNDF_H = 0xAD4 + SYS___ROUNDL_B = 0xAD6 + SYS___ROUNDL_H = 0xAD7 + SYS___ROUND_B = 0xAD0 + SYS___ROUND_H = 0xAD1 + SYS___SCALBLNF_B = 0xADC + SYS___SCALBLNF_H = 0xADD + SYS___SCALBLNL_B = 0xADF + SYS___SCALBLNL_H = 0xAE0 + SYS___SCALBLN_B = 0xAD9 + SYS___SCALBLN_H = 0xADA + SYS___SCALBNF_B = 0xAE4 + SYS___SCALBNF_H = 0xAE5 + SYS___SCALBNL_B = 0xAE7 + SYS___SCALBNL_H = 0xAE8 + SYS___SCALBN_B = 0xAE1 + SYS___SCALBN_H = 0xAE2 + SYS___SETENV = 0x0C8 + SYS___SINPID128 = 0xC73 + SYS___SINPID32 = 0xC71 + SYS___SINPID64 = 0xC72 + SYS___SMF_RECORD2 = 0xD48 + SYS___STATIC_REINIT = 0xB3D + SYS___TGAMMAF_H_C99 = 0xB79 + SYS___TGAMMAL_H = 0xAE9 + SYS___TGAMMA_H_C99 = 0xB78 + SYS___TOCSNAME2 = 0xC9A + SYS_CEIL = 0x01F + SYS_CHAUDIT = 0x1E0 + SYS_EXP = 0x01A + SYS_FCHAUDIT = 0x1E1 + SYS_FREXP = 0x01D + SYS_GETGROUPSBYNAME = 0x1E2 + SYS_GETPWUID = 0x1A0 + SYS_GETUID = 0x1A1 + SYS_ISATTY = 0x1A3 + SYS_KILL = 0x1A4 + SYS_LDEXP = 0x01E + SYS_LINK = 0x1A5 + SYS_LOG10 = 0x01C + SYS_LSEEK = 0x1A6 + SYS_LSTAT = 0x1A7 + SYS_MKDIR = 0x1A8 + SYS_MKFIFO = 0x1A9 + SYS_MKNOD = 0x1AA + SYS_MODF = 0x01B + SYS_MOUNT = 0x1AB + SYS_OPEN = 0x1AC + SYS_OPENDIR = 0x1AD + SYS_PATHCONF = 0x1AE + SYS_PAUSE = 0x1AF + SYS_PIPE = 0x1B0 + SYS_PTHREAD_ATTR_DESTROY = 0x1E7 + SYS_PTHREAD_ATTR_GETDETACHSTATE = 0x1EB + SYS_PTHREAD_ATTR_GETSTACKSIZE = 0x1E9 + SYS_PTHREAD_ATTR_GETWEIGHT_NP = 0x1ED + SYS_PTHREAD_ATTR_INIT = 0x1E6 + SYS_PTHREAD_ATTR_SETDETACHSTATE = 0x1EA + SYS_PTHREAD_ATTR_SETSTACKSIZE = 0x1E8 + SYS_PTHREAD_ATTR_SETWEIGHT_NP = 0x1EC + SYS_PTHREAD_CANCEL = 0x1EE + SYS_PTHREAD_CLEANUP_POP = 0x1F0 + SYS_PTHREAD_CLEANUP_PUSH = 0x1EF + SYS_PTHREAD_CONDATTR_DESTROY = 0x1F2 + SYS_PTHREAD_CONDATTR_INIT = 0x1F1 + SYS_PTHREAD_COND_BROADCAST = 0x1F6 + SYS_PTHREAD_COND_DESTROY = 0x1F4 + SYS_PTHREAD_COND_INIT = 0x1F3 + SYS_PTHREAD_COND_SIGNAL = 0x1F5 + SYS_PTHREAD_COND_TIMEDWAIT = 0x1F8 + SYS_PTHREAD_COND_WAIT = 0x1F7 + SYS_PTHREAD_CREATE = 0x1F9 + SYS_PTHREAD_DETACH = 0x1FA + SYS_PTHREAD_EQUAL = 0x1FB + SYS_PTHREAD_EXIT = 0x1E4 + SYS_PTHREAD_GETSPECIFIC = 0x1FC + SYS_PTHREAD_JOIN = 0x1FD + SYS_PTHREAD_KEY_CREATE = 0x1FE + SYS_PTHREAD_KILL = 0x1E5 + SYS_PTHREAD_MUTEXATTR_INIT = 0x1FF + SYS_READ = 0x1B2 + SYS_READDIR = 0x1B3 + SYS_READLINK = 0x1B4 + SYS_REWINDDIR = 0x1B5 + SYS_RMDIR = 0x1B6 + SYS_SETEGID = 0x1B7 + SYS_SETEUID = 0x1B8 + SYS_SETGID = 0x1B9 + SYS_SETPGID = 0x1BA + SYS_SETSID = 0x1BB + SYS_SETUID = 0x1BC + SYS_SIGACTION = 0x1BD + SYS_SIGADDSET = 0x1BE + SYS_SIGDELSET = 0x1BF + SYS_SIGEMPTYSET = 0x1C0 + SYS_SIGFILLSET = 0x1C1 + SYS_SIGISMEMBER = 0x1C2 + SYS_SIGLONGJMP = 0x1C3 + SYS_SIGPENDING = 0x1C4 + SYS_SIGPROCMASK = 0x1C5 + SYS_SIGSETJMP = 0x1C6 + SYS_SIGSUSPEND = 0x1C7 + SYS_SIGWAIT = 0x1E3 + SYS_SLEEP = 0x1C8 + SYS_STAT = 0x1C9 + SYS_SYMLINK = 0x1CB + SYS_SYSCONF = 0x1CC + SYS_TCDRAIN = 0x1CD + SYS_TCFLOW = 0x1CE + SYS_TCFLUSH = 0x1CF + SYS_TCGETATTR = 0x1D0 + SYS_TCGETPGRP = 0x1D1 + SYS_TCSENDBREAK = 0x1D2 + SYS_TCSETATTR = 0x1D3 + SYS_TCSETPGRP = 0x1D4 + SYS_TIMES = 0x1D5 + SYS_TTYNAME = 0x1D6 + SYS_TZSET = 0x1D7 + SYS_UMASK = 0x1D8 + SYS_UMOUNT = 0x1D9 + SYS_UNAME = 0x1DA + SYS_UNLINK = 0x1DB + SYS_UTIME = 0x1DC + SYS_WAIT = 0x1DD + SYS_WAITPID = 0x1DE + SYS_WRITE = 0x1DF + SYS_W_GETPSENT = 0x1B1 + SYS_W_IOCTL = 0x1A2 + SYS_W_STATFS = 0x1CA + SYS_A64L = 0x2EF + SYS_BCMP = 0x2B9 + SYS_BCOPY = 0x2BA + SYS_BZERO = 0x2BB + SYS_CATCLOSE = 0x2B6 + SYS_CATGETS = 0x2B7 + SYS_CATOPEN = 0x2B8 + SYS_CRYPT = 0x2AC + SYS_DBM_CLEARERR = 0x2F7 + SYS_DBM_CLOSE = 0x2F8 + SYS_DBM_DELETE = 0x2F9 + SYS_DBM_ERROR = 0x2FA + SYS_DBM_FETCH = 0x2FB + SYS_DBM_FIRSTKEY = 0x2FC + SYS_DBM_NEXTKEY = 0x2FD + SYS_DBM_OPEN = 0x2FE + SYS_DBM_STORE = 0x2FF + SYS_DRAND48 = 0x2B2 + SYS_ENCRYPT = 0x2AD + SYS_ENDUTXENT = 0x2E1 + SYS_ERAND48 = 0x2B3 + SYS_ERF = 0x02C + SYS_ERFC = 0x02D + SYS_FCHDIR = 0x2D9 + SYS_FFS = 0x2BC + SYS_FMTMSG = 0x2E5 + SYS_FSTATVFS = 0x2B4 + SYS_FTIME = 0x2F5 + SYS_GAMMA = 0x02E + SYS_GETDATE = 0x2A6 + SYS_GETPAGESIZE = 0x2D8 + SYS_GETTIMEOFDAY = 0x2F6 + SYS_GETUTXENT = 0x2E0 + SYS_GETUTXID = 0x2E2 + SYS_GETUTXLINE = 0x2E3 + SYS_HCREATE = 0x2C6 + SYS_HDESTROY = 0x2C7 + SYS_HSEARCH = 0x2C8 + SYS_HYPOT = 0x02B + SYS_INDEX = 0x2BD + SYS_INITSTATE = 0x2C2 + SYS_INSQUE = 0x2CF + SYS_ISASCII = 0x2ED + SYS_JRAND48 = 0x2E6 + SYS_L64A = 0x2F0 + SYS_LCONG48 = 0x2EA + SYS_LFIND = 0x2C9 + SYS_LRAND48 = 0x2E7 + SYS_LSEARCH = 0x2CA + SYS_MEMCCPY = 0x2D4 + SYS_MRAND48 = 0x2E8 + SYS_NRAND48 = 0x2E9 + SYS_PCLOSE = 0x2D2 + SYS_POPEN = 0x2D1 + SYS_PUTUTXLINE = 0x2E4 + SYS_RANDOM = 0x2C4 + SYS_REMQUE = 0x2D0 + SYS_RINDEX = 0x2BE + SYS_SEED48 = 0x2EC + SYS_SETKEY = 0x2AE + SYS_SETSTATE = 0x2C3 + SYS_SETUTXENT = 0x2DF + SYS_SRAND48 = 0x2EB + SYS_SRANDOM = 0x2C5 + SYS_STATVFS = 0x2B5 + SYS_STRCASECMP = 0x2BF + SYS_STRDUP = 0x2C0 + SYS_STRNCASECMP = 0x2C1 + SYS_SWAB = 0x2D3 + SYS_TDELETE = 0x2CB + SYS_TFIND = 0x2CC + SYS_TOASCII = 0x2EE + SYS_TSEARCH = 0x2CD + SYS_TWALK = 0x2CE + SYS_UALARM = 0x2F1 + SYS_USLEEP = 0x2F2 + SYS_WAIT3 = 0x2A7 + SYS_WAITID = 0x2A8 + SYS_Y1 = 0x02A + SYS___ATOE = 0x2DB + SYS___ATOE_L = 0x2DC + SYS___CATTRM = 0x2A9 + SYS___CNVBLK = 0x2AF + SYS___CRYTRM = 0x2B0 + SYS___DLGHT = 0x2A1 + SYS___ECRTRM = 0x2B1 + SYS___ETOA = 0x2DD + SYS___ETOA_L = 0x2DE + SYS___GDTRM = 0x2AA + SYS___OCLCK = 0x2DA + SYS___OPARGF = 0x2A2 + SYS___OPERRF = 0x2A5 + SYS___OPINDF = 0x2A4 + SYS___OPOPTF = 0x2A3 + SYS___RNDTRM = 0x2AB + SYS___SRCTRM = 0x2F4 + SYS___TZONE = 0x2A0 + SYS___UTXTRM = 0x2F3 + SYS_ASIN = 0x03E + SYS_ISXDIGIT = 0x03B + SYS_SETLOCAL = 0x03A + SYS_SETLOCALE = 0x03A + SYS_SIN = 0x03F + SYS_TOLOWER = 0x03C + SYS_TOUPPER = 0x03D + SYS_ACCEPT_AND_RECV = 0x4F7 + SYS_ATOL = 0x04E + SYS_CHECKSCH = 0x4BC + SYS_CHECKSCHENV = 0x4BC + SYS_CLEARERR = 0x04C + SYS_CONNECTS = 0x4B5 + SYS_CONNECTSERVER = 0x4B5 + SYS_CONNECTW = 0x4B4 + SYS_CONNECTWORKMGR = 0x4B4 + SYS_CONTINUE = 0x4B3 + SYS_CONTINUEWORKUNIT = 0x4B3 + SYS_COPYSIGN = 0x4C2 + SYS_CREATEWO = 0x4B2 + SYS_CREATEWORKUNIT = 0x4B2 + SYS_DELETEWO = 0x4B9 + SYS_DELETEWORKUNIT = 0x4B9 + SYS_DISCONNE = 0x4B6 + SYS_DISCONNECTSERVER = 0x4B6 + SYS_FEOF = 0x04D + SYS_FERROR = 0x04A + SYS_FINITE = 0x4C8 + SYS_GAMMA_R = 0x4E2 + SYS_JOINWORK = 0x4B7 + SYS_JOINWORKUNIT = 0x4B7 + SYS_LEAVEWOR = 0x4B8 + SYS_LEAVEWORKUNIT = 0x4B8 + SYS_LGAMMA_R = 0x4EB + SYS_MATHERR = 0x4D0 + SYS_PERROR = 0x04F + SYS_QUERYMET = 0x4BA + SYS_QUERYMETRICS = 0x4BA + SYS_QUERYSCH = 0x4BB + SYS_QUERYSCHENV = 0x4BB + SYS_REWIND = 0x04B + SYS_SCALBN = 0x4D4 + SYS_SIGNIFIC = 0x4D5 + SYS_SIGNIFICAND = 0x4D5 + SYS___ACOSH_B = 0x4DA + SYS___ACOS_B = 0x4D9 + SYS___ASINH_B = 0x4BE + SYS___ASIN_B = 0x4DB + SYS___ATAN2_B = 0x4DC + SYS___ATANH_B = 0x4DD + SYS___ATAN_B = 0x4BF + SYS___CBRT_B = 0x4C0 + SYS___CEIL_B = 0x4C1 + SYS___COSH_B = 0x4DE + SYS___COS_B = 0x4C3 + SYS___DGHT = 0x4A8 + SYS___ENVN = 0x4B0 + SYS___ERFC_B = 0x4C5 + SYS___ERF_B = 0x4C4 + SYS___EXPM1_B = 0x4C6 + SYS___EXP_B = 0x4DF + SYS___FABS_B = 0x4C7 + SYS___FLOOR_B = 0x4C9 + SYS___FMOD_B = 0x4E0 + SYS___FP_SETMODE = 0x4F8 + SYS___FREXP_B = 0x4CA + SYS___GAMMA_B = 0x4E1 + SYS___GDRR = 0x4A1 + SYS___HRRNO = 0x4A2 + SYS___HYPOT_B = 0x4E3 + SYS___ILOGB_B = 0x4CB + SYS___ISNAN_B = 0x4CC + SYS___J0_B = 0x4E4 + SYS___J1_B = 0x4E6 + SYS___JN_B = 0x4E8 + SYS___LDEXP_B = 0x4CD + SYS___LGAMMA_B = 0x4EA + SYS___LOG10_B = 0x4ED + SYS___LOG1P_B = 0x4CE + SYS___LOGB_B = 0x4CF + SYS___LOGIN = 0x4F5 + SYS___LOG_B = 0x4EC + SYS___MLOCKALL = 0x4B1 + SYS___MODF_B = 0x4D1 + SYS___NEXTAFTER_B = 0x4D2 + SYS___OPENDIR2 = 0x4F3 + SYS___OPEN_STAT = 0x4F6 + SYS___OPND = 0x4A5 + SYS___OPPT = 0x4A6 + SYS___OPRG = 0x4A3 + SYS___OPRR = 0x4A4 + SYS___PID_AFFINITY = 0x4BD + SYS___POW_B = 0x4EE + SYS___READDIR2 = 0x4F4 + SYS___REMAINDER_B = 0x4EF + SYS___RINT_B = 0x4D3 + SYS___SCALB_B = 0x4F0 + SYS___SIGACTIONSET = 0x4FB + SYS___SIGGM = 0x4A7 + SYS___SINH_B = 0x4F1 + SYS___SIN_B = 0x4D6 + SYS___SQRT_B = 0x4F2 + SYS___TANH_B = 0x4D8 + SYS___TAN_B = 0x4D7 + SYS___TRRNO = 0x4AF + SYS___TZNE = 0x4A9 + SYS___TZZN = 0x4AA + SYS___UCREATE = 0x4FC + SYS___UFREE = 0x4FE + SYS___UHEAPREPORT = 0x4FF + SYS___UMALLOC = 0x4FD + SYS___Y0_B = 0x4E5 + SYS___Y1_B = 0x4E7 + SYS___YN_B = 0x4E9 + SYS_ABORT = 0x05C + SYS_ASCTIME_R = 0x5E0 + SYS_ATEXIT = 0x05D + SYS_CONNECTE = 0x5AE + SYS_CONNECTEXPORTIMPORT = 0x5AE + SYS_CTIME_R = 0x5E1 + SYS_DN_COMP = 0x5DF + SYS_DN_EXPAND = 0x5DD + SYS_DN_SKIPNAME = 0x5DE + SYS_EXIT = 0x05A + SYS_EXPORTWO = 0x5A1 + SYS_EXPORTWORKUNIT = 0x5A1 + SYS_EXTRACTW = 0x5A5 + SYS_EXTRACTWORKUNIT = 0x5A5 + SYS_FSEEKO = 0x5C9 + SYS_FTELLO = 0x5C8 + SYS_GETGRGID_R = 0x5E7 + SYS_GETGRNAM_R = 0x5E8 + SYS_GETLOGIN_R = 0x5E9 + SYS_GETPWNAM_R = 0x5EA + SYS_GETPWUID_R = 0x5EB + SYS_GMTIME_R = 0x5E2 + SYS_IMPORTWO = 0x5A3 + SYS_IMPORTWORKUNIT = 0x5A3 + SYS_INET_NTOP = 0x5D3 + SYS_INET_PTON = 0x5D4 + SYS_LLABS = 0x5CE + SYS_LLDIV = 0x5CB + SYS_LOCALTIME_R = 0x5E3 + SYS_PTHREAD_ATFORK = 0x5ED + SYS_PTHREAD_ATTR_GETDETACHSTATE_U98 = 0x5FB + SYS_PTHREAD_ATTR_GETGUARDSIZE = 0x5EE + SYS_PTHREAD_ATTR_GETSCHEDPARAM = 0x5F9 + SYS_PTHREAD_ATTR_GETSTACKADDR = 0x5EF + SYS_PTHREAD_ATTR_SETDETACHSTATE_U98 = 0x5FC + SYS_PTHREAD_ATTR_SETGUARDSIZE = 0x5F0 + SYS_PTHREAD_ATTR_SETSCHEDPARAM = 0x5FA + SYS_PTHREAD_ATTR_SETSTACKADDR = 0x5F1 + SYS_PTHREAD_CONDATTR_GETPSHARED = 0x5F2 + SYS_PTHREAD_CONDATTR_SETPSHARED = 0x5F3 + SYS_PTHREAD_DETACH_U98 = 0x5FD + SYS_PTHREAD_GETCONCURRENCY = 0x5F4 + SYS_PTHREAD_GETSPECIFIC_U98 = 0x5FE + SYS_PTHREAD_KEY_DELETE = 0x5F5 + SYS_PTHREAD_SETCANCELSTATE = 0x5FF + SYS_PTHREAD_SETCONCURRENCY = 0x5F6 + SYS_PTHREAD_SIGMASK = 0x5F7 + SYS_QUERYENC = 0x5AD + SYS_QUERYWORKUNITCLASSIFICATION = 0x5AD + SYS_RAISE = 0x05E + SYS_RAND_R = 0x5E4 + SYS_READDIR_R = 0x5E6 + SYS_REALLOC = 0x05B + SYS_RES_INIT = 0x5D8 + SYS_RES_MKQUERY = 0x5D7 + SYS_RES_QUERY = 0x5D9 + SYS_RES_QUERYDOMAIN = 0x5DC + SYS_RES_SEARCH = 0x5DA + SYS_RES_SEND = 0x5DB + SYS_SETJMP = 0x05F + SYS_SIGQUEUE = 0x5A9 + SYS_STRTOK_R = 0x5E5 + SYS_STRTOLL = 0x5B0 + SYS_STRTOULL = 0x5B1 + SYS_TTYNAME_R = 0x5EC + SYS_UNDOEXPO = 0x5A2 + SYS_UNDOEXPORTWORKUNIT = 0x5A2 + SYS_UNDOIMPO = 0x5A4 + SYS_UNDOIMPORTWORKUNIT = 0x5A4 + SYS_WCSTOLL = 0x5CC + SYS_WCSTOULL = 0x5CD + SYS___ABORT = 0x05C + SYS___CONSOLE2 = 0x5D2 + SYS___CPL = 0x5A6 + SYS___DISCARDDATA = 0x5F8 + SYS___DSA_PREV = 0x5B2 + SYS___EP_FIND = 0x5B3 + SYS___FP_SWAPMODE = 0x5AF + SYS___GETUSERID = 0x5AB + SYS___GET_CPUID = 0x5B9 + SYS___GET_SYSTEM_SETTINGS = 0x5BA + SYS___IPDOMAINNAME = 0x5AC + SYS___MAP_INIT = 0x5A7 + SYS___MAP_SERVICE = 0x5A8 + SYS___MOUNT = 0x5AA + SYS___MSGRCV_TIMED = 0x5B7 + SYS___RES = 0x5D6 + SYS___SEMOP_TIMED = 0x5B8 + SYS___SERVER_THREADS_QUERY = 0x5B4 + SYS_FPRINTF = 0x06D + SYS_FSCANF = 0x06A + SYS_PRINTF = 0x06F + SYS_SETBUF = 0x06B + SYS_SETVBUF = 0x06C + SYS_SSCANF = 0x06E + SYS___CATGETS_A = 0x6C0 + SYS___CHAUDIT_A = 0x6F4 + SYS___CHMOD_A = 0x6E8 + SYS___COLLATE_INIT_A = 0x6AC + SYS___CREAT_A = 0x6F6 + SYS___CTYPE_INIT_A = 0x6AF + SYS___DLLLOAD_A = 0x6DF + SYS___DLLQUERYFN_A = 0x6E0 + SYS___DLLQUERYVAR_A = 0x6E1 + SYS___E2A_L = 0x6E3 + SYS___EXECLE_A = 0x6A0 + SYS___EXECLP_A = 0x6A4 + SYS___EXECVE_A = 0x6C1 + SYS___EXECVP_A = 0x6C2 + SYS___EXECV_A = 0x6B1 + SYS___FPRINTF_A = 0x6FA + SYS___GETADDRINFO_A = 0x6BF + SYS___GETNAMEINFO_A = 0x6C4 + SYS___GET_WCTYPE_STD_A = 0x6AE + SYS___ICONV_OPEN_A = 0x6DE + SYS___IF_INDEXTONAME_A = 0x6DC + SYS___IF_NAMETOINDEX_A = 0x6DB + SYS___ISWCTYPE_A = 0x6B0 + SYS___IS_WCTYPE_STD_A = 0x6B2 + SYS___LOCALECONV_A = 0x6B8 + SYS___LOCALECONV_STD_A = 0x6B9 + SYS___LOCALE_INIT_A = 0x6B7 + SYS___LSTAT_A = 0x6EE + SYS___LSTAT_O_A = 0x6EF + SYS___MKDIR_A = 0x6E9 + SYS___MKFIFO_A = 0x6EC + SYS___MKNOD_A = 0x6F0 + SYS___MONETARY_INIT_A = 0x6BC + SYS___MOUNT_A = 0x6F1 + SYS___NL_CSINFO_A = 0x6D6 + SYS___NL_LANGINFO_A = 0x6BA + SYS___NL_LNAGINFO_STD_A = 0x6BB + SYS___NL_MONINFO_A = 0x6D7 + SYS___NL_NUMINFO_A = 0x6D8 + SYS___NL_RESPINFO_A = 0x6D9 + SYS___NL_TIMINFO_A = 0x6DA + SYS___NUMERIC_INIT_A = 0x6C6 + SYS___OPEN_A = 0x6F7 + SYS___PRINTF_A = 0x6DD + SYS___RESP_INIT_A = 0x6C7 + SYS___RPMATCH_A = 0x6C8 + SYS___RPMATCH_C_A = 0x6C9 + SYS___RPMATCH_STD_A = 0x6CA + SYS___SETLOCALE_A = 0x6F9 + SYS___SPAWNP_A = 0x6C5 + SYS___SPAWN_A = 0x6C3 + SYS___SPRINTF_A = 0x6FB + SYS___STAT_A = 0x6EA + SYS___STAT_O_A = 0x6EB + SYS___STRCOLL_STD_A = 0x6A1 + SYS___STRFMON_A = 0x6BD + SYS___STRFMON_STD_A = 0x6BE + SYS___STRFTIME_A = 0x6CC + SYS___STRFTIME_STD_A = 0x6CD + SYS___STRPTIME_A = 0x6CE + SYS___STRPTIME_STD_A = 0x6CF + SYS___STRXFRM_A = 0x6A2 + SYS___STRXFRM_C_A = 0x6A3 + SYS___STRXFRM_STD_A = 0x6A5 + SYS___SYNTAX_INIT_A = 0x6D4 + SYS___TIME_INIT_A = 0x6CB + SYS___TOD_INIT_A = 0x6D5 + SYS___TOWLOWER_A = 0x6B3 + SYS___TOWLOWER_STD_A = 0x6B4 + SYS___TOWUPPER_A = 0x6B5 + SYS___TOWUPPER_STD_A = 0x6B6 + SYS___UMOUNT_A = 0x6F2 + SYS___VFPRINTF_A = 0x6FC + SYS___VPRINTF_A = 0x6FD + SYS___VSPRINTF_A = 0x6FE + SYS___VSWPRINTF_A = 0x6FF + SYS___WCSCOLL_A = 0x6A6 + SYS___WCSCOLL_C_A = 0x6A7 + SYS___WCSCOLL_STD_A = 0x6A8 + SYS___WCSFTIME_A = 0x6D0 + SYS___WCSFTIME_STD_A = 0x6D1 + SYS___WCSXFRM_A = 0x6A9 + SYS___WCSXFRM_C_A = 0x6AA + SYS___WCSXFRM_STD_A = 0x6AB + SYS___WCTYPE_A = 0x6AD + SYS___W_GETMNTENT_A = 0x6F5 + SYS_____CCSIDTYPE_A = 0x6E6 + SYS_____CHATTR_A = 0x6E2 + SYS_____CSNAMETYPE_A = 0x6E7 + SYS_____OPEN_STAT_A = 0x6ED + SYS_____SPAWN2_A = 0x6D2 + SYS_____SPAWNP2_A = 0x6D3 + SYS_____TOCCSID_A = 0x6E4 + SYS_____TOCSNAME_A = 0x6E5 + SYS_ACL_FREE = 0x7FF + SYS_ACL_INIT = 0x7FE + SYS_FWIDE = 0x7DF + SYS_FWPRINTF = 0x7D1 + SYS_FWRITE = 0x07E + SYS_FWSCANF = 0x7D5 + SYS_GETCHAR = 0x07B + SYS_GETS = 0x07C + SYS_M_CREATE_LAYOUT = 0x7C9 + SYS_M_DESTROY_LAYOUT = 0x7CA + SYS_M_GETVALUES_LAYOUT = 0x7CB + SYS_M_SETVALUES_LAYOUT = 0x7CC + SYS_M_TRANSFORM_LAYOUT = 0x7CD + SYS_M_WTRANSFORM_LAYOUT = 0x7CE + SYS_PREAD = 0x7C7 + SYS_PUTC = 0x07D + SYS_PUTCHAR = 0x07A + SYS_PUTS = 0x07F + SYS_PWRITE = 0x7C8 + SYS_TOWCTRAN = 0x7D8 + SYS_TOWCTRANS = 0x7D8 + SYS_UNATEXIT = 0x7B5 + SYS_VFWPRINT = 0x7D3 + SYS_VFWPRINTF = 0x7D3 + SYS_VWPRINTF = 0x7D4 + SYS_WCTRANS = 0x7D7 + SYS_WPRINTF = 0x7D2 + SYS_WSCANF = 0x7D6 + SYS___ASCTIME_R_A = 0x7A1 + SYS___BASENAME_A = 0x7DC + SYS___BTOWC_A = 0x7E4 + SYS___CDUMP_A = 0x7B7 + SYS___CEE3DMP_A = 0x7B6 + SYS___CEILF_H = 0x7F4 + SYS___CEILL_H = 0x7F5 + SYS___CEIL_H = 0x7EA + SYS___CRYPT_A = 0x7BE + SYS___CSNAP_A = 0x7B8 + SYS___CTEST_A = 0x7B9 + SYS___CTIME_R_A = 0x7A2 + SYS___CTRACE_A = 0x7BA + SYS___DBM_OPEN_A = 0x7E6 + SYS___DIRNAME_A = 0x7DD + SYS___FABSF_H = 0x7FA + SYS___FABSL_H = 0x7FB + SYS___FABS_H = 0x7ED + SYS___FGETWC_A = 0x7AA + SYS___FGETWS_A = 0x7AD + SYS___FLOORF_H = 0x7F6 + SYS___FLOORL_H = 0x7F7 + SYS___FLOOR_H = 0x7EB + SYS___FPUTWC_A = 0x7A5 + SYS___FPUTWS_A = 0x7A8 + SYS___GETTIMEOFDAY_A = 0x7AE + SYS___GETWCHAR_A = 0x7AC + SYS___GETWC_A = 0x7AB + SYS___GLOB_A = 0x7DE + SYS___GMTIME_A = 0x7AF + SYS___GMTIME_R_A = 0x7B0 + SYS___INET_PTON_A = 0x7BC + SYS___J0_H = 0x7EE + SYS___J1_H = 0x7EF + SYS___JN_H = 0x7F0 + SYS___LOCALTIME_A = 0x7B1 + SYS___LOCALTIME_R_A = 0x7B2 + SYS___MALLOC24 = 0x7FC + SYS___MALLOC31 = 0x7FD + SYS___MKTIME_A = 0x7B3 + SYS___MODFF_H = 0x7F8 + SYS___MODFL_H = 0x7F9 + SYS___MODF_H = 0x7EC + SYS___OPENDIR_A = 0x7C2 + SYS___OSNAME = 0x7E0 + SYS___PUTWCHAR_A = 0x7A7 + SYS___PUTWC_A = 0x7A6 + SYS___READDIR_A = 0x7C3 + SYS___STRTOLL_A = 0x7A3 + SYS___STRTOULL_A = 0x7A4 + SYS___SYSLOG_A = 0x7BD + SYS___TZZNA = 0x7B4 + SYS___UNGETWC_A = 0x7A9 + SYS___UTIME_A = 0x7A0 + SYS___VFPRINTF2_A = 0x7E7 + SYS___VPRINTF2_A = 0x7E8 + SYS___VSPRINTF2_A = 0x7E9 + SYS___VSWPRNTF2_A = 0x7BB + SYS___WCSTOD_A = 0x7D9 + SYS___WCSTOL_A = 0x7DA + SYS___WCSTOUL_A = 0x7DB + SYS___WCTOB_A = 0x7E5 + SYS___Y0_H = 0x7F1 + SYS___Y1_H = 0x7F2 + SYS___YN_H = 0x7F3 + SYS_____OPENDIR2_A = 0x7BF + SYS_____OSNAME_A = 0x7E1 + SYS_____READDIR2_A = 0x7C0 + SYS_DLCLOSE = 0x8DF + SYS_DLERROR = 0x8E0 + SYS_DLOPEN = 0x8DD + SYS_DLSYM = 0x8DE + SYS_FLOCKFILE = 0x8D3 + SYS_FTRYLOCKFILE = 0x8D4 + SYS_FUNLOCKFILE = 0x8D5 + SYS_GETCHAR_UNLOCKED = 0x8D7 + SYS_GETC_UNLOCKED = 0x8D6 + SYS_PUTCHAR_UNLOCKED = 0x8D9 + SYS_PUTC_UNLOCKED = 0x8D8 + SYS_SNPRINTF = 0x8DA + SYS_VSNPRINTF = 0x8DB + SYS_WCSCSPN = 0x08B + SYS_WCSLEN = 0x08C + SYS_WCSNCAT = 0x08D + SYS_WCSNCMP = 0x08A + SYS_WCSNCPY = 0x08F + SYS_WCSSPN = 0x08E + SYS___ABSF_H = 0x8E7 + SYS___ABSL_H = 0x8E8 + SYS___ABS_H = 0x8E6 + SYS___ACOSF_H = 0x8EA + SYS___ACOSH_H = 0x8EC + SYS___ACOSL_H = 0x8EB + SYS___ACOS_H = 0x8E9 + SYS___ASINF_H = 0x8EE + SYS___ASINH_H = 0x8F0 + SYS___ASINL_H = 0x8EF + SYS___ASIN_H = 0x8ED + SYS___ATAN2F_H = 0x8F8 + SYS___ATAN2L_H = 0x8F9 + SYS___ATAN2_H = 0x8F7 + SYS___ATANF_H = 0x8F2 + SYS___ATANHF_H = 0x8F5 + SYS___ATANHL_H = 0x8F6 + SYS___ATANH_H = 0x8F4 + SYS___ATANL_H = 0x8F3 + SYS___ATAN_H = 0x8F1 + SYS___CBRT_H = 0x8FA + SYS___COPYSIGNF_H = 0x8FB + SYS___COPYSIGNL_H = 0x8FC + SYS___COSF_H = 0x8FE + SYS___COSL_H = 0x8FF + SYS___COS_H = 0x8FD + SYS___DLERROR_A = 0x8D2 + SYS___DLOPEN_A = 0x8D0 + SYS___DLSYM_A = 0x8D1 + SYS___GETUTXENT_A = 0x8C6 + SYS___GETUTXID_A = 0x8C7 + SYS___GETUTXLINE_A = 0x8C8 + SYS___ITOA = 0x8AA + SYS___ITOA_A = 0x8B0 + SYS___LE_CONDITION_TOKEN_BUILD = 0x8A5 + SYS___LE_MSG_ADD_INSERT = 0x8A6 + SYS___LE_MSG_GET = 0x8A7 + SYS___LE_MSG_GET_AND_WRITE = 0x8A8 + SYS___LE_MSG_WRITE = 0x8A9 + SYS___LLTOA = 0x8AE + SYS___LLTOA_A = 0x8B4 + SYS___LTOA = 0x8AC + SYS___LTOA_A = 0x8B2 + SYS___PUTCHAR_UNLOCKED_A = 0x8CC + SYS___PUTC_UNLOCKED_A = 0x8CB + SYS___PUTUTXLINE_A = 0x8C9 + SYS___RESET_EXCEPTION_HANDLER = 0x8E3 + SYS___REXEC_A = 0x8C4 + SYS___REXEC_AF_A = 0x8C5 + SYS___SET_EXCEPTION_HANDLER = 0x8E2 + SYS___SNPRINTF_A = 0x8CD + SYS___SUPERKILL = 0x8A4 + SYS___TCGETATTR_A = 0x8A1 + SYS___TCSETATTR_A = 0x8A2 + SYS___ULLTOA = 0x8AF + SYS___ULLTOA_A = 0x8B5 + SYS___ULTOA = 0x8AD + SYS___ULTOA_A = 0x8B3 + SYS___UTOA = 0x8AB + SYS___UTOA_A = 0x8B1 + SYS___VHM_EVENT = 0x8E4 + SYS___VSNPRINTF_A = 0x8CE + SYS_____GETENV_A = 0x8C3 + SYS_____UTMPXNAME_A = 0x8CA + SYS_CACOSH = 0x9A0 + SYS_CACOSHF = 0x9A3 + SYS_CACOSHL = 0x9A6 + SYS_CARG = 0x9A9 + SYS_CARGF = 0x9AC + SYS_CARGL = 0x9AF + SYS_CASIN = 0x9B2 + SYS_CASINF = 0x9B5 + SYS_CASINH = 0x9BB + SYS_CASINHF = 0x9BE + SYS_CASINHL = 0x9C1 + SYS_CASINL = 0x9B8 + SYS_CATAN = 0x9C4 + SYS_CATANF = 0x9C7 + SYS_CATANH = 0x9CD + SYS_CATANHF = 0x9D0 + SYS_CATANHL = 0x9D3 + SYS_CATANL = 0x9CA + SYS_CCOS = 0x9D6 + SYS_CCOSF = 0x9D9 + SYS_CCOSH = 0x9DF + SYS_CCOSHF = 0x9E2 + SYS_CCOSHL = 0x9E5 + SYS_CCOSL = 0x9DC + SYS_CEXP = 0x9E8 + SYS_CEXPF = 0x9EB + SYS_CEXPL = 0x9EE + SYS_CIMAG = 0x9F1 + SYS_CIMAGF = 0x9F4 + SYS_CIMAGL = 0x9F7 + SYS_CLOGF = 0x9FD + SYS_MEMCHR = 0x09B + SYS_MEMCMP = 0x09A + SYS_STRCOLL = 0x09C + SYS_STRNCMP = 0x09D + SYS_STRRCHR = 0x09F + SYS_STRXFRM = 0x09E + SYS___CACOSHF_B = 0x9A4 + SYS___CACOSHF_H = 0x9A5 + SYS___CACOSHL_B = 0x9A7 + SYS___CACOSHL_H = 0x9A8 + SYS___CACOSH_B = 0x9A1 + SYS___CACOSH_H = 0x9A2 + SYS___CARGF_B = 0x9AD + SYS___CARGF_H = 0x9AE + SYS___CARGL_B = 0x9B0 + SYS___CARGL_H = 0x9B1 + SYS___CARG_B = 0x9AA + SYS___CARG_H = 0x9AB + SYS___CASINF_B = 0x9B6 + SYS___CASINF_H = 0x9B7 + SYS___CASINHF_B = 0x9BF + SYS___CASINHF_H = 0x9C0 + SYS___CASINHL_B = 0x9C2 + SYS___CASINHL_H = 0x9C3 + SYS___CASINH_B = 0x9BC + SYS___CASINH_H = 0x9BD + SYS___CASINL_B = 0x9B9 + SYS___CASINL_H = 0x9BA + SYS___CASIN_B = 0x9B3 + SYS___CASIN_H = 0x9B4 + SYS___CATANF_B = 0x9C8 + SYS___CATANF_H = 0x9C9 + SYS___CATANHF_B = 0x9D1 + SYS___CATANHF_H = 0x9D2 + SYS___CATANHL_B = 0x9D4 + SYS___CATANHL_H = 0x9D5 + SYS___CATANH_B = 0x9CE + SYS___CATANH_H = 0x9CF + SYS___CATANL_B = 0x9CB + SYS___CATANL_H = 0x9CC + SYS___CATAN_B = 0x9C5 + SYS___CATAN_H = 0x9C6 + SYS___CCOSF_B = 0x9DA + SYS___CCOSF_H = 0x9DB + SYS___CCOSHF_B = 0x9E3 + SYS___CCOSHF_H = 0x9E4 + SYS___CCOSHL_B = 0x9E6 + SYS___CCOSHL_H = 0x9E7 + SYS___CCOSH_B = 0x9E0 + SYS___CCOSH_H = 0x9E1 + SYS___CCOSL_B = 0x9DD + SYS___CCOSL_H = 0x9DE + SYS___CCOS_B = 0x9D7 + SYS___CCOS_H = 0x9D8 + SYS___CEXPF_B = 0x9EC + SYS___CEXPF_H = 0x9ED + SYS___CEXPL_B = 0x9EF + SYS___CEXPL_H = 0x9F0 + SYS___CEXP_B = 0x9E9 + SYS___CEXP_H = 0x9EA + SYS___CIMAGF_B = 0x9F5 + SYS___CIMAGF_H = 0x9F6 + SYS___CIMAGL_B = 0x9F8 + SYS___CIMAGL_H = 0x9F9 + SYS___CIMAG_B = 0x9F2 + SYS___CIMAG_H = 0x9F3 + SYS___CLOG = 0x9FA + SYS___CLOGF_B = 0x9FE + SYS___CLOGF_H = 0x9FF + SYS___CLOG_B = 0x9FB + SYS___CLOG_H = 0x9FC + SYS_ISWCTYPE = 0x10C + SYS_ISWXDIGI = 0x10A + SYS_ISWXDIGIT = 0x10A + SYS_MBSINIT = 0x10F + SYS_TOWLOWER = 0x10D + SYS_TOWUPPER = 0x10E + SYS_WCTYPE = 0x10B + SYS_WCSSTR = 0x11B + SYS___RPMTCH = 0x11A + SYS_WCSTOD = 0x12E + SYS_WCSTOK = 0x12C + SYS_WCSTOL = 0x12D + SYS_WCSTOUL = 0x12F + SYS_FGETWC = 0x13C + SYS_FGETWS = 0x13D + SYS_FPUTWC = 0x13E + SYS_FPUTWS = 0x13F + SYS_REGERROR = 0x13B + SYS_REGFREE = 0x13A + SYS_COLLEQUIV = 0x14F + SYS_COLLTOSTR = 0x14E + SYS_ISMCCOLLEL = 0x14C + SYS_STRTOCOLL = 0x14D + SYS_DLLFREE = 0x16F + SYS_DLLQUERYFN = 0x16D + SYS_DLLQUERYVAR = 0x16E + SYS_GETMCCOLL = 0x16A + SYS_GETWMCCOLL = 0x16B + SYS___ERR2AD = 0x16C + SYS_CFSETOSPEED = 0x17A + SYS_CHDIR = 0x17B + SYS_CHMOD = 0x17C + SYS_CHOWN = 0x17D + SYS_CLOSE = 0x17E + SYS_CLOSEDIR = 0x17F + SYS_LOG = 0x017 + SYS_COSH = 0x018 + SYS_FCHMOD = 0x18A + SYS_FCHOWN = 0x18B + SYS_FCNTL = 0x18C + SYS_FILENO = 0x18D + SYS_FORK = 0x18E + SYS_FPATHCONF = 0x18F + SYS_GETLOGIN = 0x19A + SYS_GETPGRP = 0x19C + SYS_GETPID = 0x19D + SYS_GETPPID = 0x19E + SYS_GETPWNAM = 0x19F + SYS_TANH = 0x019 + SYS_W_GETMNTENT = 0x19B + SYS_POW = 0x020 + SYS_PTHREAD_SELF = 0x20A + SYS_PTHREAD_SETINTR = 0x20B + SYS_PTHREAD_SETINTRTYPE = 0x20C + SYS_PTHREAD_SETSPECIFIC = 0x20D + SYS_PTHREAD_TESTINTR = 0x20E + SYS_PTHREAD_YIELD = 0x20F + SYS_SQRT = 0x021 + SYS_FLOOR = 0x022 + SYS_J1 = 0x023 + SYS_WCSPBRK = 0x23F + SYS_BSEARCH = 0x24C + SYS_FABS = 0x024 + SYS_GETENV = 0x24A + SYS_LDIV = 0x24D + SYS_SYSTEM = 0x24B + SYS_FMOD = 0x025 + SYS___RETHROW = 0x25F + SYS___THROW = 0x25E + SYS_J0 = 0x026 + SYS_PUTENV = 0x26A + SYS___GETENV = 0x26F + SYS_SEMCTL = 0x27A + SYS_SEMGET = 0x27B + SYS_SEMOP = 0x27C + SYS_SHMAT = 0x27D + SYS_SHMCTL = 0x27E + SYS_SHMDT = 0x27F + SYS_YN = 0x027 + SYS_JN = 0x028 + SYS_SIGALTSTACK = 0x28A + SYS_SIGHOLD = 0x28B + SYS_SIGIGNORE = 0x28C + SYS_SIGINTERRUPT = 0x28D + SYS_SIGPAUSE = 0x28E + SYS_SIGRELSE = 0x28F + SYS_GETOPT = 0x29A + SYS_GETSUBOPT = 0x29D + SYS_LCHOWN = 0x29B + SYS_SETPGRP = 0x29E + SYS_TRUNCATE = 0x29C + SYS_Y0 = 0x029 + SYS___GDERR = 0x29F + SYS_ISALPHA = 0x030 + SYS_VFORK = 0x30F + SYS__LONGJMP = 0x30D + SYS__SETJMP = 0x30E + SYS_GLOB = 0x31A + SYS_GLOBFREE = 0x31B + SYS_ISALNUM = 0x031 + SYS_PUTW = 0x31C + SYS_SEEKDIR = 0x31D + SYS_TELLDIR = 0x31E + SYS_TEMPNAM = 0x31F + SYS_GETTIMEOFDAY_R = 0x32E + SYS_ISLOWER = 0x032 + SYS_LGAMMA = 0x32C + SYS_REMAINDER = 0x32A + SYS_SCALB = 0x32B + SYS_SYNC = 0x32F + SYS_TTYSLOT = 0x32D + SYS_ENDPROTOENT = 0x33A + SYS_ENDSERVENT = 0x33B + SYS_GETHOSTBYADDR = 0x33D + SYS_GETHOSTBYADDR_R = 0x33C + SYS_GETHOSTBYNAME = 0x33F + SYS_GETHOSTBYNAME_R = 0x33E + SYS_ISCNTRL = 0x033 + SYS_GETSERVBYNAME = 0x34A + SYS_GETSERVBYPORT = 0x34B + SYS_GETSERVENT = 0x34C + SYS_GETSOCKNAME = 0x34D + SYS_GETSOCKOPT = 0x34E + SYS_INET_ADDR = 0x34F + SYS_ISDIGIT = 0x034 + SYS_ISGRAPH = 0x035 + SYS_SELECT = 0x35B + SYS_SELECTEX = 0x35C + SYS_SEND = 0x35D + SYS_SENDTO = 0x35F + SYS_CHROOT = 0x36A + SYS_ISNAN = 0x36D + SYS_ISUPPER = 0x036 + SYS_ULIMIT = 0x36C + SYS_UTIMES = 0x36E + SYS_W_STATVFS = 0x36B + SYS___H_ERRNO = 0x36F + SYS_GRANTPT = 0x37A + SYS_ISPRINT = 0x037 + SYS_TCGETSID = 0x37C + SYS_UNLOCKPT = 0x37B + SYS___TCGETCP = 0x37D + SYS___TCSETCP = 0x37E + SYS___TCSETTABLES = 0x37F + SYS_ISPUNCT = 0x038 + SYS_NLIST = 0x38C + SYS___IPDBCS = 0x38D + SYS___IPDSPX = 0x38E + SYS___IPMSGC = 0x38F + SYS___STHOSTENT = 0x38B + SYS___STSERVENT = 0x38A + SYS_ISSPACE = 0x039 + SYS_COS = 0x040 + SYS_T_ALLOC = 0x40A + SYS_T_BIND = 0x40B + SYS_T_CLOSE = 0x40C + SYS_T_CONNECT = 0x40D + SYS_T_ERROR = 0x40E + SYS_T_FREE = 0x40F + SYS_TAN = 0x041 + SYS_T_RCVREL = 0x41A + SYS_T_RCVUDATA = 0x41B + SYS_T_RCVUDERR = 0x41C + SYS_T_SND = 0x41D + SYS_T_SNDDIS = 0x41E + SYS_T_SNDREL = 0x41F + SYS_GETPMSG = 0x42A + SYS_ISASTREAM = 0x42B + SYS_PUTMSG = 0x42C + SYS_PUTPMSG = 0x42D + SYS_SINH = 0x042 + SYS___ISPOSIXON = 0x42E + SYS___OPENMVSREL = 0x42F + SYS_ACOS = 0x043 + SYS_ATAN = 0x044 + SYS_ATAN2 = 0x045 + SYS_FTELL = 0x046 + SYS_FGETPOS = 0x047 + SYS_SOCK_DEBUG = 0x47A + SYS_SOCK_DO_TESTSTOR = 0x47D + SYS_TAKESOCKET = 0x47E + SYS___SERVER_INIT = 0x47F + SYS_FSEEK = 0x048 + SYS___IPHOST = 0x48B + SYS___IPNODE = 0x48C + SYS___SERVER_CLASSIFY_CREATE = 0x48D + SYS___SERVER_CLASSIFY_DESTROY = 0x48E + SYS___SERVER_CLASSIFY_RESET = 0x48F + SYS___SMF_RECORD = 0x48A + SYS_FSETPOS = 0x049 + SYS___FNWSA = 0x49B + SYS___SPAWN2 = 0x49D + SYS___SPAWNP2 = 0x49E + SYS_ATOF = 0x050 + SYS_PTHREAD_MUTEXATTR_GETPSHARED = 0x50A + SYS_PTHREAD_MUTEXATTR_SETPSHARED = 0x50B + SYS_PTHREAD_RWLOCK_DESTROY = 0x50C + SYS_PTHREAD_RWLOCK_INIT = 0x50D + SYS_PTHREAD_RWLOCK_RDLOCK = 0x50E + SYS_PTHREAD_RWLOCK_TRYRDLOCK = 0x50F + SYS_ATOI = 0x051 + SYS___FP_CLASS = 0x51D + SYS___FP_CLR_FLAG = 0x51A + SYS___FP_FINITE = 0x51E + SYS___FP_ISNAN = 0x51F + SYS___FP_RAISE_XCP = 0x51C + SYS___FP_READ_FLAG = 0x51B + SYS_RAND = 0x052 + SYS_SIGTIMEDWAIT = 0x52D + SYS_SIGWAITINFO = 0x52E + SYS___CHKBFP = 0x52F + SYS___FPC_RS = 0x52C + SYS___FPC_RW = 0x52A + SYS___FPC_SM = 0x52B + SYS_STRTOD = 0x053 + SYS_STRTOL = 0x054 + SYS_STRTOUL = 0x055 + SYS_MALLOC = 0x056 + SYS_SRAND = 0x057 + SYS_CALLOC = 0x058 + SYS_FREE = 0x059 + SYS___OSENV = 0x59F + SYS___W_PIOCTL = 0x59E + SYS_LONGJMP = 0x060 + SYS___FLOORF_B = 0x60A + SYS___FLOORL_B = 0x60B + SYS___FREXPF_B = 0x60C + SYS___FREXPL_B = 0x60D + SYS___LDEXPF_B = 0x60E + SYS___LDEXPL_B = 0x60F + SYS_SIGNAL = 0x061 + SYS___ATAN2F_B = 0x61A + SYS___ATAN2L_B = 0x61B + SYS___COSHF_B = 0x61C + SYS___COSHL_B = 0x61D + SYS___EXPF_B = 0x61E + SYS___EXPL_B = 0x61F + SYS_TMPNAM = 0x062 + SYS___ABSF_B = 0x62A + SYS___ABSL_B = 0x62C + SYS___ABS_B = 0x62B + SYS___FMODF_B = 0x62D + SYS___FMODL_B = 0x62E + SYS___MODFF_B = 0x62F + SYS_ATANL = 0x63A + SYS_CEILF = 0x63B + SYS_CEILL = 0x63C + SYS_COSF = 0x63D + SYS_COSHF = 0x63F + SYS_COSL = 0x63E + SYS_REMOVE = 0x063 + SYS_POWL = 0x64A + SYS_RENAME = 0x064 + SYS_SINF = 0x64B + SYS_SINHF = 0x64F + SYS_SINL = 0x64C + SYS_SQRTF = 0x64D + SYS_SQRTL = 0x64E + SYS_BTOWC = 0x65F + SYS_FREXPL = 0x65A + SYS_LDEXPF = 0x65B + SYS_LDEXPL = 0x65C + SYS_MODFF = 0x65D + SYS_MODFL = 0x65E + SYS_TMPFILE = 0x065 + SYS_FREOPEN = 0x066 + SYS___CHARMAP_INIT_A = 0x66E + SYS___GETHOSTBYADDR_R_A = 0x66C + SYS___GETHOSTBYNAME_A = 0x66A + SYS___GETHOSTBYNAME_R_A = 0x66D + SYS___MBLEN_A = 0x66F + SYS___RES_INIT_A = 0x66B + SYS_FCLOSE = 0x067 + SYS___GETGRGID_R_A = 0x67D + SYS___WCSTOMBS_A = 0x67A + SYS___WCSTOMBS_STD_A = 0x67B + SYS___WCSWIDTH_A = 0x67C + SYS___WCSWIDTH_ASIA = 0x67F + SYS___WCSWIDTH_STD_A = 0x67E + SYS_FFLUSH = 0x068 + SYS___GETLOGIN_R_A = 0x68E + SYS___GETPWNAM_R_A = 0x68C + SYS___GETPWUID_R_A = 0x68D + SYS___TTYNAME_R_A = 0x68F + SYS___WCWIDTH_ASIA = 0x68B + SYS___WCWIDTH_STD_A = 0x68A + SYS_FOPEN = 0x069 + SYS___REGEXEC_A = 0x69A + SYS___REGEXEC_STD_A = 0x69B + SYS___REGFREE_A = 0x69C + SYS___REGFREE_STD_A = 0x69D + SYS___STRCOLL_A = 0x69E + SYS___STRCOLL_C_A = 0x69F + SYS_SCANF = 0x070 + SYS___A64L_A = 0x70C + SYS___ECVT_A = 0x70D + SYS___FCVT_A = 0x70E + SYS___GCVT_A = 0x70F + SYS___STRTOUL_A = 0x70A + SYS_____AE_CORRESTBL_QUERY_A = 0x70B + SYS_SPRINTF = 0x071 + SYS___ACCESS_A = 0x71F + SYS___CATOPEN_A = 0x71E + SYS___GETOPT_A = 0x71D + SYS___REALPATH_A = 0x71A + SYS___SETENV_A = 0x71B + SYS___SYSTEM_A = 0x71C + SYS_FGETC = 0x072 + SYS___GAI_STRERROR_A = 0x72F + SYS___RMDIR_A = 0x72A + SYS___STATVFS_A = 0x72B + SYS___SYMLINK_A = 0x72C + SYS___TRUNCATE_A = 0x72D + SYS___UNLINK_A = 0x72E + SYS_VFPRINTF = 0x073 + SYS___ISSPACE_A = 0x73A + SYS___ISUPPER_A = 0x73B + SYS___ISWALNUM_A = 0x73F + SYS___ISXDIGIT_A = 0x73C + SYS___TOLOWER_A = 0x73D + SYS___TOUPPER_A = 0x73E + SYS_VPRINTF = 0x074 + SYS___CONFSTR_A = 0x74B + SYS___FDOPEN_A = 0x74E + SYS___FLDATA_A = 0x74F + SYS___FTOK_A = 0x74C + SYS___ISWXDIGIT_A = 0x74A + SYS___MKTEMP_A = 0x74D + SYS_VSPRINTF = 0x075 + SYS___GETGRGID_A = 0x75A + SYS___GETGRNAM_A = 0x75B + SYS___GETGROUPSBYNAME_A = 0x75C + SYS___GETHOSTENT_A = 0x75D + SYS___GETHOSTNAME_A = 0x75E + SYS___GETLOGIN_A = 0x75F + SYS_GETC = 0x076 + SYS___CREATEWORKUNIT_A = 0x76A + SYS___CTERMID_A = 0x76B + SYS___FMTMSG_A = 0x76C + SYS___INITGROUPS_A = 0x76D + SYS___MSGRCV_A = 0x76F + SYS_____LOGIN_A = 0x76E + SYS_FGETS = 0x077 + SYS___STRCASECMP_A = 0x77B + SYS___STRNCASECMP_A = 0x77C + SYS___TTYNAME_A = 0x77D + SYS___UNAME_A = 0x77E + SYS___UTIMES_A = 0x77F + SYS_____SERVER_PWU_A = 0x77A + SYS_FPUTC = 0x078 + SYS___CREAT_O_A = 0x78E + SYS___ENVNA = 0x78F + SYS___FREAD_A = 0x78A + SYS___FWRITE_A = 0x78B + SYS___ISASCII = 0x78D + SYS___OPEN_O_A = 0x78C + SYS_FPUTS = 0x079 + SYS___ASCTIME_A = 0x79C + SYS___CTIME_A = 0x79D + SYS___GETDATE_A = 0x79E + SYS___GETSERVBYPORT_A = 0x79A + SYS___GETSERVENT_A = 0x79B + SYS___TZSET_A = 0x79F + SYS_ACL_FROM_TEXT = 0x80C + SYS_ACL_SET_FD = 0x80A + SYS_ACL_SET_FILE = 0x80B + SYS_ACL_SORT = 0x80E + SYS_ACL_TO_TEXT = 0x80D + SYS_UNGETC = 0x080 + SYS___SHUTDOWN_REGISTRATION = 0x80F + SYS_FREAD = 0x081 + SYS_FREEADDRINFO = 0x81A + SYS_GAI_STRERROR = 0x81B + SYS_REXEC_AF = 0x81C + SYS___DYNALLOC_A = 0x81F + SYS___POE = 0x81D + SYS_WCSTOMBS = 0x082 + SYS___INET_ADDR_A = 0x82F + SYS___NLIST_A = 0x82A + SYS_____TCGETCP_A = 0x82B + SYS_____TCSETCP_A = 0x82C + SYS_____W_PIOCTL_A = 0x82E + SYS_MBTOWC = 0x083 + SYS___CABEND = 0x83D + SYS___LE_CIB_GET = 0x83E + SYS___RECVMSG_A = 0x83B + SYS___SENDMSG_A = 0x83A + SYS___SET_LAA_FOR_JIT = 0x83F + SYS_____LCHATTR_A = 0x83C + SYS_WCTOMB = 0x084 + SYS___CBRTL_B = 0x84A + SYS___COPYSIGNF_B = 0x84B + SYS___COPYSIGNL_B = 0x84C + SYS___COTANF_B = 0x84D + SYS___COTANL_B = 0x84F + SYS___COTAN_B = 0x84E + SYS_MBSTOWCS = 0x085 + SYS___LOG1PL_B = 0x85A + SYS___LOG2F_B = 0x85B + SYS___LOG2L_B = 0x85D + SYS___LOG2_B = 0x85C + SYS___REMAINDERF_B = 0x85E + SYS___REMAINDERL_B = 0x85F + SYS_ACOSHF = 0x86E + SYS_ACOSHL = 0x86F + SYS_WCSCPY = 0x086 + SYS___ERFCF_B = 0x86D + SYS___ERFF_B = 0x86C + SYS___LROUNDF_B = 0x86A + SYS___LROUND_B = 0x86B + SYS_COTANL = 0x87A + SYS_EXP2F = 0x87B + SYS_EXP2L = 0x87C + SYS_EXPM1F = 0x87D + SYS_EXPM1L = 0x87E + SYS_FDIMF = 0x87F + SYS_WCSCAT = 0x087 + SYS___COTANL = 0x87A + SYS_REMAINDERF = 0x88A + SYS_REMAINDERL = 0x88B + SYS_REMAINDF = 0x88A + SYS_REMAINDL = 0x88B + SYS_REMQUO = 0x88D + SYS_REMQUOF = 0x88C + SYS_REMQUOL = 0x88E + SYS_TGAMMAF = 0x88F + SYS_WCSCHR = 0x088 + SYS_ERFCF = 0x89B + SYS_ERFCL = 0x89C + SYS_ERFL = 0x89A + SYS_EXP2 = 0x89E + SYS_WCSCMP = 0x089 + SYS___EXP2_B = 0x89D + SYS___FAR_JUMP = 0x89F + SYS_ABS = 0x090 + SYS___ERFCL_H = 0x90A + SYS___EXPF_H = 0x90C + SYS___EXPL_H = 0x90D + SYS___EXPM1_H = 0x90E + SYS___EXP_H = 0x90B + SYS___FDIM_H = 0x90F + SYS_DIV = 0x091 + SYS___LOG2F_H = 0x91F + SYS___LOG2_H = 0x91E + SYS___LOGB_H = 0x91D + SYS___LOGF_H = 0x91B + SYS___LOGL_H = 0x91C + SYS___LOG_H = 0x91A + SYS_LABS = 0x092 + SYS___POWL_H = 0x92A + SYS___REMAINDER_H = 0x92B + SYS___RINT_H = 0x92C + SYS___SCALB_H = 0x92D + SYS___SINF_H = 0x92F + SYS___SIN_H = 0x92E + SYS_STRNCPY = 0x093 + SYS___TANHF_H = 0x93B + SYS___TANHL_H = 0x93C + SYS___TANH_H = 0x93A + SYS___TGAMMAF_H = 0x93E + SYS___TGAMMA_H = 0x93D + SYS___TRUNC_H = 0x93F + SYS_MEMCPY = 0x094 + SYS_VFWSCANF = 0x94A + SYS_VSWSCANF = 0x94E + SYS_VWSCANF = 0x94C + SYS_INET6_RTH_ADD = 0x95D + SYS_INET6_RTH_INIT = 0x95C + SYS_INET6_RTH_REVERSE = 0x95E + SYS_INET6_RTH_SEGMENTS = 0x95F + SYS_INET6_RTH_SPACE = 0x95B + SYS_MEMMOVE = 0x095 + SYS_WCSTOLD = 0x95A + SYS_STRCPY = 0x096 + SYS_STRCMP = 0x097 + SYS_CABS = 0x98E + SYS_STRCAT = 0x098 + SYS___CABS_B = 0x98F + SYS___POW_II = 0x98A + SYS___POW_II_B = 0x98B + SYS___POW_II_H = 0x98C + SYS_CACOSF = 0x99A + SYS_CACOSL = 0x99D + SYS_STRNCAT = 0x099 + SYS___CACOSF_B = 0x99B + SYS___CACOSF_H = 0x99C + SYS___CACOSL_B = 0x99E + SYS___CACOSL_H = 0x99F + SYS_ISWALPHA = 0x100 + SYS_ISWBLANK = 0x101 + SYS___ISWBLK = 0x101 + SYS_ISWCNTRL = 0x102 + SYS_ISWDIGIT = 0x103 + SYS_ISWGRAPH = 0x104 + SYS_ISWLOWER = 0x105 + SYS_ISWPRINT = 0x106 + SYS_ISWPUNCT = 0x107 + SYS_ISWSPACE = 0x108 + SYS_ISWUPPER = 0x109 + SYS_WCTOB = 0x110 + SYS_MBRLEN = 0x111 + SYS_MBRTOWC = 0x112 + SYS_MBSRTOWC = 0x113 + SYS_MBSRTOWCS = 0x113 + SYS_WCRTOMB = 0x114 + SYS_WCSRTOMB = 0x115 + SYS_WCSRTOMBS = 0x115 + SYS___CSID = 0x116 + SYS___WCSID = 0x117 + SYS_STRPTIME = 0x118 + SYS___STRPTM = 0x118 + SYS_STRFMON = 0x119 + SYS_WCSCOLL = 0x130 + SYS_WCSXFRM = 0x131 + SYS_WCSWIDTH = 0x132 + SYS_WCWIDTH = 0x133 + SYS_WCSFTIME = 0x134 + SYS_SWPRINTF = 0x135 + SYS_VSWPRINT = 0x136 + SYS_VSWPRINTF = 0x136 + SYS_SWSCANF = 0x137 + SYS_REGCOMP = 0x138 + SYS_REGEXEC = 0x139 + SYS_GETWC = 0x140 + SYS_GETWCHAR = 0x141 + SYS_PUTWC = 0x142 + SYS_PUTWCHAR = 0x143 + SYS_UNGETWC = 0x144 + SYS_ICONV_OPEN = 0x145 + SYS_ICONV = 0x146 + SYS_ICONV_CLOSE = 0x147 + SYS_COLLRANGE = 0x150 + SYS_CCLASS = 0x151 + SYS_COLLORDER = 0x152 + SYS___DEMANGLE = 0x154 + SYS_FDOPEN = 0x155 + SYS___ERRNO = 0x156 + SYS___ERRNO2 = 0x157 + SYS___TERROR = 0x158 + SYS_MAXCOLL = 0x169 + SYS_DLLLOAD = 0x170 + SYS__EXIT = 0x174 + SYS_ACCESS = 0x175 + SYS_ALARM = 0x176 + SYS_CFGETISPEED = 0x177 + SYS_CFGETOSPEED = 0x178 + SYS_CFSETISPEED = 0x179 + SYS_CREAT = 0x180 + SYS_CTERMID = 0x181 + SYS_DUP = 0x182 + SYS_DUP2 = 0x183 + SYS_EXECL = 0x184 + SYS_EXECLE = 0x185 + SYS_EXECLP = 0x186 + SYS_EXECV = 0x187 + SYS_EXECVE = 0x188 + SYS_EXECVP = 0x189 + SYS_FSTAT = 0x190 + SYS_FSYNC = 0x191 + SYS_FTRUNCATE = 0x192 + SYS_GETCWD = 0x193 + SYS_GETEGID = 0x194 + SYS_GETEUID = 0x195 + SYS_GETGID = 0x196 + SYS_GETGRGID = 0x197 + SYS_GETGRNAM = 0x198 + SYS_GETGROUPS = 0x199 + SYS_PTHREAD_MUTEXATTR_DESTROY = 0x200 + SYS_PTHREAD_MUTEXATTR_SETKIND_NP = 0x201 + SYS_PTHREAD_MUTEXATTR_GETKIND_NP = 0x202 + SYS_PTHREAD_MUTEX_INIT = 0x203 + SYS_PTHREAD_MUTEX_DESTROY = 0x204 + SYS_PTHREAD_MUTEX_LOCK = 0x205 + SYS_PTHREAD_MUTEX_TRYLOCK = 0x206 + SYS_PTHREAD_MUTEX_UNLOCK = 0x207 + SYS_PTHREAD_ONCE = 0x209 + SYS_TW_OPEN = 0x210 + SYS_TW_FCNTL = 0x211 + SYS_PTHREAD_JOIN_D4_NP = 0x212 + SYS_PTHREAD_CONDATTR_SETKIND_NP = 0x213 + SYS_PTHREAD_CONDATTR_GETKIND_NP = 0x214 + SYS_EXTLINK_NP = 0x215 + SYS___PASSWD = 0x216 + SYS_SETGROUPS = 0x217 + SYS_INITGROUPS = 0x218 + SYS_WCSRCHR = 0x240 + SYS_SVC99 = 0x241 + SYS___SVC99 = 0x241 + SYS_WCSWCS = 0x242 + SYS_LOCALECO = 0x243 + SYS_LOCALECONV = 0x243 + SYS___LIBREL = 0x244 + SYS_RELEASE = 0x245 + SYS___RLSE = 0x245 + SYS_FLOCATE = 0x246 + SYS___FLOCT = 0x246 + SYS_FDELREC = 0x247 + SYS___FDLREC = 0x247 + SYS_FETCH = 0x248 + SYS___FETCH = 0x248 + SYS_QSORT = 0x249 + SYS___CLEANUPCATCH = 0x260 + SYS___CATCHMATCH = 0x261 + SYS___CLEAN2UPCATCH = 0x262 + SYS_GETPRIORITY = 0x270 + SYS_NICE = 0x271 + SYS_SETPRIORITY = 0x272 + SYS_GETITIMER = 0x273 + SYS_SETITIMER = 0x274 + SYS_MSGCTL = 0x275 + SYS_MSGGET = 0x276 + SYS_MSGRCV = 0x277 + SYS_MSGSND = 0x278 + SYS_MSGXRCV = 0x279 + SYS___MSGXR = 0x279 + SYS_SHMGET = 0x280 + SYS___GETIPC = 0x281 + SYS_SETGRENT = 0x282 + SYS_GETGRENT = 0x283 + SYS_ENDGRENT = 0x284 + SYS_SETPWENT = 0x285 + SYS_GETPWENT = 0x286 + SYS_ENDPWENT = 0x287 + SYS_BSD_SIGNAL = 0x288 + SYS_KILLPG = 0x289 + SYS_SIGSET = 0x290 + SYS_SIGSTACK = 0x291 + SYS_GETRLIMIT = 0x292 + SYS_SETRLIMIT = 0x293 + SYS_GETRUSAGE = 0x294 + SYS_MMAP = 0x295 + SYS_MPROTECT = 0x296 + SYS_MSYNC = 0x297 + SYS_MUNMAP = 0x298 + SYS_CONFSTR = 0x299 + SYS___NDMTRM = 0x300 + SYS_FTOK = 0x301 + SYS_BASENAME = 0x302 + SYS_DIRNAME = 0x303 + SYS_GETDTABLESIZE = 0x304 + SYS_MKSTEMP = 0x305 + SYS_MKTEMP = 0x306 + SYS_NFTW = 0x307 + SYS_GETWD = 0x308 + SYS_LOCKF = 0x309 + SYS_WORDEXP = 0x310 + SYS_WORDFREE = 0x311 + SYS_GETPGID = 0x312 + SYS_GETSID = 0x313 + SYS___UTMPXNAME = 0x314 + SYS_CUSERID = 0x315 + SYS_GETPASS = 0x316 + SYS_FNMATCH = 0x317 + SYS_FTW = 0x318 + SYS_GETW = 0x319 + SYS_ACOSH = 0x320 + SYS_ASINH = 0x321 + SYS_ATANH = 0x322 + SYS_CBRT = 0x323 + SYS_EXPM1 = 0x324 + SYS_ILOGB = 0x325 + SYS_LOGB = 0x326 + SYS_LOG1P = 0x327 + SYS_NEXTAFTER = 0x328 + SYS_RINT = 0x329 + SYS_SPAWN = 0x330 + SYS_SPAWNP = 0x331 + SYS_GETLOGIN_UU = 0x332 + SYS_ECVT = 0x333 + SYS_FCVT = 0x334 + SYS_GCVT = 0x335 + SYS_ACCEPT = 0x336 + SYS_BIND = 0x337 + SYS_CONNECT = 0x338 + SYS_ENDHOSTENT = 0x339 + SYS_GETHOSTENT = 0x340 + SYS_GETHOSTID = 0x341 + SYS_GETHOSTNAME = 0x342 + SYS_GETNETBYADDR = 0x343 + SYS_GETNETBYNAME = 0x344 + SYS_GETNETENT = 0x345 + SYS_GETPEERNAME = 0x346 + SYS_GETPROTOBYNAME = 0x347 + SYS_GETPROTOBYNUMBER = 0x348 + SYS_GETPROTOENT = 0x349 + SYS_INET_LNAOF = 0x350 + SYS_INET_MAKEADDR = 0x351 + SYS_INET_NETOF = 0x352 + SYS_INET_NETWORK = 0x353 + SYS_INET_NTOA = 0x354 + SYS_IOCTL = 0x355 + SYS_LISTEN = 0x356 + SYS_READV = 0x357 + SYS_RECV = 0x358 + SYS_RECVFROM = 0x359 + SYS_SETHOSTENT = 0x360 + SYS_SETNETENT = 0x361 + SYS_SETPEER = 0x362 + SYS_SETPROTOENT = 0x363 + SYS_SETSERVENT = 0x364 + SYS_SETSOCKOPT = 0x365 + SYS_SHUTDOWN = 0x366 + SYS_SOCKET = 0x367 + SYS_SOCKETPAIR = 0x368 + SYS_WRITEV = 0x369 + SYS_ENDNETENT = 0x370 + SYS_CLOSELOG = 0x371 + SYS_OPENLOG = 0x372 + SYS_SETLOGMASK = 0x373 + SYS_SYSLOG = 0x374 + SYS_PTSNAME = 0x375 + SYS_SETREUID = 0x376 + SYS_SETREGID = 0x377 + SYS_REALPATH = 0x378 + SYS___SIGNGAM = 0x379 + SYS_POLL = 0x380 + SYS_REXEC = 0x381 + SYS___ISASCII2 = 0x382 + SYS___TOASCII2 = 0x383 + SYS_CHPRIORITY = 0x384 + SYS_PTHREAD_ATTR_SETSYNCTYPE_NP = 0x385 + SYS_PTHREAD_ATTR_GETSYNCTYPE_NP = 0x386 + SYS_PTHREAD_SET_LIMIT_NP = 0x387 + SYS___STNETENT = 0x388 + SYS___STPROTOENT = 0x389 + SYS___SELECT1 = 0x390 + SYS_PTHREAD_SECURITY_NP = 0x391 + SYS___CHECK_RESOURCE_AUTH_NP = 0x392 + SYS___CONVERT_ID_NP = 0x393 + SYS___OPENVMREL = 0x394 + SYS_WMEMCHR = 0x395 + SYS_WMEMCMP = 0x396 + SYS_WMEMCPY = 0x397 + SYS_WMEMMOVE = 0x398 + SYS_WMEMSET = 0x399 + SYS___FPUTWC = 0x400 + SYS___PUTWC = 0x401 + SYS___PWCHAR = 0x402 + SYS___WCSFTM = 0x403 + SYS___WCSTOK = 0x404 + SYS___WCWDTH = 0x405 + SYS_T_ACCEPT = 0x409 + SYS_T_GETINFO = 0x410 + SYS_T_GETPROTADDR = 0x411 + SYS_T_GETSTATE = 0x412 + SYS_T_LISTEN = 0x413 + SYS_T_LOOK = 0x414 + SYS_T_OPEN = 0x415 + SYS_T_OPTMGMT = 0x416 + SYS_T_RCV = 0x417 + SYS_T_RCVCONNECT = 0x418 + SYS_T_RCVDIS = 0x419 + SYS_T_SNDUDATA = 0x420 + SYS_T_STRERROR = 0x421 + SYS_T_SYNC = 0x422 + SYS_T_UNBIND = 0x423 + SYS___T_ERRNO = 0x424 + SYS___RECVMSG2 = 0x425 + SYS___SENDMSG2 = 0x426 + SYS_FATTACH = 0x427 + SYS_FDETACH = 0x428 + SYS_GETMSG = 0x429 + SYS_GETCONTEXT = 0x430 + SYS_SETCONTEXT = 0x431 + SYS_MAKECONTEXT = 0x432 + SYS_SWAPCONTEXT = 0x433 + SYS_PTHREAD_GETSPECIFIC_D8_NP = 0x434 + SYS_GETCLIENTID = 0x470 + SYS___GETCLIENTID = 0x471 + SYS_GETSTABLESIZE = 0x472 + SYS_GETIBMOPT = 0x473 + SYS_GETIBMSOCKOPT = 0x474 + SYS_GIVESOCKET = 0x475 + SYS_IBMSFLUSH = 0x476 + SYS_MAXDESC = 0x477 + SYS_SETIBMOPT = 0x478 + SYS_SETIBMSOCKOPT = 0x479 + SYS___SERVER_PWU = 0x480 + SYS_PTHREAD_TAG_NP = 0x481 + SYS___CONSOLE = 0x482 + SYS___WSINIT = 0x483 + SYS___IPTCPN = 0x489 + SYS___SERVER_CLASSIFY = 0x490 + SYS___HEAPRPT = 0x496 + SYS___ISBFP = 0x500 + SYS___FP_CAST = 0x501 + SYS___CERTIFICATE = 0x502 + SYS_SEND_FILE = 0x503 + SYS_AIO_CANCEL = 0x504 + SYS_AIO_ERROR = 0x505 + SYS_AIO_READ = 0x506 + SYS_AIO_RETURN = 0x507 + SYS_AIO_SUSPEND = 0x508 + SYS_AIO_WRITE = 0x509 + SYS_PTHREAD_RWLOCK_TRYWRLOCK = 0x510 + SYS_PTHREAD_RWLOCK_UNLOCK = 0x511 + SYS_PTHREAD_RWLOCK_WRLOCK = 0x512 + SYS_PTHREAD_RWLOCKATTR_GETPSHARED = 0x513 + SYS_PTHREAD_RWLOCKATTR_SETPSHARED = 0x514 + SYS_PTHREAD_RWLOCKATTR_INIT = 0x515 + SYS_PTHREAD_RWLOCKATTR_DESTROY = 0x516 + SYS___CTTBL = 0x517 + SYS_PTHREAD_MUTEXATTR_SETTYPE = 0x518 + SYS_PTHREAD_MUTEXATTR_GETTYPE = 0x519 + SYS___FP_UNORDERED = 0x520 + SYS___FP_READ_RND = 0x521 + SYS___FP_READ_RND_B = 0x522 + SYS___FP_SWAP_RND = 0x523 + SYS___FP_SWAP_RND_B = 0x524 + SYS___FP_LEVEL = 0x525 + SYS___FP_BTOH = 0x526 + SYS___FP_HTOB = 0x527 + SYS___FPC_RD = 0x528 + SYS___FPC_WR = 0x529 + SYS_PTHREAD_SETCANCELTYPE = 0x600 + SYS_PTHREAD_TESTCANCEL = 0x601 + SYS___ATANF_B = 0x602 + SYS___ATANL_B = 0x603 + SYS___CEILF_B = 0x604 + SYS___CEILL_B = 0x605 + SYS___COSF_B = 0x606 + SYS___COSL_B = 0x607 + SYS___FABSF_B = 0x608 + SYS___FABSL_B = 0x609 + SYS___SINF_B = 0x610 + SYS___SINL_B = 0x611 + SYS___TANF_B = 0x612 + SYS___TANL_B = 0x613 + SYS___TANHF_B = 0x614 + SYS___TANHL_B = 0x615 + SYS___ACOSF_B = 0x616 + SYS___ACOSL_B = 0x617 + SYS___ASINF_B = 0x618 + SYS___ASINL_B = 0x619 + SYS___LOGF_B = 0x620 + SYS___LOGL_B = 0x621 + SYS___LOG10F_B = 0x622 + SYS___LOG10L_B = 0x623 + SYS___POWF_B = 0x624 + SYS___POWL_B = 0x625 + SYS___SINHF_B = 0x626 + SYS___SINHL_B = 0x627 + SYS___SQRTF_B = 0x628 + SYS___SQRTL_B = 0x629 + SYS___MODFL_B = 0x630 + SYS_ABSF = 0x631 + SYS_ABSL = 0x632 + SYS_ACOSF = 0x633 + SYS_ACOSL = 0x634 + SYS_ASINF = 0x635 + SYS_ASINL = 0x636 + SYS_ATAN2F = 0x637 + SYS_ATAN2L = 0x638 + SYS_ATANF = 0x639 + SYS_COSHL = 0x640 + SYS_EXPF = 0x641 + SYS_EXPL = 0x642 + SYS_TANHF = 0x643 + SYS_TANHL = 0x644 + SYS_LOG10F = 0x645 + SYS_LOG10L = 0x646 + SYS_LOGF = 0x647 + SYS_LOGL = 0x648 + SYS_POWF = 0x649 + SYS_SINHL = 0x650 + SYS_TANF = 0x651 + SYS_TANL = 0x652 + SYS_FABSF = 0x653 + SYS_FABSL = 0x654 + SYS_FLOORF = 0x655 + SYS_FLOORL = 0x656 + SYS_FMODF = 0x657 + SYS_FMODL = 0x658 + SYS_FREXPF = 0x659 + SYS___CHATTR = 0x660 + SYS___FCHATTR = 0x661 + SYS___TOCCSID = 0x662 + SYS___CSNAMETYPE = 0x663 + SYS___TOCSNAME = 0x664 + SYS___CCSIDTYPE = 0x665 + SYS___AE_CORRESTBL_QUERY = 0x666 + SYS___AE_AUTOCONVERT_STATE = 0x667 + SYS_DN_FIND = 0x668 + SYS___GETHOSTBYADDR_A = 0x669 + SYS___MBLEN_SB_A = 0x670 + SYS___MBLEN_STD_A = 0x671 + SYS___MBLEN_UTF = 0x672 + SYS___MBSTOWCS_A = 0x673 + SYS___MBSTOWCS_STD_A = 0x674 + SYS___MBTOWC_A = 0x675 + SYS___MBTOWC_ISO1 = 0x676 + SYS___MBTOWC_SBCS = 0x677 + SYS___MBTOWC_MBCS = 0x678 + SYS___MBTOWC_UTF = 0x679 + SYS___CSID_A = 0x680 + SYS___CSID_STD_A = 0x681 + SYS___WCSID_A = 0x682 + SYS___WCSID_STD_A = 0x683 + SYS___WCTOMB_A = 0x684 + SYS___WCTOMB_ISO1 = 0x685 + SYS___WCTOMB_STD_A = 0x686 + SYS___WCTOMB_UTF = 0x687 + SYS___WCWIDTH_A = 0x688 + SYS___GETGRNAM_R_A = 0x689 + SYS___READDIR_R_A = 0x690 + SYS___E2A_S = 0x691 + SYS___FNMATCH_A = 0x692 + SYS___FNMATCH_C_A = 0x693 + SYS___EXECL_A = 0x694 + SYS___FNMATCH_STD_A = 0x695 + SYS___REGCOMP_A = 0x696 + SYS___REGCOMP_STD_A = 0x697 + SYS___REGERROR_A = 0x698 + SYS___REGERROR_STD_A = 0x699 + SYS___SWPRINTF_A = 0x700 + SYS___FSCANF_A = 0x701 + SYS___SCANF_A = 0x702 + SYS___SSCANF_A = 0x703 + SYS___SWSCANF_A = 0x704 + SYS___ATOF_A = 0x705 + SYS___ATOI_A = 0x706 + SYS___ATOL_A = 0x707 + SYS___STRTOD_A = 0x708 + SYS___STRTOL_A = 0x709 + SYS___L64A_A = 0x710 + SYS___STRERROR_A = 0x711 + SYS___PERROR_A = 0x712 + SYS___FETCH_A = 0x713 + SYS___GETENV_A = 0x714 + SYS___MKSTEMP_A = 0x717 + SYS___PTSNAME_A = 0x718 + SYS___PUTENV_A = 0x719 + SYS___CHDIR_A = 0x720 + SYS___CHOWN_A = 0x721 + SYS___CHROOT_A = 0x722 + SYS___GETCWD_A = 0x723 + SYS___GETWD_A = 0x724 + SYS___LCHOWN_A = 0x725 + SYS___LINK_A = 0x726 + SYS___PATHCONF_A = 0x727 + SYS___IF_NAMEINDEX_A = 0x728 + SYS___READLINK_A = 0x729 + SYS___EXTLINK_NP_A = 0x730 + SYS___ISALNUM_A = 0x731 + SYS___ISALPHA_A = 0x732 + SYS___A2E_S = 0x733 + SYS___ISCNTRL_A = 0x734 + SYS___ISDIGIT_A = 0x735 + SYS___ISGRAPH_A = 0x736 + SYS___ISLOWER_A = 0x737 + SYS___ISPRINT_A = 0x738 + SYS___ISPUNCT_A = 0x739 + SYS___ISWALPHA_A = 0x740 + SYS___A2E_L = 0x741 + SYS___ISWCNTRL_A = 0x742 + SYS___ISWDIGIT_A = 0x743 + SYS___ISWGRAPH_A = 0x744 + SYS___ISWLOWER_A = 0x745 + SYS___ISWPRINT_A = 0x746 + SYS___ISWPUNCT_A = 0x747 + SYS___ISWSPACE_A = 0x748 + SYS___ISWUPPER_A = 0x749 + SYS___REMOVE_A = 0x750 + SYS___RENAME_A = 0x751 + SYS___TMPNAM_A = 0x752 + SYS___FOPEN_A = 0x753 + SYS___FREOPEN_A = 0x754 + SYS___CUSERID_A = 0x755 + SYS___POPEN_A = 0x756 + SYS___TEMPNAM_A = 0x757 + SYS___FTW_A = 0x758 + SYS___GETGRENT_A = 0x759 + SYS___INET_NTOP_A = 0x760 + SYS___GETPASS_A = 0x761 + SYS___GETPWENT_A = 0x762 + SYS___GETPWNAM_A = 0x763 + SYS___GETPWUID_A = 0x764 + SYS_____CHECK_RESOURCE_AUTH_NP_A = 0x765 + SYS___CHECKSCHENV_A = 0x766 + SYS___CONNECTSERVER_A = 0x767 + SYS___CONNECTWORKMGR_A = 0x768 + SYS_____CONSOLE_A = 0x769 + SYS___MSGSND_A = 0x770 + SYS___MSGXRCV_A = 0x771 + SYS___NFTW_A = 0x772 + SYS_____PASSWD_A = 0x773 + SYS___PTHREAD_SECURITY_NP_A = 0x774 + SYS___QUERYMETRICS_A = 0x775 + SYS___QUERYSCHENV = 0x776 + SYS___READV_A = 0x777 + SYS_____SERVER_CLASSIFY_A = 0x778 + SYS_____SERVER_INIT_A = 0x779 + SYS___W_GETPSENT_A = 0x780 + SYS___WRITEV_A = 0x781 + SYS___W_STATFS_A = 0x782 + SYS___W_STATVFS_A = 0x783 + SYS___FPUTC_A = 0x784 + SYS___PUTCHAR_A = 0x785 + SYS___PUTS_A = 0x786 + SYS___FGETS_A = 0x787 + SYS___GETS_A = 0x788 + SYS___FPUTS_A = 0x789 + SYS___PUTC_A = 0x790 + SYS___AE_THREAD_SETMODE = 0x791 + SYS___AE_THREAD_SWAPMODE = 0x792 + SYS___GETNETBYADDR_A = 0x793 + SYS___GETNETBYNAME_A = 0x794 + SYS___GETNETENT_A = 0x795 + SYS___GETPROTOBYNAME_A = 0x796 + SYS___GETPROTOBYNUMBER_A = 0x797 + SYS___GETPROTOENT_A = 0x798 + SYS___GETSERVBYNAME_A = 0x799 + SYS_ACL_FIRST_ENTRY = 0x800 + SYS_ACL_GET_ENTRY = 0x801 + SYS_ACL_VALID = 0x802 + SYS_ACL_CREATE_ENTRY = 0x803 + SYS_ACL_DELETE_ENTRY = 0x804 + SYS_ACL_UPDATE_ENTRY = 0x805 + SYS_ACL_DELETE_FD = 0x806 + SYS_ACL_DELETE_FILE = 0x807 + SYS_ACL_GET_FD = 0x808 + SYS_ACL_GET_FILE = 0x809 + SYS___ERFL_B = 0x810 + SYS___ERFCL_B = 0x811 + SYS___LGAMMAL_B = 0x812 + SYS___SETHOOKEVENTS = 0x813 + SYS_IF_NAMETOINDEX = 0x814 + SYS_IF_INDEXTONAME = 0x815 + SYS_IF_NAMEINDEX = 0x816 + SYS_IF_FREENAMEINDEX = 0x817 + SYS_GETADDRINFO = 0x818 + SYS_GETNAMEINFO = 0x819 + SYS___DYNFREE_A = 0x820 + SYS___RES_QUERY_A = 0x821 + SYS___RES_SEARCH_A = 0x822 + SYS___RES_QUERYDOMAIN_A = 0x823 + SYS___RES_MKQUERY_A = 0x824 + SYS___RES_SEND_A = 0x825 + SYS___DN_EXPAND_A = 0x826 + SYS___DN_SKIPNAME_A = 0x827 + SYS___DN_COMP_A = 0x828 + SYS___DN_FIND_A = 0x829 + SYS___INET_NTOA_A = 0x830 + SYS___INET_NETWORK_A = 0x831 + SYS___ACCEPT_A = 0x832 + SYS___ACCEPT_AND_RECV_A = 0x833 + SYS___BIND_A = 0x834 + SYS___CONNECT_A = 0x835 + SYS___GETPEERNAME_A = 0x836 + SYS___GETSOCKNAME_A = 0x837 + SYS___RECVFROM_A = 0x838 + SYS___SENDTO_A = 0x839 + SYS___LCHATTR = 0x840 + SYS___WRITEDOWN = 0x841 + SYS_PTHREAD_MUTEX_INIT2 = 0x842 + SYS___ACOSHF_B = 0x843 + SYS___ACOSHL_B = 0x844 + SYS___ASINHF_B = 0x845 + SYS___ASINHL_B = 0x846 + SYS___ATANHF_B = 0x847 + SYS___ATANHL_B = 0x848 + SYS___CBRTF_B = 0x849 + SYS___EXP2F_B = 0x850 + SYS___EXP2L_B = 0x851 + SYS___EXPM1F_B = 0x852 + SYS___EXPM1L_B = 0x853 + SYS___FDIMF_B = 0x854 + SYS___FDIM_B = 0x855 + SYS___FDIML_B = 0x856 + SYS___HYPOTF_B = 0x857 + SYS___HYPOTL_B = 0x858 + SYS___LOG1PF_B = 0x859 + SYS___REMQUOF_B = 0x860 + SYS___REMQUO_B = 0x861 + SYS___REMQUOL_B = 0x862 + SYS___TGAMMAF_B = 0x863 + SYS___TGAMMA_B = 0x864 + SYS___TGAMMAL_B = 0x865 + SYS___TRUNCF_B = 0x866 + SYS___TRUNC_B = 0x867 + SYS___TRUNCL_B = 0x868 + SYS___LGAMMAF_B = 0x869 + SYS_ASINHF = 0x870 + SYS_ASINHL = 0x871 + SYS_ATANHF = 0x872 + SYS_ATANHL = 0x873 + SYS_CBRTF = 0x874 + SYS_CBRTL = 0x875 + SYS_COPYSIGNF = 0x876 + SYS_CPYSIGNF = 0x876 + SYS_COPYSIGNL = 0x877 + SYS_CPYSIGNL = 0x877 + SYS_COTANF = 0x878 + SYS___COTANF = 0x878 + SYS_COTAN = 0x879 + SYS___COTAN = 0x879 + SYS_FDIM = 0x881 + SYS_FDIML = 0x882 + SYS_HYPOTF = 0x883 + SYS_HYPOTL = 0x884 + SYS_LOG1PF = 0x885 + SYS_LOG1PL = 0x886 + SYS_LOG2F = 0x887 + SYS_LOG2 = 0x888 + SYS_LOG2L = 0x889 + SYS_TGAMMA = 0x890 + SYS_TGAMMAL = 0x891 + SYS_TRUNCF = 0x892 + SYS_TRUNC = 0x893 + SYS_TRUNCL = 0x894 + SYS_LGAMMAF = 0x895 + SYS_LGAMMAL = 0x896 + SYS_LROUNDF = 0x897 + SYS_LROUND = 0x898 + SYS_ERFF = 0x899 + SYS___COSHF_H = 0x900 + SYS___COSHL_H = 0x901 + SYS___COTAN_H = 0x902 + SYS___COTANF_H = 0x903 + SYS___COTANL_H = 0x904 + SYS___ERF_H = 0x905 + SYS___ERFF_H = 0x906 + SYS___ERFL_H = 0x907 + SYS___ERFC_H = 0x908 + SYS___ERFCF_H = 0x909 + SYS___FDIMF_H = 0x910 + SYS___FDIML_H = 0x911 + SYS___FMOD_H = 0x912 + SYS___FMODF_H = 0x913 + SYS___FMODL_H = 0x914 + SYS___GAMMA_H = 0x915 + SYS___HYPOT_H = 0x916 + SYS___ILOGB_H = 0x917 + SYS___LGAMMA_H = 0x918 + SYS___LGAMMAF_H = 0x919 + SYS___LOG2L_H = 0x920 + SYS___LOG1P_H = 0x921 + SYS___LOG10_H = 0x922 + SYS___LOG10F_H = 0x923 + SYS___LOG10L_H = 0x924 + SYS___LROUND_H = 0x925 + SYS___LROUNDF_H = 0x926 + SYS___NEXTAFTER_H = 0x927 + SYS___POW_H = 0x928 + SYS___POWF_H = 0x929 + SYS___SINL_H = 0x930 + SYS___SINH_H = 0x931 + SYS___SINHF_H = 0x932 + SYS___SINHL_H = 0x933 + SYS___SQRT_H = 0x934 + SYS___SQRTF_H = 0x935 + SYS___SQRTL_H = 0x936 + SYS___TAN_H = 0x937 + SYS___TANF_H = 0x938 + SYS___TANL_H = 0x939 + SYS___TRUNCF_H = 0x940 + SYS___TRUNCL_H = 0x941 + SYS___COSH_H = 0x942 + SYS___LE_DEBUG_SET_RESUME_MCH = 0x943 + SYS_VFSCANF = 0x944 + SYS_VSCANF = 0x946 + SYS_VSSCANF = 0x948 + SYS_IMAXABS = 0x950 + SYS_IMAXDIV = 0x951 + SYS_STRTOIMAX = 0x952 + SYS_STRTOUMAX = 0x953 + SYS_WCSTOIMAX = 0x954 + SYS_WCSTOUMAX = 0x955 + SYS_ATOLL = 0x956 + SYS_STRTOF = 0x957 + SYS_STRTOLD = 0x958 + SYS_WCSTOF = 0x959 + SYS_INET6_RTH_GETADDR = 0x960 + SYS_INET6_OPT_INIT = 0x961 + SYS_INET6_OPT_APPEND = 0x962 + SYS_INET6_OPT_FINISH = 0x963 + SYS_INET6_OPT_SET_VAL = 0x964 + SYS_INET6_OPT_NEXT = 0x965 + SYS_INET6_OPT_FIND = 0x966 + SYS_INET6_OPT_GET_VAL = 0x967 + SYS___POW_I = 0x987 + SYS___POW_I_B = 0x988 + SYS___POW_I_H = 0x989 + SYS___CABS_H = 0x990 + SYS_CABSF = 0x991 + SYS___CABSF_B = 0x992 + SYS___CABSF_H = 0x993 + SYS_CABSL = 0x994 + SYS___CABSL_B = 0x995 + SYS___CABSL_H = 0x996 + SYS_CACOS = 0x997 + SYS___CACOS_B = 0x998 + SYS___CACOS_H = 0x999 ) diff --git a/services/vendor/golang.org/x/sys/unix/ztypes_linux.go b/services/vendor/golang.org/x/sys/unix/ztypes_linux.go index 7f1961b9..dc0c955e 100644 --- a/services/vendor/golang.org/x/sys/unix/ztypes_linux.go +++ b/services/vendor/golang.org/x/sys/unix/ztypes_linux.go @@ -110,8 +110,7 @@ type Statx_t struct { Mnt_id uint64 Dio_mem_align uint32 Dio_offset_align uint32 - Subvol uint64 - _ [11]uint64 + _ [12]uint64 } type Fsid struct { @@ -837,15 +836,6 @@ const ( FSPICK_EMPTY_PATH = 0x8 FSMOUNT_CLOEXEC = 0x1 - - FSCONFIG_SET_FLAG = 0x0 - FSCONFIG_SET_STRING = 0x1 - FSCONFIG_SET_BINARY = 0x2 - FSCONFIG_SET_PATH = 0x3 - FSCONFIG_SET_PATH_EMPTY = 0x4 - FSCONFIG_SET_FD = 0x5 - FSCONFIG_CMD_CREATE = 0x6 - FSCONFIG_CMD_RECONFIGURE = 0x7 ) type OpenHow struct { @@ -1179,8 +1169,7 @@ const ( PERF_SAMPLE_BRANCH_TYPE_SAVE_SHIFT = 0x10 PERF_SAMPLE_BRANCH_HW_INDEX_SHIFT = 0x11 PERF_SAMPLE_BRANCH_PRIV_SAVE_SHIFT = 0x12 - PERF_SAMPLE_BRANCH_COUNTERS = 0x80000 - PERF_SAMPLE_BRANCH_MAX_SHIFT = 0x14 + PERF_SAMPLE_BRANCH_MAX_SHIFT = 0x13 PERF_SAMPLE_BRANCH_USER = 0x1 PERF_SAMPLE_BRANCH_KERNEL = 0x2 PERF_SAMPLE_BRANCH_HV = 0x4 @@ -1200,7 +1189,7 @@ const ( PERF_SAMPLE_BRANCH_TYPE_SAVE = 0x10000 PERF_SAMPLE_BRANCH_HW_INDEX = 0x20000 PERF_SAMPLE_BRANCH_PRIV_SAVE = 0x40000 - PERF_SAMPLE_BRANCH_MAX = 0x100000 + PERF_SAMPLE_BRANCH_MAX = 0x80000 PERF_BR_UNKNOWN = 0x0 PERF_BR_COND = 0x1 PERF_BR_UNCOND = 0x2 @@ -1561,7 +1550,6 @@ const ( IFLA_DEVLINK_PORT = 0x3e IFLA_GSO_IPV4_MAX_SIZE = 0x3f IFLA_GRO_IPV4_MAX_SIZE = 0x40 - IFLA_DPLL_PIN = 0x41 IFLA_PROTO_DOWN_REASON_UNSPEC = 0x0 IFLA_PROTO_DOWN_REASON_MASK = 0x1 IFLA_PROTO_DOWN_REASON_VALUE = 0x2 @@ -1577,7 +1565,6 @@ const ( IFLA_INET6_ICMP6STATS = 0x6 IFLA_INET6_TOKEN = 0x7 IFLA_INET6_ADDR_GEN_MODE = 0x8 - IFLA_INET6_RA_MTU = 0x9 IFLA_BR_UNSPEC = 0x0 IFLA_BR_FORWARD_DELAY = 0x1 IFLA_BR_HELLO_TIME = 0x2 @@ -1625,9 +1612,6 @@ const ( IFLA_BR_MCAST_MLD_VERSION = 0x2c IFLA_BR_VLAN_STATS_PER_PORT = 0x2d IFLA_BR_MULTI_BOOLOPT = 0x2e - IFLA_BR_MCAST_QUERIER_STATE = 0x2f - IFLA_BR_FDB_N_LEARNED = 0x30 - IFLA_BR_FDB_MAX_LEARNED = 0x31 IFLA_BRPORT_UNSPEC = 0x0 IFLA_BRPORT_STATE = 0x1 IFLA_BRPORT_PRIORITY = 0x2 @@ -1665,14 +1649,6 @@ const ( IFLA_BRPORT_BACKUP_PORT = 0x22 IFLA_BRPORT_MRP_RING_OPEN = 0x23 IFLA_BRPORT_MRP_IN_OPEN = 0x24 - IFLA_BRPORT_MCAST_EHT_HOSTS_LIMIT = 0x25 - IFLA_BRPORT_MCAST_EHT_HOSTS_CNT = 0x26 - IFLA_BRPORT_LOCKED = 0x27 - IFLA_BRPORT_MAB = 0x28 - IFLA_BRPORT_MCAST_N_GROUPS = 0x29 - IFLA_BRPORT_MCAST_MAX_GROUPS = 0x2a - IFLA_BRPORT_NEIGH_VLAN_SUPPRESS = 0x2b - IFLA_BRPORT_BACKUP_NHID = 0x2c IFLA_INFO_UNSPEC = 0x0 IFLA_INFO_KIND = 0x1 IFLA_INFO_DATA = 0x2 @@ -1694,9 +1670,6 @@ const ( IFLA_MACVLAN_MACADDR = 0x4 IFLA_MACVLAN_MACADDR_DATA = 0x5 IFLA_MACVLAN_MACADDR_COUNT = 0x6 - IFLA_MACVLAN_BC_QUEUE_LEN = 0x7 - IFLA_MACVLAN_BC_QUEUE_LEN_USED = 0x8 - IFLA_MACVLAN_BC_CUTOFF = 0x9 IFLA_VRF_UNSPEC = 0x0 IFLA_VRF_TABLE = 0x1 IFLA_VRF_PORT_UNSPEC = 0x0 @@ -1720,22 +1693,9 @@ const ( IFLA_XFRM_UNSPEC = 0x0 IFLA_XFRM_LINK = 0x1 IFLA_XFRM_IF_ID = 0x2 - IFLA_XFRM_COLLECT_METADATA = 0x3 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 - IFLA_NETKIT_POLICY = 0x3 - IFLA_NETKIT_PEER_POLICY = 0x4 - IFLA_NETKIT_MODE = 0x5 IFLA_VXLAN_UNSPEC = 0x0 IFLA_VXLAN_ID = 0x1 IFLA_VXLAN_GROUP = 0x2 @@ -1766,8 +1726,6 @@ const ( IFLA_VXLAN_GPE = 0x1b IFLA_VXLAN_TTL_INHERIT = 0x1c IFLA_VXLAN_DF = 0x1d - IFLA_VXLAN_VNIFILTER = 0x1e - IFLA_VXLAN_LOCALBYPASS = 0x1f IFLA_GENEVE_UNSPEC = 0x0 IFLA_GENEVE_ID = 0x1 IFLA_GENEVE_REMOTE = 0x2 @@ -1782,7 +1740,6 @@ const ( IFLA_GENEVE_LABEL = 0xb IFLA_GENEVE_TTL_INHERIT = 0xc IFLA_GENEVE_DF = 0xd - IFLA_GENEVE_INNER_PROTO_INHERIT = 0xe IFLA_BAREUDP_UNSPEC = 0x0 IFLA_BAREUDP_PORT = 0x1 IFLA_BAREUDP_ETHERTYPE = 0x2 @@ -1795,8 +1752,6 @@ const ( IFLA_GTP_FD1 = 0x2 IFLA_GTP_PDP_HASHSIZE = 0x3 IFLA_GTP_ROLE = 0x4 - IFLA_GTP_CREATE_SOCKETS = 0x5 - IFLA_GTP_RESTART_COUNT = 0x6 IFLA_BOND_UNSPEC = 0x0 IFLA_BOND_MODE = 0x1 IFLA_BOND_ACTIVE_SLAVE = 0x2 @@ -1826,9 +1781,6 @@ const ( IFLA_BOND_AD_ACTOR_SYSTEM = 0x1a IFLA_BOND_TLB_DYNAMIC_LB = 0x1b IFLA_BOND_PEER_NOTIF_DELAY = 0x1c - IFLA_BOND_AD_LACP_ACTIVE = 0x1d - IFLA_BOND_MISSED_MAX = 0x1e - IFLA_BOND_NS_IP6_TARGET = 0x1f IFLA_BOND_AD_INFO_UNSPEC = 0x0 IFLA_BOND_AD_INFO_AGGREGATOR = 0x1 IFLA_BOND_AD_INFO_NUM_PORTS = 0x2 @@ -1844,7 +1796,6 @@ const ( IFLA_BOND_SLAVE_AD_AGGREGATOR_ID = 0x6 IFLA_BOND_SLAVE_AD_ACTOR_OPER_PORT_STATE = 0x7 IFLA_BOND_SLAVE_AD_PARTNER_OPER_PORT_STATE = 0x8 - IFLA_BOND_SLAVE_PRIO = 0x9 IFLA_VF_INFO_UNSPEC = 0x0 IFLA_VF_INFO = 0x1 IFLA_VF_UNSPEC = 0x0 @@ -1903,16 +1854,8 @@ const ( IFLA_STATS_LINK_XSTATS_SLAVE = 0x3 IFLA_STATS_LINK_OFFLOAD_XSTATS = 0x4 IFLA_STATS_AF_SPEC = 0x5 - IFLA_STATS_GETSET_UNSPEC = 0x0 - IFLA_STATS_GET_FILTERS = 0x1 - IFLA_STATS_SET_OFFLOAD_XSTATS_L3_STATS = 0x2 IFLA_OFFLOAD_XSTATS_UNSPEC = 0x0 IFLA_OFFLOAD_XSTATS_CPU_HIT = 0x1 - IFLA_OFFLOAD_XSTATS_HW_S_INFO = 0x2 - IFLA_OFFLOAD_XSTATS_L3_STATS = 0x3 - IFLA_OFFLOAD_XSTATS_HW_S_INFO_UNSPEC = 0x0 - IFLA_OFFLOAD_XSTATS_HW_S_INFO_REQUEST = 0x1 - IFLA_OFFLOAD_XSTATS_HW_S_INFO_USED = 0x2 IFLA_XDP_UNSPEC = 0x0 IFLA_XDP_FD = 0x1 IFLA_XDP_ATTACHED = 0x2 @@ -1942,11 +1885,6 @@ const ( IFLA_RMNET_UNSPEC = 0x0 IFLA_RMNET_MUX_ID = 0x1 IFLA_RMNET_FLAGS = 0x2 - IFLA_MCTP_UNSPEC = 0x0 - IFLA_MCTP_NET = 0x1 - IFLA_DSA_UNSPEC = 0x0 - IFLA_DSA_CONDUIT = 0x1 - IFLA_DSA_MASTER = 0x1 ) const ( @@ -2483,15 +2421,6 @@ type XDPMmapOffsets struct { Cr XDPRingOffset } -type XDPUmemReg struct { - Addr uint64 - Len uint64 - Chunk_size uint32 - Headroom uint32 - Flags uint32 - Tx_metadata_len uint32 -} - type XDPStatistics struct { Rx_dropped uint64 Rx_invalid_descs uint64 @@ -2946,7 +2875,7 @@ const ( BPF_TCP_LISTEN = 0xa BPF_TCP_CLOSING = 0xb BPF_TCP_NEW_SYN_RECV = 0xc - BPF_TCP_MAX_STATES = 0xe + BPF_TCP_MAX_STATES = 0xd TCP_BPF_IW = 0x3e9 TCP_BPF_SNDCWND_CLAMP = 0x3ea TCP_BPF_DELACK_MAX = 0x3eb @@ -3222,7 +3151,7 @@ const ( DEVLINK_CMD_LINECARD_NEW = 0x50 DEVLINK_CMD_LINECARD_DEL = 0x51 DEVLINK_CMD_SELFTESTS_GET = 0x52 - DEVLINK_CMD_MAX = 0x54 + DEVLINK_CMD_MAX = 0x53 DEVLINK_PORT_TYPE_NOTSET = 0x0 DEVLINK_PORT_TYPE_AUTO = 0x1 DEVLINK_PORT_TYPE_ETH = 0x2 @@ -3474,7 +3403,7 @@ const ( DEVLINK_PORT_FN_ATTR_STATE = 0x2 DEVLINK_PORT_FN_ATTR_OPSTATE = 0x3 DEVLINK_PORT_FN_ATTR_CAPS = 0x4 - DEVLINK_PORT_FUNCTION_ATTR_MAX = 0x6 + DEVLINK_PORT_FUNCTION_ATTR_MAX = 0x5 ) type FsverityDigest struct { @@ -3807,9 +3736,6 @@ const ( ETHTOOL_MSG_PSE_GET_REPLY = 0x25 ETHTOOL_MSG_RSS_GET_REPLY = 0x26 ETHTOOL_MSG_KERNEL_MAX = 0x2b - 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 @@ -3979,7 +3905,7 @@ const ( ETHTOOL_A_TSINFO_TX_TYPES = 0x3 ETHTOOL_A_TSINFO_RX_FILTERS = 0x4 ETHTOOL_A_TSINFO_PHC_INDEX = 0x5 - ETHTOOL_A_TSINFO_MAX = 0x6 + ETHTOOL_A_TSINFO_MAX = 0x5 ETHTOOL_A_CABLE_TEST_UNSPEC = 0x0 ETHTOOL_A_CABLE_TEST_HEADER = 0x1 ETHTOOL_A_CABLE_TEST_MAX = 0x1 @@ -4609,7 +4535,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 = 0x146 NL80211_ATTR_MAX_CRIT_PROT_DURATION = 0xb4 NL80211_ATTR_MAX_CSA_COUNTERS = 0xce NL80211_ATTR_MAX_MATCH_SETS = 0x85 @@ -4875,7 +4801,7 @@ const ( NL80211_BSS_FREQUENCY_OFFSET = 0x14 NL80211_BSS_INFORMATION_ELEMENTS = 0x6 NL80211_BSS_LAST_SEEN_BOOTTIME = 0xf - NL80211_BSS_MAX = 0x18 + NL80211_BSS_MAX = 0x16 NL80211_BSS_MLD_ADDR = 0x16 NL80211_BSS_MLO_LINK_ID = 0x15 NL80211_BSS_PAD = 0x10 @@ -4979,7 +4905,7 @@ const ( NL80211_CMD_LEAVE_IBSS = 0x2c NL80211_CMD_LEAVE_MESH = 0x45 NL80211_CMD_LEAVE_OCB = 0x6d - NL80211_CMD_MAX = 0x9b + NL80211_CMD_MAX = 0x9a NL80211_CMD_MICHAEL_MIC_FAILURE = 0x29 NL80211_CMD_MODIFY_LINK_STA = 0x97 NL80211_CMD_NAN_MATCH = 0x78 @@ -5213,7 +5139,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 = 0x1c NL80211_FREQUENCY_ATTR_MAX_TX_POWER = 0x6 NL80211_FREQUENCY_ATTR_NO_10MHZ = 0x11 NL80211_FREQUENCY_ATTR_NO_160MHZ = 0xc @@ -5707,7 +5633,7 @@ const ( NL80211_STA_FLAG_ASSOCIATED = 0x7 NL80211_STA_FLAG_AUTHENTICATED = 0x5 NL80211_STA_FLAG_AUTHORIZED = 0x1 - NL80211_STA_FLAG_MAX = 0x8 + NL80211_STA_FLAG_MAX = 0x7 NL80211_STA_FLAG_MAX_OLD_API = 0x6 NL80211_STA_FLAG_MFP = 0x4 NL80211_STA_FLAG_SHORT_PREAMBLE = 0x2 @@ -6005,34 +5931,3 @@ type CachestatRange struct { Off uint64 Len uint64 } - -const ( - SK_MEMINFO_RMEM_ALLOC = 0x0 - SK_MEMINFO_RCVBUF = 0x1 - SK_MEMINFO_WMEM_ALLOC = 0x2 - SK_MEMINFO_SNDBUF = 0x3 - SK_MEMINFO_FWD_ALLOC = 0x4 - SK_MEMINFO_WMEM_QUEUED = 0x5 - SK_MEMINFO_OPTMEM = 0x6 - SK_MEMINFO_BACKLOG = 0x7 - SK_MEMINFO_DROPS = 0x8 - SK_MEMINFO_VARS = 0x9 - SKNLGRP_NONE = 0x0 - SKNLGRP_INET_TCP_DESTROY = 0x1 - SKNLGRP_INET_UDP_DESTROY = 0x2 - SKNLGRP_INET6_TCP_DESTROY = 0x3 - SKNLGRP_INET6_UDP_DESTROY = 0x4 - SK_DIAG_BPF_STORAGE_REQ_NONE = 0x0 - SK_DIAG_BPF_STORAGE_REQ_MAP_FD = 0x1 - SK_DIAG_BPF_STORAGE_REP_NONE = 0x0 - SK_DIAG_BPF_STORAGE = 0x1 - SK_DIAG_BPF_STORAGE_NONE = 0x0 - SK_DIAG_BPF_STORAGE_PAD = 0x1 - SK_DIAG_BPF_STORAGE_MAP_ID = 0x2 - SK_DIAG_BPF_STORAGE_MAP_VALUE = 0x3 -) - -type SockDiagReq struct { - Family uint8 - Protocol uint8 -} diff --git a/services/vendor/golang.org/x/sys/unix/ztypes_linux_386.go b/services/vendor/golang.org/x/sys/unix/ztypes_linux_386.go index fd402da4..438a30af 100644 --- a/services/vendor/golang.org/x/sys/unix/ztypes_linux_386.go +++ b/services/vendor/golang.org/x/sys/unix/ztypes_linux_386.go @@ -477,6 +477,14 @@ const ( BLKPG = 0x1269 ) +type XDPUmemReg struct { + Addr uint64 + Len uint64 + Size uint32 + Headroom uint32 + Flags uint32 +} + type CryptoUserAlg struct { Name [64]int8 Driver_name [64]int8 diff --git a/services/vendor/golang.org/x/sys/unix/ztypes_linux_amd64.go b/services/vendor/golang.org/x/sys/unix/ztypes_linux_amd64.go index eb7a5e18..adceca35 100644 --- a/services/vendor/golang.org/x/sys/unix/ztypes_linux_amd64.go +++ b/services/vendor/golang.org/x/sys/unix/ztypes_linux_amd64.go @@ -492,6 +492,15 @@ const ( BLKPG = 0x1269 ) +type XDPUmemReg struct { + Addr uint64 + Len uint64 + Size uint32 + Headroom uint32 + Flags uint32 + _ [4]byte +} + type CryptoUserAlg struct { Name [64]int8 Driver_name [64]int8 diff --git a/services/vendor/golang.org/x/sys/unix/ztypes_linux_arm.go b/services/vendor/golang.org/x/sys/unix/ztypes_linux_arm.go index d78ac108..eeaa00a3 100644 --- a/services/vendor/golang.org/x/sys/unix/ztypes_linux_arm.go +++ b/services/vendor/golang.org/x/sys/unix/ztypes_linux_arm.go @@ -470,6 +470,15 @@ const ( BLKPG = 0x1269 ) +type XDPUmemReg struct { + Addr uint64 + Len uint64 + Size uint32 + Headroom uint32 + Flags uint32 + _ [4]byte +} + type CryptoUserAlg struct { Name [64]uint8 Driver_name [64]uint8 diff --git a/services/vendor/golang.org/x/sys/unix/ztypes_linux_arm64.go b/services/vendor/golang.org/x/sys/unix/ztypes_linux_arm64.go index cd06d47f..6739aa91 100644 --- a/services/vendor/golang.org/x/sys/unix/ztypes_linux_arm64.go +++ b/services/vendor/golang.org/x/sys/unix/ztypes_linux_arm64.go @@ -471,6 +471,15 @@ const ( BLKPG = 0x1269 ) +type XDPUmemReg struct { + Addr uint64 + Len uint64 + Size uint32 + Headroom uint32 + Flags uint32 + _ [4]byte +} + type CryptoUserAlg struct { Name [64]int8 Driver_name [64]int8 diff --git a/services/vendor/golang.org/x/sys/unix/ztypes_linux_loong64.go b/services/vendor/golang.org/x/sys/unix/ztypes_linux_loong64.go index 2f28fe26..9920ef63 100644 --- a/services/vendor/golang.org/x/sys/unix/ztypes_linux_loong64.go +++ b/services/vendor/golang.org/x/sys/unix/ztypes_linux_loong64.go @@ -472,6 +472,15 @@ const ( BLKPG = 0x1269 ) +type XDPUmemReg struct { + Addr uint64 + Len uint64 + Size uint32 + Headroom uint32 + Flags uint32 + _ [4]byte +} + type CryptoUserAlg struct { Name [64]int8 Driver_name [64]int8 diff --git a/services/vendor/golang.org/x/sys/unix/ztypes_linux_mips.go b/services/vendor/golang.org/x/sys/unix/ztypes_linux_mips.go index 71d6cac2..2923b799 100644 --- a/services/vendor/golang.org/x/sys/unix/ztypes_linux_mips.go +++ b/services/vendor/golang.org/x/sys/unix/ztypes_linux_mips.go @@ -476,6 +476,15 @@ const ( BLKPG = 0x20001269 ) +type XDPUmemReg struct { + Addr uint64 + Len uint64 + Size uint32 + Headroom uint32 + Flags uint32 + _ [4]byte +} + type CryptoUserAlg struct { Name [64]int8 Driver_name [64]int8 diff --git a/services/vendor/golang.org/x/sys/unix/ztypes_linux_mips64.go b/services/vendor/golang.org/x/sys/unix/ztypes_linux_mips64.go index 8596d453..ce2750ee 100644 --- a/services/vendor/golang.org/x/sys/unix/ztypes_linux_mips64.go +++ b/services/vendor/golang.org/x/sys/unix/ztypes_linux_mips64.go @@ -474,6 +474,15 @@ const ( BLKPG = 0x20001269 ) +type XDPUmemReg struct { + Addr uint64 + Len uint64 + Size uint32 + Headroom uint32 + Flags uint32 + _ [4]byte +} + type CryptoUserAlg struct { Name [64]int8 Driver_name [64]int8 diff --git a/services/vendor/golang.org/x/sys/unix/ztypes_linux_mips64le.go b/services/vendor/golang.org/x/sys/unix/ztypes_linux_mips64le.go index cd60ea18..3038811d 100644 --- a/services/vendor/golang.org/x/sys/unix/ztypes_linux_mips64le.go +++ b/services/vendor/golang.org/x/sys/unix/ztypes_linux_mips64le.go @@ -474,6 +474,15 @@ const ( BLKPG = 0x20001269 ) +type XDPUmemReg struct { + Addr uint64 + Len uint64 + Size uint32 + Headroom uint32 + Flags uint32 + _ [4]byte +} + type CryptoUserAlg struct { Name [64]int8 Driver_name [64]int8 diff --git a/services/vendor/golang.org/x/sys/unix/ztypes_linux_mipsle.go b/services/vendor/golang.org/x/sys/unix/ztypes_linux_mipsle.go index b0ae420c..efc6fed1 100644 --- a/services/vendor/golang.org/x/sys/unix/ztypes_linux_mipsle.go +++ b/services/vendor/golang.org/x/sys/unix/ztypes_linux_mipsle.go @@ -476,6 +476,15 @@ const ( BLKPG = 0x20001269 ) +type XDPUmemReg struct { + Addr uint64 + Len uint64 + Size uint32 + Headroom uint32 + Flags uint32 + _ [4]byte +} + type CryptoUserAlg struct { Name [64]int8 Driver_name [64]int8 diff --git a/services/vendor/golang.org/x/sys/unix/ztypes_linux_ppc.go b/services/vendor/golang.org/x/sys/unix/ztypes_linux_ppc.go index 83597287..9a654b75 100644 --- a/services/vendor/golang.org/x/sys/unix/ztypes_linux_ppc.go +++ b/services/vendor/golang.org/x/sys/unix/ztypes_linux_ppc.go @@ -482,6 +482,15 @@ const ( BLKPG = 0x20001269 ) +type XDPUmemReg struct { + Addr uint64 + Len uint64 + Size uint32 + Headroom uint32 + Flags uint32 + _ [4]byte +} + type CryptoUserAlg struct { Name [64]uint8 Driver_name [64]uint8 diff --git a/services/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64.go b/services/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64.go index 69eb6a5c..40d358e3 100644 --- a/services/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64.go +++ b/services/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64.go @@ -481,6 +481,15 @@ const ( BLKPG = 0x20001269 ) +type XDPUmemReg struct { + Addr uint64 + Len uint64 + Size uint32 + Headroom uint32 + Flags uint32 + _ [4]byte +} + type CryptoUserAlg struct { Name [64]uint8 Driver_name [64]uint8 diff --git a/services/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64le.go b/services/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64le.go index 5f583cb6..148c6ceb 100644 --- a/services/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64le.go +++ b/services/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64le.go @@ -481,6 +481,15 @@ const ( BLKPG = 0x20001269 ) +type XDPUmemReg struct { + Addr uint64 + Len uint64 + Size uint32 + Headroom uint32 + Flags uint32 + _ [4]byte +} + type CryptoUserAlg struct { Name [64]uint8 Driver_name [64]uint8 diff --git a/services/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go b/services/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go index 15adc041..72ba8154 100644 --- a/services/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go +++ b/services/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go @@ -499,6 +499,15 @@ const ( BLKPG = 0x1269 ) +type XDPUmemReg struct { + Addr uint64 + Len uint64 + Size uint32 + Headroom uint32 + Flags uint32 + _ [4]byte +} + type CryptoUserAlg struct { Name [64]uint8 Driver_name [64]uint8 diff --git a/services/vendor/golang.org/x/sys/unix/ztypes_linux_s390x.go b/services/vendor/golang.org/x/sys/unix/ztypes_linux_s390x.go index cf3ce900..71e76550 100644 --- a/services/vendor/golang.org/x/sys/unix/ztypes_linux_s390x.go +++ b/services/vendor/golang.org/x/sys/unix/ztypes_linux_s390x.go @@ -495,6 +495,15 @@ const ( BLKPG = 0x1269 ) +type XDPUmemReg struct { + Addr uint64 + Len uint64 + Size uint32 + Headroom uint32 + Flags uint32 + _ [4]byte +} + type CryptoUserAlg struct { Name [64]int8 Driver_name [64]int8 diff --git a/services/vendor/golang.org/x/sys/unix/ztypes_linux_sparc64.go b/services/vendor/golang.org/x/sys/unix/ztypes_linux_sparc64.go index 590b5673..4abbdb9d 100644 --- a/services/vendor/golang.org/x/sys/unix/ztypes_linux_sparc64.go +++ b/services/vendor/golang.org/x/sys/unix/ztypes_linux_sparc64.go @@ -476,6 +476,15 @@ const ( BLKPG = 0x20001269 ) +type XDPUmemReg struct { + Addr uint64 + Len uint64 + Size uint32 + Headroom uint32 + Flags uint32 + _ [4]byte +} + type CryptoUserAlg struct { Name [64]int8 Driver_name [64]int8 diff --git a/services/vendor/golang.org/x/sys/unix/ztypes_zos_s390x.go b/services/vendor/golang.org/x/sys/unix/ztypes_zos_s390x.go index d9a13af4..54f31be6 100644 --- a/services/vendor/golang.org/x/sys/unix/ztypes_zos_s390x.go +++ b/services/vendor/golang.org/x/sys/unix/ztypes_zos_s390x.go @@ -25,13 +25,10 @@ const ( SizeofIPv6Mreq = 20 SizeofICMPv6Filter = 32 SizeofIPv6MTUInfo = 32 - SizeofInet4Pktinfo = 8 - SizeofInet6Pktinfo = 20 SizeofLinger = 8 SizeofSockaddrInet4 = 16 SizeofSockaddrInet6 = 28 SizeofTCPInfo = 0x68 - SizeofUcred = 12 ) type ( @@ -72,17 +69,12 @@ type Utimbuf struct { } type Utsname struct { - Sysname [16]byte - Nodename [32]byte - Release [8]byte - Version [8]byte - Machine [16]byte -} - -type Ucred struct { - Pid int32 - Uid uint32 - Gid uint32 + Sysname [65]byte + Nodename [65]byte + Release [65]byte + Version [65]byte + Machine [65]byte + Domainname [65]byte } type RawSockaddrInet4 struct { @@ -333,7 +325,7 @@ type Statvfs_t struct { } type Statfs_t struct { - Type uint64 + Type uint32 Bsize uint64 Blocks uint64 Bfree uint64 @@ -344,7 +336,6 @@ type Statfs_t struct { Namelen uint64 Frsize uint64 Flags uint64 - _ [4]uint64 } type direntLE struct { @@ -421,126 +412,3 @@ type W_Mntent struct { Quiesceowner [8]byte _ [38]byte } - -type EpollEvent struct { - Events uint32 - _ int32 - Fd int32 - Pad int32 -} - -type InotifyEvent struct { - Wd int32 - Mask uint32 - Cookie uint32 - Len uint32 - Name string -} - -const ( - SizeofInotifyEvent = 0x10 -) - -type ConsMsg2 struct { - Cm2Format uint16 - Cm2R1 uint16 - Cm2Msglength uint32 - Cm2Msg *byte - Cm2R2 [4]byte - Cm2R3 [4]byte - Cm2Routcde *uint32 - Cm2Descr *uint32 - Cm2Msgflag uint32 - Cm2Token uint32 - Cm2Msgid *uint32 - Cm2R4 [4]byte - Cm2DomToken uint32 - Cm2DomMsgid *uint32 - Cm2ModCartptr *byte - Cm2ModConsidptr *byte - Cm2MsgCart [8]byte - Cm2MsgConsid [4]byte - Cm2R5 [12]byte -} - -const ( - CC_modify = 1 - CC_stop = 2 - CONSOLE_FORMAT_2 = 2 - CONSOLE_FORMAT_3 = 3 - CONSOLE_HRDCPY = 0x80000000 -) - -type OpenHow struct { - Flags uint64 - Mode uint64 - Resolve uint64 -} - -const SizeofOpenHow = 0x18 - -const ( - RESOLVE_CACHED = 0x20 - RESOLVE_BENEATH = 0x8 - RESOLVE_IN_ROOT = 0x10 - RESOLVE_NO_MAGICLINKS = 0x2 - RESOLVE_NO_SYMLINKS = 0x4 - RESOLVE_NO_XDEV = 0x1 -) - -type Siginfo struct { - Signo int32 - Errno int32 - Code int32 - Pid int32 - Uid uint32 - _ [44]byte -} - -type SysvIpcPerm struct { - Uid uint32 - Gid uint32 - Cuid uint32 - Cgid uint32 - Mode int32 -} - -type SysvShmDesc struct { - Perm SysvIpcPerm - _ [4]byte - Lpid int32 - Cpid int32 - Nattch uint32 - _ [4]byte - _ [4]byte - _ [4]byte - _ int32 - _ uint8 - _ uint8 - _ uint16 - _ *byte - Segsz uint64 - Atime Time_t - Dtime Time_t - Ctime Time_t -} - -type SysvShmDesc64 struct { - Perm SysvIpcPerm - _ [4]byte - Lpid int32 - Cpid int32 - Nattch uint32 - _ [4]byte - _ [4]byte - _ [4]byte - _ int32 - _ byte - _ uint8 - _ uint16 - _ *byte - Segsz uint64 - Atime int64 - Dtime int64 - Ctime int64 -} diff --git a/services/vendor/golang.org/x/sys/windows/aliases.go b/services/vendor/golang.org/x/sys/windows/aliases.go index 16f90560..ce2d713d 100644 --- a/services/vendor/golang.org/x/sys/windows/aliases.go +++ b/services/vendor/golang.org/x/sys/windows/aliases.go @@ -2,7 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. -//go:build windows +//go:build windows && go1.9 package windows diff --git a/services/vendor/golang.org/x/sys/windows/empty.s b/services/vendor/golang.org/x/sys/windows/empty.s new file mode 100644 index 00000000..ba64caca --- /dev/null +++ b/services/vendor/golang.org/x/sys/windows/empty.s @@ -0,0 +1,8 @@ +// Copyright 2019 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.12 + +// This file is here to allow bodyless functions with go:linkname for Go 1.11 +// and earlier (see https://golang.org/issue/23311). diff --git a/services/vendor/golang.org/x/sys/windows/security_windows.go b/services/vendor/golang.org/x/sys/windows/security_windows.go index b6e1ab76..26be94a8 100644 --- a/services/vendor/golang.org/x/sys/windows/security_windows.go +++ b/services/vendor/golang.org/x/sys/windows/security_windows.go @@ -68,7 +68,6 @@ type UserInfo10 struct { //sys NetUserGetInfo(serverName *uint16, userName *uint16, level uint32, buf **byte) (neterr error) = netapi32.NetUserGetInfo //sys NetGetJoinInformation(server *uint16, name **uint16, bufType *uint32) (neterr error) = netapi32.NetGetJoinInformation //sys NetApiBufferFree(buf *byte) (neterr error) = netapi32.NetApiBufferFree -//sys NetUserEnum(serverName *uint16, level uint32, filter uint32, buf **byte, prefMaxLen uint32, entriesRead *uint32, totalEntries *uint32, resumeHandle *uint32) (neterr error) = netapi32.NetUserEnum const ( // do not reorder @@ -894,7 +893,7 @@ type ACL struct { aclRevision byte sbz1 byte aclSize uint16 - AceCount uint16 + aceCount uint16 sbz2 uint16 } @@ -1087,27 +1086,6 @@ type EXPLICIT_ACCESS struct { Trustee TRUSTEE } -// https://learn.microsoft.com/en-us/windows/win32/api/winnt/ns-winnt-ace_header -type ACE_HEADER struct { - AceType uint8 - AceFlags uint8 - AceSize uint16 -} - -// https://learn.microsoft.com/en-us/windows/win32/api/winnt/ns-winnt-access_allowed_ace -type ACCESS_ALLOWED_ACE struct { - Header ACE_HEADER - Mask ACCESS_MASK - SidStart uint32 -} - -const ( - // Constants for AceType - // https://learn.microsoft.com/en-us/windows/win32/api/winnt/ns-winnt-ace_header - ACCESS_ALLOWED_ACE_TYPE = 0 - ACCESS_DENIED_ACE_TYPE = 1 -) - // This type is the union inside of TRUSTEE and must be created using one of the TrusteeValueFrom* functions. type TrusteeValue uintptr @@ -1179,7 +1157,6 @@ type OBJECTS_AND_NAME struct { //sys makeSelfRelativeSD(absoluteSD *SECURITY_DESCRIPTOR, selfRelativeSD *SECURITY_DESCRIPTOR, selfRelativeSDSize *uint32) (err error) = advapi32.MakeSelfRelativeSD //sys setEntriesInAcl(countExplicitEntries uint32, explicitEntries *EXPLICIT_ACCESS, oldACL *ACL, newACL **ACL) (ret error) = advapi32.SetEntriesInAclW -//sys GetAce(acl *ACL, aceIndex uint32, pAce **ACCESS_ALLOWED_ACE) (err error) = advapi32.GetAce // Control returns the security descriptor control bits. func (sd *SECURITY_DESCRIPTOR) Control() (control SECURITY_DESCRIPTOR_CONTROL, revision uint32, err error) { diff --git a/services/vendor/golang.org/x/sys/windows/syscall_windows.go b/services/vendor/golang.org/x/sys/windows/syscall_windows.go index 1fa34fd1..6395a031 100644 --- a/services/vendor/golang.org/x/sys/windows/syscall_windows.go +++ b/services/vendor/golang.org/x/sys/windows/syscall_windows.go @@ -17,10 +17,8 @@ import ( "unsafe" ) -type ( - Handle uintptr - HWND uintptr -) +type Handle uintptr +type HWND uintptr const ( InvalidHandle = ^Handle(0) @@ -167,7 +165,6 @@ func NewCallbackCDecl(fn interface{}) uintptr { //sys CreateFile(name *uint16, access uint32, mode uint32, sa *SecurityAttributes, createmode uint32, attrs uint32, templatefile Handle) (handle Handle, err error) [failretval==InvalidHandle] = CreateFileW //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 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 @@ -213,10 +210,6 @@ func NewCallbackCDecl(fn interface{}) uintptr { //sys OpenProcess(desiredAccess uint32, inheritHandle bool, processId uint32) (handle Handle, err error) //sys ShellExecute(hwnd Handle, verb *uint16, file *uint16, args *uint16, cwd *uint16, showCmd int32) (err error) [failretval<=32] = shell32.ShellExecuteW //sys GetWindowThreadProcessId(hwnd HWND, pid *uint32) (tid uint32, err error) = user32.GetWindowThreadProcessId -//sys LoadKeyboardLayout(name *uint16, flags uint32) (hkl Handle, err error) [failretval==0] = user32.LoadKeyboardLayoutW -//sys UnloadKeyboardLayout(hkl Handle) (err error) = user32.UnloadKeyboardLayout -//sys GetKeyboardLayout(tid uint32) (hkl Handle) = user32.GetKeyboardLayout -//sys ToUnicodeEx(vkey uint32, scancode uint32, keystate *byte, pwszBuff *uint16, cchBuff int32, flags uint32, hkl Handle) (ret int32) = user32.ToUnicodeEx //sys GetShellWindow() (shellWindow HWND) = user32.GetShellWindow //sys MessageBox(hwnd HWND, text *uint16, caption *uint16, boxtype uint32) (ret int32, err error) [failretval==0] = user32.MessageBoxW //sys ExitWindowsEx(flags uint32, reason uint32) (err error) = user32.ExitWindowsEx @@ -355,19 +348,8 @@ func NewCallbackCDecl(fn interface{}) uintptr { //sys SetProcessPriorityBoost(process Handle, disable bool) (err error) = kernel32.SetProcessPriorityBoost //sys GetProcessWorkingSetSizeEx(hProcess Handle, lpMinimumWorkingSetSize *uintptr, lpMaximumWorkingSetSize *uintptr, flags *uint32) //sys SetProcessWorkingSetSizeEx(hProcess Handle, dwMinimumWorkingSetSize uintptr, dwMaximumWorkingSetSize uintptr, flags uint32) (err error) -//sys ClearCommBreak(handle Handle) (err error) -//sys ClearCommError(handle Handle, lpErrors *uint32, lpStat *ComStat) (err error) -//sys EscapeCommFunction(handle Handle, dwFunc uint32) (err error) -//sys GetCommState(handle Handle, lpDCB *DCB) (err error) -//sys GetCommModemStatus(handle Handle, lpModemStat *uint32) (err error) //sys GetCommTimeouts(handle Handle, timeouts *CommTimeouts) (err error) -//sys PurgeComm(handle Handle, dwFlags uint32) (err error) -//sys SetCommBreak(handle Handle) (err error) -//sys SetCommMask(handle Handle, dwEvtMask uint32) (err error) -//sys SetCommState(handle Handle, lpDCB *DCB) (err error) //sys SetCommTimeouts(handle Handle, timeouts *CommTimeouts) (err error) -//sys SetupComm(handle Handle, dwInQueue uint32, dwOutQueue uint32) (err error) -//sys WaitCommEvent(handle Handle, lpEvtMask *uint32, lpOverlapped *Overlapped) (err error) //sys GetActiveProcessorCount(groupNumber uint16) (ret uint32) //sys GetMaximumProcessorCount(groupNumber uint16) (ret uint32) //sys EnumWindows(enumFunc uintptr, param unsafe.Pointer) (err error) = user32.EnumWindows @@ -1374,11 +1356,9 @@ func SetsockoptLinger(fd Handle, level, opt int, l *Linger) (err error) { func SetsockoptInet4Addr(fd Handle, level, opt int, value [4]byte) (err error) { return Setsockopt(fd, int32(level), int32(opt), (*byte)(unsafe.Pointer(&value[0])), 4) } - func SetsockoptIPMreq(fd Handle, level, opt int, mreq *IPMreq) (err error) { return Setsockopt(fd, int32(level), int32(opt), (*byte)(unsafe.Pointer(mreq)), int32(unsafe.Sizeof(*mreq))) } - func SetsockoptIPv6Mreq(fd Handle, level, opt int, mreq *IPv6Mreq) (err error) { return syscall.EWINDOWS } @@ -1854,73 +1834,3 @@ func ResizePseudoConsole(pconsole Handle, size Coord) error { // accept arguments that can be casted to uintptr, and Coord can't. return resizePseudoConsole(pconsole, *((*uint32)(unsafe.Pointer(&size)))) } - -// DCB constants. See https://learn.microsoft.com/en-us/windows/win32/api/winbase/ns-winbase-dcb. -const ( - CBR_110 = 110 - CBR_300 = 300 - CBR_600 = 600 - CBR_1200 = 1200 - CBR_2400 = 2400 - CBR_4800 = 4800 - CBR_9600 = 9600 - CBR_14400 = 14400 - CBR_19200 = 19200 - CBR_38400 = 38400 - CBR_57600 = 57600 - CBR_115200 = 115200 - CBR_128000 = 128000 - CBR_256000 = 256000 - - DTR_CONTROL_DISABLE = 0x00000000 - DTR_CONTROL_ENABLE = 0x00000010 - DTR_CONTROL_HANDSHAKE = 0x00000020 - - RTS_CONTROL_DISABLE = 0x00000000 - RTS_CONTROL_ENABLE = 0x00001000 - RTS_CONTROL_HANDSHAKE = 0x00002000 - RTS_CONTROL_TOGGLE = 0x00003000 - - NOPARITY = 0 - ODDPARITY = 1 - EVENPARITY = 2 - MARKPARITY = 3 - SPACEPARITY = 4 - - ONESTOPBIT = 0 - ONE5STOPBITS = 1 - TWOSTOPBITS = 2 -) - -// EscapeCommFunction constants. See https://learn.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-escapecommfunction. -const ( - SETXOFF = 1 - SETXON = 2 - SETRTS = 3 - CLRRTS = 4 - SETDTR = 5 - CLRDTR = 6 - SETBREAK = 8 - CLRBREAK = 9 -) - -// PurgeComm constants. See https://learn.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-purgecomm. -const ( - PURGE_TXABORT = 0x0001 - PURGE_RXABORT = 0x0002 - PURGE_TXCLEAR = 0x0004 - PURGE_RXCLEAR = 0x0008 -) - -// SetCommMask constants. See https://learn.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-setcommmask. -const ( - EV_RXCHAR = 0x0001 - EV_RXFLAG = 0x0002 - EV_TXEMPTY = 0x0004 - EV_CTS = 0x0008 - EV_DSR = 0x0010 - EV_RLSD = 0x0020 - EV_BREAK = 0x0040 - EV_ERR = 0x0080 - EV_RING = 0x0100 -) diff --git a/services/vendor/golang.org/x/sys/windows/types_windows.go b/services/vendor/golang.org/x/sys/windows/types_windows.go index 3f03b3d5..359780f6 100644 --- a/services/vendor/golang.org/x/sys/windows/types_windows.go +++ b/services/vendor/golang.org/x/sys/windows/types_windows.go @@ -2003,21 +2003,7 @@ const ( MOVEFILE_FAIL_IF_NOT_TRACKABLE = 0x20 ) -// Flags for GetAdaptersAddresses, see -// https://learn.microsoft.com/en-us/windows/win32/api/iphlpapi/nf-iphlpapi-getadaptersaddresses. -const ( - GAA_FLAG_SKIP_UNICAST = 0x1 - GAA_FLAG_SKIP_ANYCAST = 0x2 - GAA_FLAG_SKIP_MULTICAST = 0x4 - GAA_FLAG_SKIP_DNS_SERVER = 0x8 - GAA_FLAG_INCLUDE_PREFIX = 0x10 - GAA_FLAG_SKIP_FRIENDLY_NAME = 0x20 - GAA_FLAG_INCLUDE_WINS_INFO = 0x40 - GAA_FLAG_INCLUDE_GATEWAYS = 0x80 - GAA_FLAG_INCLUDE_ALL_INTERFACES = 0x100 - GAA_FLAG_INCLUDE_ALL_COMPARTMENTS = 0x200 - GAA_FLAG_INCLUDE_TUNNEL_BINDINGORDER = 0x400 -) +const GAA_FLAG_INCLUDE_PREFIX = 0x00000010 const ( IF_TYPE_OTHER = 1 @@ -2031,50 +2017,6 @@ 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 @@ -3438,38 +3380,3 @@ type BLOB struct { Size uint32 BlobData *byte } - -type ComStat struct { - Flags uint32 - CBInQue uint32 - CBOutQue uint32 -} - -type DCB struct { - DCBlength uint32 - BaudRate uint32 - Flags uint32 - wReserved uint16 - XonLim uint16 - XoffLim uint16 - ByteSize uint8 - Parity uint8 - StopBits uint8 - XonChar byte - XoffChar byte - ErrorChar byte - EofChar byte - EvtChar byte - wReserved1 uint16 -} - -// Keyboard Layout Flags. -// See https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-loadkeyboardlayoutw -const ( - KLF_ACTIVATE = 0x00000001 - KLF_SUBSTITUTE_OK = 0x00000002 - KLF_REORDER = 0x00000008 - KLF_REPLACELANG = 0x00000010 - KLF_NOTELLSHELL = 0x00000080 - KLF_SETFORPROCESS = 0x00000100 -) diff --git a/services/vendor/golang.org/x/sys/windows/zsyscall_windows.go b/services/vendor/golang.org/x/sys/windows/zsyscall_windows.go index 9bb979a3..e8791c82 100644 --- a/services/vendor/golang.org/x/sys/windows/zsyscall_windows.go +++ b/services/vendor/golang.org/x/sys/windows/zsyscall_windows.go @@ -91,7 +91,6 @@ var ( procEnumServicesStatusExW = modadvapi32.NewProc("EnumServicesStatusExW") procEqualSid = modadvapi32.NewProc("EqualSid") procFreeSid = modadvapi32.NewProc("FreeSid") - procGetAce = modadvapi32.NewProc("GetAce") procGetLengthSid = modadvapi32.NewProc("GetLengthSid") procGetNamedSecurityInfoW = modadvapi32.NewProc("GetNamedSecurityInfoW") procGetSecurityDescriptorControl = modadvapi32.NewProc("GetSecurityDescriptorControl") @@ -189,8 +188,6 @@ var ( procAssignProcessToJobObject = modkernel32.NewProc("AssignProcessToJobObject") procCancelIo = modkernel32.NewProc("CancelIo") procCancelIoEx = modkernel32.NewProc("CancelIoEx") - procClearCommBreak = modkernel32.NewProc("ClearCommBreak") - procClearCommError = modkernel32.NewProc("ClearCommError") procCloseHandle = modkernel32.NewProc("CloseHandle") procClosePseudoConsole = modkernel32.NewProc("ClosePseudoConsole") procConnectNamedPipe = modkernel32.NewProc("ConnectNamedPipe") @@ -215,9 +212,7 @@ var ( procDeleteProcThreadAttributeList = modkernel32.NewProc("DeleteProcThreadAttributeList") procDeleteVolumeMountPointW = modkernel32.NewProc("DeleteVolumeMountPointW") procDeviceIoControl = modkernel32.NewProc("DeviceIoControl") - procDisconnectNamedPipe = modkernel32.NewProc("DisconnectNamedPipe") procDuplicateHandle = modkernel32.NewProc("DuplicateHandle") - procEscapeCommFunction = modkernel32.NewProc("EscapeCommFunction") procExitProcess = modkernel32.NewProc("ExitProcess") procExpandEnvironmentStringsW = modkernel32.NewProc("ExpandEnvironmentStringsW") procFindClose = modkernel32.NewProc("FindClose") @@ -241,8 +236,6 @@ var ( procGenerateConsoleCtrlEvent = modkernel32.NewProc("GenerateConsoleCtrlEvent") procGetACP = modkernel32.NewProc("GetACP") procGetActiveProcessorCount = modkernel32.NewProc("GetActiveProcessorCount") - procGetCommModemStatus = modkernel32.NewProc("GetCommModemStatus") - procGetCommState = modkernel32.NewProc("GetCommState") procGetCommTimeouts = modkernel32.NewProc("GetCommTimeouts") procGetCommandLineW = modkernel32.NewProc("GetCommandLineW") procGetComputerNameExW = modkernel32.NewProc("GetComputerNameExW") @@ -329,7 +322,6 @@ var ( procProcess32NextW = modkernel32.NewProc("Process32NextW") procProcessIdToSessionId = modkernel32.NewProc("ProcessIdToSessionId") procPulseEvent = modkernel32.NewProc("PulseEvent") - procPurgeComm = modkernel32.NewProc("PurgeComm") procQueryDosDeviceW = modkernel32.NewProc("QueryDosDeviceW") procQueryFullProcessImageNameW = modkernel32.NewProc("QueryFullProcessImageNameW") procQueryInformationJobObject = modkernel32.NewProc("QueryInformationJobObject") @@ -343,9 +335,6 @@ var ( procResetEvent = modkernel32.NewProc("ResetEvent") procResizePseudoConsole = modkernel32.NewProc("ResizePseudoConsole") procResumeThread = modkernel32.NewProc("ResumeThread") - procSetCommBreak = modkernel32.NewProc("SetCommBreak") - procSetCommMask = modkernel32.NewProc("SetCommMask") - procSetCommState = modkernel32.NewProc("SetCommState") procSetCommTimeouts = modkernel32.NewProc("SetCommTimeouts") procSetConsoleCursorPosition = modkernel32.NewProc("SetConsoleCursorPosition") procSetConsoleMode = modkernel32.NewProc("SetConsoleMode") @@ -353,6 +342,7 @@ var ( procSetDefaultDllDirectories = modkernel32.NewProc("SetDefaultDllDirectories") procSetDllDirectoryW = modkernel32.NewProc("SetDllDirectoryW") procSetEndOfFile = modkernel32.NewProc("SetEndOfFile") + procSetFileValidData = modkernel32.NewProc("SetFileValidData") procSetEnvironmentVariableW = modkernel32.NewProc("SetEnvironmentVariableW") procSetErrorMode = modkernel32.NewProc("SetErrorMode") procSetEvent = modkernel32.NewProc("SetEvent") @@ -361,7 +351,6 @@ var ( procSetFileInformationByHandle = modkernel32.NewProc("SetFileInformationByHandle") procSetFilePointer = modkernel32.NewProc("SetFilePointer") procSetFileTime = modkernel32.NewProc("SetFileTime") - procSetFileValidData = modkernel32.NewProc("SetFileValidData") procSetHandleInformation = modkernel32.NewProc("SetHandleInformation") procSetInformationJobObject = modkernel32.NewProc("SetInformationJobObject") procSetNamedPipeHandleState = modkernel32.NewProc("SetNamedPipeHandleState") @@ -372,7 +361,6 @@ var ( procSetStdHandle = modkernel32.NewProc("SetStdHandle") procSetVolumeLabelW = modkernel32.NewProc("SetVolumeLabelW") procSetVolumeMountPointW = modkernel32.NewProc("SetVolumeMountPointW") - procSetupComm = modkernel32.NewProc("SetupComm") procSizeofResource = modkernel32.NewProc("SizeofResource") procSleepEx = modkernel32.NewProc("SleepEx") procTerminateJobObject = modkernel32.NewProc("TerminateJobObject") @@ -391,7 +379,6 @@ var ( procVirtualQueryEx = modkernel32.NewProc("VirtualQueryEx") procVirtualUnlock = modkernel32.NewProc("VirtualUnlock") procWTSGetActiveConsoleSessionId = modkernel32.NewProc("WTSGetActiveConsoleSessionId") - procWaitCommEvent = modkernel32.NewProc("WaitCommEvent") procWaitForMultipleObjects = modkernel32.NewProc("WaitForMultipleObjects") procWaitForSingleObject = modkernel32.NewProc("WaitForSingleObject") procWriteConsoleW = modkernel32.NewProc("WriteConsoleW") @@ -402,7 +389,6 @@ var ( procTransmitFile = modmswsock.NewProc("TransmitFile") procNetApiBufferFree = modnetapi32.NewProc("NetApiBufferFree") procNetGetJoinInformation = modnetapi32.NewProc("NetGetJoinInformation") - procNetUserEnum = modnetapi32.NewProc("NetUserEnum") procNetUserGetInfo = modnetapi32.NewProc("NetUserGetInfo") procNtCreateFile = modntdll.NewProc("NtCreateFile") procNtCreateNamedPipeFile = modntdll.NewProc("NtCreateNamedPipeFile") @@ -478,16 +464,12 @@ var ( procGetDesktopWindow = moduser32.NewProc("GetDesktopWindow") procGetForegroundWindow = moduser32.NewProc("GetForegroundWindow") procGetGUIThreadInfo = moduser32.NewProc("GetGUIThreadInfo") - procGetKeyboardLayout = moduser32.NewProc("GetKeyboardLayout") procGetShellWindow = moduser32.NewProc("GetShellWindow") procGetWindowThreadProcessId = moduser32.NewProc("GetWindowThreadProcessId") procIsWindow = moduser32.NewProc("IsWindow") procIsWindowUnicode = moduser32.NewProc("IsWindowUnicode") procIsWindowVisible = moduser32.NewProc("IsWindowVisible") - procLoadKeyboardLayoutW = moduser32.NewProc("LoadKeyboardLayoutW") procMessageBoxW = moduser32.NewProc("MessageBoxW") - procToUnicodeEx = moduser32.NewProc("ToUnicodeEx") - procUnloadKeyboardLayout = moduser32.NewProc("UnloadKeyboardLayout") procCreateEnvironmentBlock = moduserenv.NewProc("CreateEnvironmentBlock") procDestroyEnvironmentBlock = moduserenv.NewProc("DestroyEnvironmentBlock") procGetUserProfileDirectoryW = moduserenv.NewProc("GetUserProfileDirectoryW") @@ -793,14 +775,6 @@ func FreeSid(sid *SID) (err error) { return } -func GetAce(acl *ACL, aceIndex uint32, pAce **ACCESS_ALLOWED_ACE) (err error) { - r1, _, e1 := syscall.Syscall(procGetAce.Addr(), 3, uintptr(unsafe.Pointer(acl)), uintptr(aceIndex), uintptr(unsafe.Pointer(pAce))) - if r1 == 0 { - err = errnoErr(e1) - } - return -} - func GetLengthSid(sid *SID) (len uint32) { r0, _, _ := syscall.Syscall(procGetLengthSid.Addr(), 1, uintptr(unsafe.Pointer(sid)), 0, 0) len = uint32(r0) @@ -1667,22 +1641,6 @@ func CancelIoEx(s Handle, o *Overlapped) (err error) { return } -func ClearCommBreak(handle Handle) (err error) { - r1, _, e1 := syscall.Syscall(procClearCommBreak.Addr(), 1, uintptr(handle), 0, 0) - if r1 == 0 { - err = errnoErr(e1) - } - return -} - -func ClearCommError(handle Handle, lpErrors *uint32, lpStat *ComStat) (err error) { - r1, _, e1 := syscall.Syscall(procClearCommError.Addr(), 3, uintptr(handle), uintptr(unsafe.Pointer(lpErrors)), uintptr(unsafe.Pointer(lpStat))) - if r1 == 0 { - err = errnoErr(e1) - } - return -} - func CloseHandle(handle Handle) (err error) { r1, _, e1 := syscall.Syscall(procCloseHandle.Addr(), 1, uintptr(handle), 0, 0) if r1 == 0 { @@ -1887,14 +1845,6 @@ func DeviceIoControl(handle Handle, ioControlCode uint32, inBuffer *byte, inBuff return } -func DisconnectNamedPipe(pipe Handle) (err error) { - r1, _, e1 := syscall.Syscall(procDisconnectNamedPipe.Addr(), 1, uintptr(pipe), 0, 0) - if r1 == 0 { - err = errnoErr(e1) - } - return -} - func DuplicateHandle(hSourceProcessHandle Handle, hSourceHandle Handle, hTargetProcessHandle Handle, lpTargetHandle *Handle, dwDesiredAccess uint32, bInheritHandle bool, dwOptions uint32) (err error) { var _p0 uint32 if bInheritHandle { @@ -1907,14 +1857,6 @@ func DuplicateHandle(hSourceProcessHandle Handle, hSourceHandle Handle, hTargetP return } -func EscapeCommFunction(handle Handle, dwFunc uint32) (err error) { - r1, _, e1 := syscall.Syscall(procEscapeCommFunction.Addr(), 2, uintptr(handle), uintptr(dwFunc), 0) - if r1 == 0 { - err = errnoErr(e1) - } - return -} - func ExitProcess(exitcode uint32) { syscall.Syscall(procExitProcess.Addr(), 1, uintptr(exitcode), 0, 0) return @@ -2116,22 +2058,6 @@ func GetActiveProcessorCount(groupNumber uint16) (ret uint32) { return } -func GetCommModemStatus(handle Handle, lpModemStat *uint32) (err error) { - r1, _, e1 := syscall.Syscall(procGetCommModemStatus.Addr(), 2, uintptr(handle), uintptr(unsafe.Pointer(lpModemStat)), 0) - if r1 == 0 { - err = errnoErr(e1) - } - return -} - -func GetCommState(handle Handle, lpDCB *DCB) (err error) { - r1, _, e1 := syscall.Syscall(procGetCommState.Addr(), 2, uintptr(handle), uintptr(unsafe.Pointer(lpDCB)), 0) - if r1 == 0 { - err = errnoErr(e1) - } - return -} - func GetCommTimeouts(handle Handle, timeouts *CommTimeouts) (err error) { r1, _, e1 := syscall.Syscall(procGetCommTimeouts.Addr(), 2, uintptr(handle), uintptr(unsafe.Pointer(timeouts)), 0) if r1 == 0 { @@ -2884,14 +2810,6 @@ func PulseEvent(event Handle) (err error) { return } -func PurgeComm(handle Handle, dwFlags uint32) (err error) { - r1, _, e1 := syscall.Syscall(procPurgeComm.Addr(), 2, uintptr(handle), uintptr(dwFlags), 0) - if r1 == 0 { - err = errnoErr(e1) - } - return -} - func QueryDosDevice(deviceName *uint16, targetPath *uint16, max uint32) (n uint32, err error) { r0, _, e1 := syscall.Syscall(procQueryDosDeviceW.Addr(), 3, uintptr(unsafe.Pointer(deviceName)), uintptr(unsafe.Pointer(targetPath)), uintptr(max)) n = uint32(r0) @@ -3006,30 +2924,6 @@ func ResumeThread(thread Handle) (ret uint32, err error) { return } -func SetCommBreak(handle Handle) (err error) { - r1, _, e1 := syscall.Syscall(procSetCommBreak.Addr(), 1, uintptr(handle), 0, 0) - if r1 == 0 { - err = errnoErr(e1) - } - return -} - -func SetCommMask(handle Handle, dwEvtMask uint32) (err error) { - r1, _, e1 := syscall.Syscall(procSetCommMask.Addr(), 2, uintptr(handle), uintptr(dwEvtMask), 0) - if r1 == 0 { - err = errnoErr(e1) - } - return -} - -func SetCommState(handle Handle, lpDCB *DCB) (err error) { - r1, _, e1 := syscall.Syscall(procSetCommState.Addr(), 2, uintptr(handle), uintptr(unsafe.Pointer(lpDCB)), 0) - if r1 == 0 { - err = errnoErr(e1) - } - return -} - func SetCommTimeouts(handle Handle, timeouts *CommTimeouts) (err error) { r1, _, e1 := syscall.Syscall(procSetCommTimeouts.Addr(), 2, uintptr(handle), uintptr(unsafe.Pointer(timeouts)), 0) if r1 == 0 { @@ -3095,6 +2989,14 @@ func SetEndOfFile(handle Handle) (err error) { return } +func SetFileValidData(handle Handle, validDataLength int64) (err error) { + r1, _, e1 := syscall.Syscall(procSetFileValidData.Addr(), 2, uintptr(handle), uintptr(validDataLength), 0) + if r1 == 0 { + err = errnoErr(e1) + } + return +} + func SetEnvironmentVariable(name *uint16, value *uint16) (err error) { r1, _, e1 := syscall.Syscall(procSetEnvironmentVariableW.Addr(), 2, uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(value)), 0) if r1 == 0 { @@ -3158,14 +3060,6 @@ func SetFileTime(handle Handle, ctime *Filetime, atime *Filetime, wtime *Filetim return } -func SetFileValidData(handle Handle, validDataLength int64) (err error) { - r1, _, e1 := syscall.Syscall(procSetFileValidData.Addr(), 2, uintptr(handle), uintptr(validDataLength), 0) - if r1 == 0 { - err = errnoErr(e1) - } - return -} - func SetHandleInformation(handle Handle, mask uint32, flags uint32) (err error) { r1, _, e1 := syscall.Syscall(procSetHandleInformation.Addr(), 3, uintptr(handle), uintptr(mask), uintptr(flags)) if r1 == 0 { @@ -3251,14 +3145,6 @@ func SetVolumeMountPoint(volumeMountPoint *uint16, volumeName *uint16) (err erro return } -func SetupComm(handle Handle, dwInQueue uint32, dwOutQueue uint32) (err error) { - r1, _, e1 := syscall.Syscall(procSetupComm.Addr(), 3, uintptr(handle), uintptr(dwInQueue), uintptr(dwOutQueue)) - if r1 == 0 { - err = errnoErr(e1) - } - return -} - func SizeofResource(module Handle, resInfo Handle) (size uint32, err error) { r0, _, e1 := syscall.Syscall(procSizeofResource.Addr(), 2, uintptr(module), uintptr(resInfo), 0) size = uint32(r0) @@ -3405,14 +3291,6 @@ func WTSGetActiveConsoleSessionId() (sessionID uint32) { return } -func WaitCommEvent(handle Handle, lpEvtMask *uint32, lpOverlapped *Overlapped) (err error) { - r1, _, e1 := syscall.Syscall(procWaitCommEvent.Addr(), 3, uintptr(handle), uintptr(unsafe.Pointer(lpEvtMask)), uintptr(unsafe.Pointer(lpOverlapped))) - if r1 == 0 { - err = errnoErr(e1) - } - return -} - func waitForMultipleObjects(count uint32, handles uintptr, waitAll bool, waitMilliseconds uint32) (event uint32, err error) { var _p0 uint32 if waitAll { @@ -3500,14 +3378,6 @@ func NetGetJoinInformation(server *uint16, name **uint16, bufType *uint32) (nete return } -func NetUserEnum(serverName *uint16, level uint32, filter uint32, buf **byte, prefMaxLen uint32, entriesRead *uint32, totalEntries *uint32, resumeHandle *uint32) (neterr error) { - r0, _, _ := syscall.Syscall9(procNetUserEnum.Addr(), 8, uintptr(unsafe.Pointer(serverName)), uintptr(level), uintptr(filter), uintptr(unsafe.Pointer(buf)), uintptr(prefMaxLen), uintptr(unsafe.Pointer(entriesRead)), uintptr(unsafe.Pointer(totalEntries)), uintptr(unsafe.Pointer(resumeHandle)), 0) - if r0 != 0 { - neterr = syscall.Errno(r0) - } - return -} - func NetUserGetInfo(serverName *uint16, userName *uint16, level uint32, buf **byte) (neterr error) { r0, _, _ := syscall.Syscall6(procNetUserGetInfo.Addr(), 4, uintptr(unsafe.Pointer(serverName)), uintptr(unsafe.Pointer(userName)), uintptr(level), uintptr(unsafe.Pointer(buf)), 0, 0) if r0 != 0 { @@ -4086,12 +3956,6 @@ func GetGUIThreadInfo(thread uint32, info *GUIThreadInfo) (err error) { return } -func GetKeyboardLayout(tid uint32) (hkl Handle) { - r0, _, _ := syscall.Syscall(procGetKeyboardLayout.Addr(), 1, uintptr(tid), 0, 0) - hkl = Handle(r0) - return -} - func GetShellWindow() (shellWindow HWND) { r0, _, _ := syscall.Syscall(procGetShellWindow.Addr(), 0, 0, 0, 0) shellWindow = HWND(r0) @@ -4125,15 +3989,6 @@ func IsWindowVisible(hwnd HWND) (isVisible bool) { return } -func LoadKeyboardLayout(name *uint16, flags uint32) (hkl Handle, err error) { - r0, _, e1 := syscall.Syscall(procLoadKeyboardLayoutW.Addr(), 2, uintptr(unsafe.Pointer(name)), uintptr(flags), 0) - hkl = Handle(r0) - if hkl == 0 { - err = errnoErr(e1) - } - return -} - func MessageBox(hwnd HWND, text *uint16, caption *uint16, boxtype uint32) (ret int32, err error) { r0, _, e1 := syscall.Syscall6(procMessageBoxW.Addr(), 4, uintptr(hwnd), uintptr(unsafe.Pointer(text)), uintptr(unsafe.Pointer(caption)), uintptr(boxtype), 0, 0) ret = int32(r0) @@ -4143,20 +3998,6 @@ func MessageBox(hwnd HWND, text *uint16, caption *uint16, boxtype uint32) (ret i return } -func ToUnicodeEx(vkey uint32, scancode uint32, keystate *byte, pwszBuff *uint16, cchBuff int32, flags uint32, hkl Handle) (ret int32) { - r0, _, _ := syscall.Syscall9(procToUnicodeEx.Addr(), 7, uintptr(vkey), uintptr(scancode), uintptr(unsafe.Pointer(keystate)), uintptr(unsafe.Pointer(pwszBuff)), uintptr(cchBuff), uintptr(flags), uintptr(hkl), 0, 0) - ret = int32(r0) - return -} - -func UnloadKeyboardLayout(hkl Handle) (err error) { - r1, _, e1 := syscall.Syscall(procUnloadKeyboardLayout.Addr(), 1, uintptr(hkl), 0, 0) - if r1 == 0 { - err = errnoErr(e1) - } - return -} - func CreateEnvironmentBlock(block **uint16, token Token, inheritExisting bool) (err error) { var _p0 uint32 if inheritExisting { diff --git a/services/vendor/google.golang.org/protobuf/encoding/prototext/decode.go b/services/vendor/google.golang.org/protobuf/encoding/prototext/decode.go index 24bc98ac..a45f112b 100644 --- a/services/vendor/google.golang.org/protobuf/encoding/prototext/decode.go +++ b/services/vendor/google.golang.org/protobuf/encoding/prototext/decode.go @@ -84,7 +84,7 @@ type decoder struct { } // newError returns an error object with position info. -func (d decoder) newError(pos int, f string, x ...any) error { +func (d decoder) newError(pos int, f string, x ...interface{}) error { line, column := d.Position(pos) head := fmt.Sprintf("(line %d:%d): ", line, column) return errors.New(head+f, x...) @@ -96,7 +96,7 @@ func (d decoder) unexpectedTokenError(tok text.Token) error { } // syntaxError returns a syntax error for given position. -func (d decoder) syntaxError(pos int, f string, x ...any) error { +func (d decoder) syntaxError(pos int, f string, x ...interface{}) error { line, column := d.Position(pos) head := fmt.Sprintf("syntax error (line %d:%d): ", line, column) return errors.New(head+f, x...) diff --git a/services/vendor/google.golang.org/protobuf/encoding/prototext/encode.go b/services/vendor/google.golang.org/protobuf/encoding/prototext/encode.go index 1f57e661..95967e81 100644 --- a/services/vendor/google.golang.org/protobuf/encoding/prototext/encode.go +++ b/services/vendor/google.golang.org/protobuf/encoding/prototext/encode.go @@ -27,17 +27,15 @@ const defaultIndent = " " // Format formats the message as a multiline string. // This function is only intended for human consumption and ignores errors. -// Do not depend on the output being stable. Its output will change across -// different builds of your program, even when using the same version of the -// protobuf module. +// Do not depend on the output being stable. It may change over time across +// different versions of the program. func Format(m proto.Message) string { return MarshalOptions{Multiline: true}.Format(m) } // Marshal writes the given [proto.Message] in textproto format using default -// options. Do not depend on the output being stable. Its output will change -// across different builds of your program, even when using the same version of -// the protobuf module. +// options. Do not depend on the output being stable. It may change over time +// across different versions of the program. func Marshal(m proto.Message) ([]byte, error) { return MarshalOptions{}.Marshal(m) } @@ -86,9 +84,8 @@ type MarshalOptions struct { // Format formats the message as a string. // This method is only intended for human consumption and ignores errors. -// Do not depend on the output being stable. Its output will change across -// different builds of your program, even when using the same version of the -// protobuf module. +// Do not depend on the output being stable. It may change over time across +// different versions of the program. func (o MarshalOptions) Format(m proto.Message) string { if m == nil || !m.ProtoReflect().IsValid() { return "" // invalid syntax, but okay since this is for debugging @@ -101,9 +98,8 @@ func (o MarshalOptions) Format(m proto.Message) string { } // Marshal writes the given [proto.Message] in textproto format using options in -// MarshalOptions object. Do not depend on the output being stable. Its output -// will change across different builds of your program, even when using the -// same version of the protobuf module. +// MarshalOptions object. Do not depend on the output being stable. It may +// change over time across different versions of the program. func (o MarshalOptions) Marshal(m proto.Message) ([]byte, error) { return o.marshal(nil, m) } diff --git a/services/vendor/google.golang.org/protobuf/internal/descfmt/stringer.go b/services/vendor/google.golang.org/protobuf/internal/descfmt/stringer.go index 87e46bd4..a45625c8 100644 --- a/services/vendor/google.golang.org/protobuf/internal/descfmt/stringer.go +++ b/services/vendor/google.golang.org/protobuf/internal/descfmt/stringer.go @@ -252,7 +252,6 @@ func formatDescOpt(t protoreflect.Descriptor, isRoot, allowMulti bool, record fu {rv.MethodByName("Values"), "Values"}, {rv.MethodByName("ReservedNames"), "ReservedNames"}, {rv.MethodByName("ReservedRanges"), "ReservedRanges"}, - {rv.MethodByName("IsClosed"), "IsClosed"}, }...) case protoreflect.EnumValueDescriptor: diff --git a/services/vendor/google.golang.org/protobuf/internal/editiondefaults/editions_defaults.binpb b/services/vendor/google.golang.org/protobuf/internal/editiondefaults/editions_defaults.binpb index ff6a3836..18f07568 100644 Binary files a/services/vendor/google.golang.org/protobuf/internal/editiondefaults/editions_defaults.binpb and b/services/vendor/google.golang.org/protobuf/internal/editiondefaults/editions_defaults.binpb differ diff --git a/services/vendor/google.golang.org/protobuf/internal/encoding/tag/tag.go b/services/vendor/google.golang.org/protobuf/internal/encoding/tag/tag.go index 7e87c760..373d2083 100644 --- a/services/vendor/google.golang.org/protobuf/internal/encoding/tag/tag.go +++ b/services/vendor/google.golang.org/protobuf/internal/encoding/tag/tag.go @@ -32,7 +32,6 @@ var byteType = reflect.TypeOf(byte(0)) func Unmarshal(tag string, goType reflect.Type, evs protoreflect.EnumValueDescriptors) protoreflect.FieldDescriptor { f := new(filedesc.Field) f.L0.ParentFile = filedesc.SurrogateProto2 - f.L1.EditionFeatures = f.L0.ParentFile.L1.EditionFeatures for len(tag) > 0 { i := strings.IndexByte(tag, ',') if i < 0 { @@ -108,7 +107,8 @@ func Unmarshal(tag string, goType reflect.Type, evs protoreflect.EnumValueDescri f.L1.StringName.InitJSON(jsonName) } case s == "packed": - f.L1.EditionFeatures.IsPacked = true + f.L1.HasPacked = true + f.L1.IsPacked = true case strings.HasPrefix(s, "weak="): f.L1.IsWeak = true f.L1.Message = filedesc.PlaceholderMessage(protoreflect.FullName(s[len("weak="):])) diff --git a/services/vendor/google.golang.org/protobuf/internal/encoding/text/decode.go b/services/vendor/google.golang.org/protobuf/internal/encoding/text/decode.go index 099b2bf4..87853e78 100644 --- a/services/vendor/google.golang.org/protobuf/internal/encoding/text/decode.go +++ b/services/vendor/google.golang.org/protobuf/internal/encoding/text/decode.go @@ -601,7 +601,7 @@ func (d *Decoder) consumeToken(kind Kind, size int, attrs uint8) Token { // newSyntaxError returns a syntax error with line and column information for // current position. -func (d *Decoder) newSyntaxError(f string, x ...any) error { +func (d *Decoder) newSyntaxError(f string, x ...interface{}) error { e := errors.New(f, x...) line, column := d.Position(len(d.orig) - len(d.in)) return errors.New("syntax error (line %d:%d): %v", line, column, e) diff --git a/services/vendor/google.golang.org/protobuf/internal/errors/errors.go b/services/vendor/google.golang.org/protobuf/internal/errors/errors.go index c2d6bd52..20c17b35 100644 --- a/services/vendor/google.golang.org/protobuf/internal/errors/errors.go +++ b/services/vendor/google.golang.org/protobuf/internal/errors/errors.go @@ -17,7 +17,7 @@ var Error = errors.New("protobuf error") // New formats a string according to the format specifier and arguments and // returns an error that has a "proto" prefix. -func New(f string, x ...any) error { +func New(f string, x ...interface{}) error { return &prefixError{s: format(f, x...)} } @@ -43,7 +43,7 @@ func (e *prefixError) Unwrap() error { // Wrap returns an error that has a "proto" prefix, the formatted string described // by the format specifier and arguments, and a suffix of err. The error wraps err. -func Wrap(err error, f string, x ...any) error { +func Wrap(err error, f string, x ...interface{}) error { return &wrapError{ s: format(f, x...), err: err, @@ -67,7 +67,7 @@ func (e *wrapError) Is(target error) bool { return target == Error } -func format(f string, x ...any) string { +func format(f string, x ...interface{}) string { // avoid "proto: " prefix when chaining for i := 0; i < len(x); i++ { switch e := x[i].(type) { @@ -87,18 +87,3 @@ func InvalidUTF8(name string) error { func RequiredNotSet(name string) error { return New("required field %v not set", name) } - -type SizeMismatchError struct { - Calculated, Measured int -} - -func (e *SizeMismatchError) Error() string { - return fmt.Sprintf("size mismatch (see https://github.com/golang/protobuf/issues/1609): calculated=%d, measured=%d", e.Calculated, e.Measured) -} - -func MismatchedSizeCalculation(calculated, measured int) error { - return &SizeMismatchError{ - Calculated: calculated, - Measured: measured, - } -} diff --git a/services/vendor/google.golang.org/protobuf/internal/filedesc/desc.go b/services/vendor/google.golang.org/protobuf/internal/filedesc/desc.go index df53ff40..8826bcf4 100644 --- a/services/vendor/google.golang.org/protobuf/internal/filedesc/desc.go +++ b/services/vendor/google.golang.org/protobuf/internal/filedesc/desc.go @@ -7,7 +7,6 @@ package filedesc import ( "bytes" "fmt" - "strings" "sync" "sync/atomic" @@ -109,12 +108,9 @@ func (fd *File) ParentFile() protoreflect.FileDescriptor { return fd } func (fd *File) Parent() protoreflect.Descriptor { return nil } func (fd *File) Index() int { return 0 } func (fd *File) Syntax() protoreflect.Syntax { return fd.L1.Syntax } - -// Not exported and just used to reconstruct the original FileDescriptor proto -func (fd *File) Edition() int32 { return int32(fd.L1.Edition) } -func (fd *File) Name() protoreflect.Name { return fd.L1.Package.Name() } -func (fd *File) FullName() protoreflect.FullName { return fd.L1.Package } -func (fd *File) IsPlaceholder() bool { return false } +func (fd *File) Name() protoreflect.Name { return fd.L1.Package.Name() } +func (fd *File) FullName() protoreflect.FullName { return fd.L1.Package } +func (fd *File) IsPlaceholder() bool { return false } func (fd *File) Options() protoreflect.ProtoMessage { if f := fd.lazyInit().Options; f != nil { return f() @@ -206,9 +202,6 @@ func (ed *Enum) lazyInit() *EnumL2 { ed.L0.ParentFile.lazyInit() // implicitly initializes L2 return ed.L2 } -func (ed *Enum) IsClosed() bool { - return !ed.L1.EditionFeatures.IsOpenEnum -} func (ed *EnumValue) Options() protoreflect.ProtoMessage { if f := ed.L1.Options; f != nil { @@ -258,6 +251,10 @@ type ( StringName stringName IsProto3Optional bool // promoted from google.protobuf.FieldDescriptorProto IsWeak bool // promoted from google.protobuf.FieldOptions + HasPacked bool // promoted from google.protobuf.FieldOptions + IsPacked bool // promoted from google.protobuf.FieldOptions + HasEnforceUTF8 bool // promoted from google.protobuf.FieldOptions + EnforceUTF8 bool // promoted from google.protobuf.FieldOptions Default defaultValue ContainingOneof protoreflect.OneofDescriptor // must be consistent with Message.Oneofs.Fields Enum protoreflect.EnumDescriptor @@ -334,7 +331,8 @@ func (fd *Field) HasPresence() bool { if fd.L1.Cardinality == protoreflect.Repeated { return false } - return fd.IsExtension() || fd.L1.EditionFeatures.IsFieldPresence || fd.L1.Message != nil || fd.L1.ContainingOneof != nil + explicitFieldPresence := fd.Syntax() == protoreflect.Editions && fd.L1.EditionFeatures.IsFieldPresence + return fd.Syntax() == protoreflect.Proto2 || explicitFieldPresence || fd.L1.Message != nil || fd.L1.ContainingOneof != nil } func (fd *Field) HasOptionalKeyword() bool { return (fd.L0.ParentFile.L1.Syntax == protoreflect.Proto2 && fd.L1.Cardinality == protoreflect.Optional && fd.L1.ContainingOneof == nil) || fd.L1.IsProto3Optional @@ -347,7 +345,14 @@ func (fd *Field) IsPacked() bool { case protoreflect.StringKind, protoreflect.BytesKind, protoreflect.MessageKind, protoreflect.GroupKind: return false } - return fd.L1.EditionFeatures.IsPacked + if fd.L0.ParentFile.L1.Syntax == protoreflect.Editions { + return fd.L1.EditionFeatures.IsPacked + } + if fd.L0.ParentFile.L1.Syntax == protoreflect.Proto3 { + // proto3 repeated fields are packed by default. + return !fd.L1.HasPacked || fd.L1.IsPacked + } + return fd.L1.IsPacked } func (fd *Field) IsExtension() bool { return false } func (fd *Field) IsWeak() bool { return fd.L1.IsWeak } @@ -383,10 +388,6 @@ func (fd *Field) Message() protoreflect.MessageDescriptor { } return fd.L1.Message } -func (fd *Field) IsMapEntry() bool { - parent, ok := fd.L0.Parent.(protoreflect.MessageDescriptor) - return ok && parent.IsMapEntry() -} func (fd *Field) Format(s fmt.State, r rune) { descfmt.FormatDesc(s, r, fd) } func (fd *Field) ProtoType(protoreflect.FieldDescriptor) {} @@ -398,7 +399,13 @@ func (fd *Field) ProtoType(protoreflect.FieldDescriptor) {} // WARNING: This method is exempt from the compatibility promise and may be // removed in the future without warning. func (fd *Field) EnforceUTF8() bool { - return fd.L1.EditionFeatures.IsUTF8Validated + if fd.L0.ParentFile.L1.Syntax == protoreflect.Editions { + return fd.L1.EditionFeatures.IsUTF8Validated + } + if fd.L1.HasEnforceUTF8 { + return fd.L1.EnforceUTF8 + } + return fd.L0.ParentFile.L1.Syntax == protoreflect.Proto3 } func (od *Oneof) IsSynthetic() bool { @@ -431,6 +438,7 @@ type ( Options func() protoreflect.ProtoMessage StringName stringName IsProto3Optional bool // promoted from google.protobuf.FieldDescriptorProto + IsPacked bool // promoted from google.protobuf.FieldOptions Default defaultValue Enum protoreflect.EnumDescriptor Message protoreflect.MessageDescriptor @@ -453,16 +461,7 @@ func (xd *Extension) HasPresence() bool { return xd.L1.Cardi func (xd *Extension) HasOptionalKeyword() bool { return (xd.L0.ParentFile.L1.Syntax == protoreflect.Proto2 && xd.L1.Cardinality == protoreflect.Optional) || xd.lazyInit().IsProto3Optional } -func (xd *Extension) IsPacked() bool { - if xd.L1.Cardinality != protoreflect.Repeated { - return false - } - switch xd.L1.Kind { - case protoreflect.StringKind, protoreflect.BytesKind, protoreflect.MessageKind, protoreflect.GroupKind: - return false - } - return xd.L1.EditionFeatures.IsPacked -} +func (xd *Extension) IsPacked() bool { return xd.lazyInit().IsPacked } func (xd *Extension) IsExtension() bool { return true } func (xd *Extension) IsWeak() bool { return false } func (xd *Extension) IsList() bool { return xd.Cardinality() == protoreflect.Repeated } @@ -543,9 +542,8 @@ func (md *Method) ProtoInternal(pragma.DoNotImplement) {} // Surrogate files are can be used to create standalone descriptors // where the syntax is only information derived from the parent file. var ( - SurrogateProto2 = &File{L1: FileL1{Syntax: protoreflect.Proto2}, L2: &FileL2{}} - SurrogateProto3 = &File{L1: FileL1{Syntax: protoreflect.Proto3}, L2: &FileL2{}} - SurrogateEdition2023 = &File{L1: FileL1{Syntax: protoreflect.Editions, Edition: Edition2023}, L2: &FileL2{}} + SurrogateProto2 = &File{L1: FileL1{Syntax: protoreflect.Proto2}, L2: &FileL2{}} + SurrogateProto3 = &File{L1: FileL1{Syntax: protoreflect.Proto3}, L2: &FileL2{}} ) type ( @@ -587,34 +585,6 @@ func (s *stringName) InitJSON(name string) { s.nameJSON = name } -// Returns true if this field is structured like the synthetic field of a proto2 -// group. This allows us to expand our treatment of delimited fields without -// breaking proto2 files that have been upgraded to editions. -func isGroupLike(fd protoreflect.FieldDescriptor) bool { - // Groups are always group types. - if fd.Kind() != protoreflect.GroupKind { - return false - } - - // Group fields are always the lowercase type name. - if strings.ToLower(string(fd.Message().Name())) != string(fd.Name()) { - return false - } - - // Groups could only be defined in the same file they're used. - if fd.Message().ParentFile() != fd.ParentFile() { - return false - } - - // Group messages are always defined in the same scope as the field. File - // level extensions will compare NULL == NULL here, which is why the file - // comparison above is necessary to ensure both come from the same file. - if fd.IsExtension() { - return fd.Parent() == fd.Message().Parent() - } - return fd.ContainingMessage() == fd.Message().Parent() -} - func (s *stringName) lazyInit(fd protoreflect.FieldDescriptor) *stringName { s.once.Do(func() { if fd.IsExtension() { @@ -635,7 +605,7 @@ func (s *stringName) lazyInit(fd protoreflect.FieldDescriptor) *stringName { // Format the text name. s.nameText = string(fd.Name()) - if isGroupLike(fd) { + if fd.Kind() == protoreflect.GroupKind { s.nameText = string(fd.Message().Name()) } } diff --git a/services/vendor/google.golang.org/protobuf/internal/filedesc/desc_init.go b/services/vendor/google.golang.org/protobuf/internal/filedesc/desc_init.go index 8a57d60b..237e64fd 100644 --- a/services/vendor/google.golang.org/protobuf/internal/filedesc/desc_init.go +++ b/services/vendor/google.golang.org/protobuf/internal/filedesc/desc_init.go @@ -113,10 +113,8 @@ func (fd *File) unmarshalSeed(b []byte) { switch string(v) { case "proto2": fd.L1.Syntax = protoreflect.Proto2 - fd.L1.Edition = EditionProto2 case "proto3": fd.L1.Syntax = protoreflect.Proto3 - fd.L1.Edition = EditionProto3 case "editions": fd.L1.Syntax = protoreflect.Editions default: @@ -179,10 +177,11 @@ func (fd *File) unmarshalSeed(b []byte) { // If syntax is missing, it is assumed to be proto2. if fd.L1.Syntax == 0 { fd.L1.Syntax = protoreflect.Proto2 - fd.L1.Edition = EditionProto2 } - fd.L1.EditionFeatures = getFeaturesFor(fd.L1.Edition) + if fd.L1.Syntax == protoreflect.Editions { + fd.L1.EditionFeatures = getFeaturesFor(fd.L1.Edition) + } // Parse editions features from options if any if options != nil { @@ -268,7 +267,6 @@ func (ed *Enum) unmarshalSeed(b []byte, sb *strs.Builder, pf *File, pd protorefl ed.L0.ParentFile = pf ed.L0.Parent = pd ed.L0.Index = i - ed.L1.EditionFeatures = featuresFromParentDesc(ed.Parent()) var numValues int for b := b; len(b) > 0; { @@ -445,7 +443,6 @@ func (xd *Extension) unmarshalSeed(b []byte, sb *strs.Builder, pf *File, pd prot xd.L0.ParentFile = pf xd.L0.Parent = pd xd.L0.Index = i - xd.L1.EditionFeatures = featuresFromParentDesc(pd) for len(b) > 0 { num, typ, n := protowire.ConsumeTag(b) @@ -470,38 +467,6 @@ func (xd *Extension) unmarshalSeed(b []byte, sb *strs.Builder, pf *File, pd prot xd.L0.FullName = appendFullName(sb, pd.FullName(), v) case genid.FieldDescriptorProto_Extendee_field_number: xd.L1.Extendee = PlaceholderMessage(makeFullName(sb, v)) - case genid.FieldDescriptorProto_Options_field_number: - xd.unmarshalOptions(v) - } - default: - m := protowire.ConsumeFieldValue(num, typ, b) - b = b[m:] - } - } - - if xd.L1.Kind == protoreflect.MessageKind && xd.L1.EditionFeatures.IsDelimitedEncoded { - xd.L1.Kind = protoreflect.GroupKind - } -} - -func (xd *Extension) unmarshalOptions(b []byte) { - for len(b) > 0 { - num, typ, n := protowire.ConsumeTag(b) - b = b[n:] - switch typ { - case protowire.VarintType: - v, m := protowire.ConsumeVarint(b) - b = b[m:] - switch num { - case genid.FieldOptions_Packed_field_number: - xd.L1.EditionFeatures.IsPacked = protowire.DecodeBool(v) - } - case protowire.BytesType: - v, m := protowire.ConsumeBytes(b) - b = b[m:] - switch num { - case genid.FieldOptions_Features_field_number: - xd.L1.EditionFeatures = unmarshalFeatureSet(v, xd.L1.EditionFeatures) } default: m := protowire.ConsumeFieldValue(num, typ, b) @@ -534,7 +499,7 @@ func (sd *Service) unmarshalSeed(b []byte, sb *strs.Builder, pf *File, pd protor } var nameBuilderPool = sync.Pool{ - New: func() any { return new(strs.Builder) }, + New: func() interface{} { return new(strs.Builder) }, } func getBuilder() *strs.Builder { diff --git a/services/vendor/google.golang.org/protobuf/internal/filedesc/desc_lazy.go b/services/vendor/google.golang.org/protobuf/internal/filedesc/desc_lazy.go index e56c91a8..482a61cc 100644 --- a/services/vendor/google.golang.org/protobuf/internal/filedesc/desc_lazy.go +++ b/services/vendor/google.golang.org/protobuf/internal/filedesc/desc_lazy.go @@ -45,11 +45,6 @@ func (file *File) resolveMessages() { case protoreflect.MessageKind, protoreflect.GroupKind: fd.L1.Message = file.resolveMessageDependency(fd.L1.Message, listFieldDeps, depIdx) depIdx++ - if fd.L1.Kind == protoreflect.GroupKind && (fd.IsMap() || fd.IsMapEntry()) { - // A map field might inherit delimited encoding from a file-wide default feature. - // But maps never actually use delimited encoding. (At least for now...) - fd.L1.Kind = protoreflect.MessageKind - } } // Default is resolved here since it depends on Enum being resolved. @@ -471,10 +466,10 @@ func (fd *Field) unmarshalFull(b []byte, sb *strs.Builder, pf *File, pd protoref b = b[m:] } } - if fd.L1.Kind == protoreflect.MessageKind && fd.L1.EditionFeatures.IsDelimitedEncoded { + if fd.Syntax() == protoreflect.Editions && fd.L1.Kind == protoreflect.MessageKind && fd.L1.EditionFeatures.IsDelimitedEncoded { fd.L1.Kind = protoreflect.GroupKind } - if fd.L1.EditionFeatures.IsLegacyRequired { + if fd.Syntax() == protoreflect.Editions && fd.L1.EditionFeatures.IsLegacyRequired { fd.L1.Cardinality = protoreflect.Required } if rawTypeName != nil { @@ -501,11 +496,13 @@ func (fd *Field) unmarshalOptions(b []byte) { b = b[m:] switch num { case genid.FieldOptions_Packed_field_number: - fd.L1.EditionFeatures.IsPacked = protowire.DecodeBool(v) + fd.L1.HasPacked = true + fd.L1.IsPacked = protowire.DecodeBool(v) case genid.FieldOptions_Weak_field_number: fd.L1.IsWeak = protowire.DecodeBool(v) case FieldOptions_EnforceUTF8: - fd.L1.EditionFeatures.IsUTF8Validated = protowire.DecodeBool(v) + fd.L1.HasEnforceUTF8 = true + fd.L1.EnforceUTF8 = protowire.DecodeBool(v) } case protowire.BytesType: v, m := protowire.ConsumeBytes(b) @@ -551,6 +548,7 @@ func (od *Oneof) unmarshalFull(b []byte, sb *strs.Builder, pf *File, pd protoref func (xd *Extension) unmarshalFull(b []byte, sb *strs.Builder) { var rawTypeName []byte var rawOptions []byte + xd.L1.EditionFeatures = featuresFromParentDesc(xd.L1.Extendee) xd.L2 = new(ExtensionL2) for len(b) > 0 { num, typ, n := protowire.ConsumeTag(b) @@ -574,6 +572,7 @@ func (xd *Extension) unmarshalFull(b []byte, sb *strs.Builder) { case genid.FieldDescriptorProto_TypeName_field_number: rawTypeName = v case genid.FieldDescriptorProto_Options_field_number: + xd.unmarshalOptions(v) rawOptions = appendOptions(rawOptions, v) } default: @@ -581,6 +580,12 @@ func (xd *Extension) unmarshalFull(b []byte, sb *strs.Builder) { b = b[m:] } } + if xd.Syntax() == protoreflect.Editions && xd.L1.Kind == protoreflect.MessageKind && xd.L1.EditionFeatures.IsDelimitedEncoded { + xd.L1.Kind = protoreflect.GroupKind + } + if xd.Syntax() == protoreflect.Editions && xd.L1.EditionFeatures.IsLegacyRequired { + xd.L1.Cardinality = protoreflect.Required + } if rawTypeName != nil { name := makeFullName(sb, rawTypeName) switch xd.L1.Kind { @@ -593,6 +598,32 @@ func (xd *Extension) unmarshalFull(b []byte, sb *strs.Builder) { xd.L2.Options = xd.L0.ParentFile.builder.optionsUnmarshaler(&descopts.Field, rawOptions) } +func (xd *Extension) unmarshalOptions(b []byte) { + for len(b) > 0 { + num, typ, n := protowire.ConsumeTag(b) + b = b[n:] + switch typ { + case protowire.VarintType: + v, m := protowire.ConsumeVarint(b) + b = b[m:] + switch num { + case genid.FieldOptions_Packed_field_number: + xd.L2.IsPacked = protowire.DecodeBool(v) + } + case protowire.BytesType: + v, m := protowire.ConsumeBytes(b) + b = b[m:] + switch num { + case genid.FieldOptions_Features_field_number: + xd.L1.EditionFeatures = unmarshalFeatureSet(v, xd.L1.EditionFeatures) + } + default: + m := protowire.ConsumeFieldValue(num, typ, b) + b = b[m:] + } + } +} + func (sd *Service) unmarshalFull(b []byte, sb *strs.Builder) { var rawMethods [][]byte var rawOptions []byte diff --git a/services/vendor/google.golang.org/protobuf/internal/filedesc/desc_list_gen.go b/services/vendor/google.golang.org/protobuf/internal/filedesc/desc_list_gen.go index f4107c05..30db19fd 100644 --- a/services/vendor/google.golang.org/protobuf/internal/filedesc/desc_list_gen.go +++ b/services/vendor/google.golang.org/protobuf/internal/filedesc/desc_list_gen.go @@ -8,7 +8,6 @@ package filedesc import ( "fmt" - "strings" "sync" "google.golang.org/protobuf/internal/descfmt" @@ -199,16 +198,6 @@ func (p *Fields) lazyInit() *Fields { if _, ok := p.byText[d.TextName()]; !ok { p.byText[d.TextName()] = d } - if isGroupLike(d) { - lowerJSONName := strings.ToLower(d.JSONName()) - if _, ok := p.byJSON[lowerJSONName]; !ok { - p.byJSON[lowerJSONName] = d - } - lowerTextName := strings.ToLower(d.TextName()) - if _, ok := p.byText[lowerTextName]; !ok { - p.byText[lowerTextName] = d - } - } if _, ok := p.byNum[d.Number()]; !ok { p.byNum[d.Number()] = d } diff --git a/services/vendor/google.golang.org/protobuf/internal/filedesc/editions.go b/services/vendor/google.golang.org/protobuf/internal/filedesc/editions.go index 11f5f356..0375a49d 100644 --- a/services/vendor/google.golang.org/protobuf/internal/filedesc/editions.go +++ b/services/vendor/google.golang.org/protobuf/internal/filedesc/editions.go @@ -14,13 +14,9 @@ import ( ) var defaultsCache = make(map[Edition]EditionFeatures) -var defaultsKeys = []Edition{} func init() { unmarshalEditionDefaults(editiondefaults.Defaults) - SurrogateProto2.L1.EditionFeatures = getFeaturesFor(EditionProto2) - SurrogateProto3.L1.EditionFeatures = getFeaturesFor(EditionProto3) - SurrogateEdition2023.L1.EditionFeatures = getFeaturesFor(Edition2023) } func unmarshalGoFeature(b []byte, parent EditionFeatures) EditionFeatures { @@ -108,15 +104,12 @@ func unmarshalEditionDefault(b []byte) { v, m := protowire.ConsumeBytes(b) b = b[m:] switch num { - case genid.FeatureSetDefaults_FeatureSetEditionDefault_FixedFeatures_field_number: - fs = unmarshalFeatureSet(v, fs) - case genid.FeatureSetDefaults_FeatureSetEditionDefault_OverridableFeatures_field_number: + case genid.FeatureSetDefaults_FeatureSetEditionDefault_Features_field_number: fs = unmarshalFeatureSet(v, fs) } } } defaultsCache[ed] = fs - defaultsKeys = append(defaultsKeys, ed) } func unmarshalEditionDefaults(b []byte) { @@ -142,15 +135,8 @@ func unmarshalEditionDefaults(b []byte) { } func getFeaturesFor(ed Edition) EditionFeatures { - match := EditionUnknown - for _, key := range defaultsKeys { - if key > ed { - break - } - match = key - } - if match == EditionUnknown { - panic(fmt.Sprintf("unsupported edition: %v", ed)) + if def, ok := defaultsCache[ed]; ok { + return def } - return defaultsCache[match] + panic(fmt.Sprintf("unsupported edition: %v", ed)) } diff --git a/services/vendor/google.golang.org/protobuf/internal/filedesc/placeholder.go b/services/vendor/google.golang.org/protobuf/internal/filedesc/placeholder.go index bfb3b841..28240ebc 100644 --- a/services/vendor/google.golang.org/protobuf/internal/filedesc/placeholder.go +++ b/services/vendor/google.golang.org/protobuf/internal/filedesc/placeholder.go @@ -63,7 +63,6 @@ func (e PlaceholderEnum) Options() protoreflect.ProtoMessage { return des func (e PlaceholderEnum) Values() protoreflect.EnumValueDescriptors { return emptyEnumValues } func (e PlaceholderEnum) ReservedNames() protoreflect.Names { return emptyNames } func (e PlaceholderEnum) ReservedRanges() protoreflect.EnumRanges { return emptyEnumRanges } -func (e PlaceholderEnum) IsClosed() bool { return false } func (e PlaceholderEnum) ProtoType(protoreflect.EnumDescriptor) { return } func (e PlaceholderEnum) ProtoInternal(pragma.DoNotImplement) { return } diff --git a/services/vendor/google.golang.org/protobuf/internal/filetype/build.go b/services/vendor/google.golang.org/protobuf/internal/filetype/build.go index ba83fea4..f0e38c4e 100644 --- a/services/vendor/google.golang.org/protobuf/internal/filetype/build.go +++ b/services/vendor/google.golang.org/protobuf/internal/filetype/build.go @@ -68,7 +68,7 @@ type Builder struct { // and for input and output messages referenced by service methods. // Dependencies must come after declarations, but the ordering of // dependencies themselves is unspecified. - GoTypes []any + GoTypes []interface{} // DependencyIndexes is an ordered list of indexes into GoTypes for the // dependencies of messages, extensions, or services. @@ -268,7 +268,7 @@ func (x depIdxs) Get(i, j int32) int32 { type ( resolverByIndex struct { - goTypes []any + goTypes []interface{} depIdxs depIdxs fileRegistry } diff --git a/services/vendor/google.golang.org/protobuf/internal/genid/descriptor_gen.go b/services/vendor/google.golang.org/protobuf/internal/genid/descriptor_gen.go index f30ab6b5..40272c89 100644 --- a/services/vendor/google.golang.org/protobuf/internal/genid/descriptor_gen.go +++ b/services/vendor/google.golang.org/protobuf/internal/genid/descriptor_gen.go @@ -21,7 +21,6 @@ const ( // Enum values for google.protobuf.Edition. const ( Edition_EDITION_UNKNOWN_enum_value = 0 - Edition_EDITION_LEGACY_enum_value = 900 Edition_EDITION_PROTO2_enum_value = 998 Edition_EDITION_PROTO3_enum_value = 999 Edition_EDITION_2023_enum_value = 1000 @@ -654,7 +653,6 @@ const ( FieldOptions_Targets_field_name protoreflect.Name = "targets" FieldOptions_EditionDefaults_field_name protoreflect.Name = "edition_defaults" FieldOptions_Features_field_name protoreflect.Name = "features" - FieldOptions_FeatureSupport_field_name protoreflect.Name = "feature_support" FieldOptions_UninterpretedOption_field_name protoreflect.Name = "uninterpreted_option" FieldOptions_Ctype_field_fullname protoreflect.FullName = "google.protobuf.FieldOptions.ctype" @@ -669,7 +667,6 @@ const ( FieldOptions_Targets_field_fullname protoreflect.FullName = "google.protobuf.FieldOptions.targets" FieldOptions_EditionDefaults_field_fullname protoreflect.FullName = "google.protobuf.FieldOptions.edition_defaults" FieldOptions_Features_field_fullname protoreflect.FullName = "google.protobuf.FieldOptions.features" - FieldOptions_FeatureSupport_field_fullname protoreflect.FullName = "google.protobuf.FieldOptions.feature_support" FieldOptions_UninterpretedOption_field_fullname protoreflect.FullName = "google.protobuf.FieldOptions.uninterpreted_option" ) @@ -687,7 +684,6 @@ const ( FieldOptions_Targets_field_number protoreflect.FieldNumber = 19 FieldOptions_EditionDefaults_field_number protoreflect.FieldNumber = 20 FieldOptions_Features_field_number protoreflect.FieldNumber = 21 - FieldOptions_FeatureSupport_field_number protoreflect.FieldNumber = 22 FieldOptions_UninterpretedOption_field_number protoreflect.FieldNumber = 999 ) @@ -771,33 +767,6 @@ const ( FieldOptions_EditionDefault_Value_field_number protoreflect.FieldNumber = 2 ) -// Names for google.protobuf.FieldOptions.FeatureSupport. -const ( - FieldOptions_FeatureSupport_message_name protoreflect.Name = "FeatureSupport" - FieldOptions_FeatureSupport_message_fullname protoreflect.FullName = "google.protobuf.FieldOptions.FeatureSupport" -) - -// Field names for google.protobuf.FieldOptions.FeatureSupport. -const ( - FieldOptions_FeatureSupport_EditionIntroduced_field_name protoreflect.Name = "edition_introduced" - FieldOptions_FeatureSupport_EditionDeprecated_field_name protoreflect.Name = "edition_deprecated" - FieldOptions_FeatureSupport_DeprecationWarning_field_name protoreflect.Name = "deprecation_warning" - FieldOptions_FeatureSupport_EditionRemoved_field_name protoreflect.Name = "edition_removed" - - FieldOptions_FeatureSupport_EditionIntroduced_field_fullname protoreflect.FullName = "google.protobuf.FieldOptions.FeatureSupport.edition_introduced" - FieldOptions_FeatureSupport_EditionDeprecated_field_fullname protoreflect.FullName = "google.protobuf.FieldOptions.FeatureSupport.edition_deprecated" - FieldOptions_FeatureSupport_DeprecationWarning_field_fullname protoreflect.FullName = "google.protobuf.FieldOptions.FeatureSupport.deprecation_warning" - FieldOptions_FeatureSupport_EditionRemoved_field_fullname protoreflect.FullName = "google.protobuf.FieldOptions.FeatureSupport.edition_removed" -) - -// Field numbers for google.protobuf.FieldOptions.FeatureSupport. -const ( - FieldOptions_FeatureSupport_EditionIntroduced_field_number protoreflect.FieldNumber = 1 - FieldOptions_FeatureSupport_EditionDeprecated_field_number protoreflect.FieldNumber = 2 - FieldOptions_FeatureSupport_DeprecationWarning_field_number protoreflect.FieldNumber = 3 - FieldOptions_FeatureSupport_EditionRemoved_field_number protoreflect.FieldNumber = 4 -) - // Names for google.protobuf.OneofOptions. const ( OneofOptions_message_name protoreflect.Name = "OneofOptions" @@ -860,13 +829,11 @@ const ( EnumValueOptions_Deprecated_field_name protoreflect.Name = "deprecated" EnumValueOptions_Features_field_name protoreflect.Name = "features" EnumValueOptions_DebugRedact_field_name protoreflect.Name = "debug_redact" - EnumValueOptions_FeatureSupport_field_name protoreflect.Name = "feature_support" EnumValueOptions_UninterpretedOption_field_name protoreflect.Name = "uninterpreted_option" EnumValueOptions_Deprecated_field_fullname protoreflect.FullName = "google.protobuf.EnumValueOptions.deprecated" EnumValueOptions_Features_field_fullname protoreflect.FullName = "google.protobuf.EnumValueOptions.features" EnumValueOptions_DebugRedact_field_fullname protoreflect.FullName = "google.protobuf.EnumValueOptions.debug_redact" - EnumValueOptions_FeatureSupport_field_fullname protoreflect.FullName = "google.protobuf.EnumValueOptions.feature_support" EnumValueOptions_UninterpretedOption_field_fullname protoreflect.FullName = "google.protobuf.EnumValueOptions.uninterpreted_option" ) @@ -875,7 +842,6 @@ const ( EnumValueOptions_Deprecated_field_number protoreflect.FieldNumber = 1 EnumValueOptions_Features_field_number protoreflect.FieldNumber = 2 EnumValueOptions_DebugRedact_field_number protoreflect.FieldNumber = 3 - EnumValueOptions_FeatureSupport_field_number protoreflect.FieldNumber = 4 EnumValueOptions_UninterpretedOption_field_number protoreflect.FieldNumber = 999 ) @@ -1144,20 +1110,17 @@ const ( // Field names for google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault. const ( - FeatureSetDefaults_FeatureSetEditionDefault_Edition_field_name protoreflect.Name = "edition" - FeatureSetDefaults_FeatureSetEditionDefault_OverridableFeatures_field_name protoreflect.Name = "overridable_features" - FeatureSetDefaults_FeatureSetEditionDefault_FixedFeatures_field_name protoreflect.Name = "fixed_features" + FeatureSetDefaults_FeatureSetEditionDefault_Edition_field_name protoreflect.Name = "edition" + FeatureSetDefaults_FeatureSetEditionDefault_Features_field_name protoreflect.Name = "features" - FeatureSetDefaults_FeatureSetEditionDefault_Edition_field_fullname protoreflect.FullName = "google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault.edition" - FeatureSetDefaults_FeatureSetEditionDefault_OverridableFeatures_field_fullname protoreflect.FullName = "google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault.overridable_features" - FeatureSetDefaults_FeatureSetEditionDefault_FixedFeatures_field_fullname protoreflect.FullName = "google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault.fixed_features" + FeatureSetDefaults_FeatureSetEditionDefault_Edition_field_fullname protoreflect.FullName = "google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault.edition" + FeatureSetDefaults_FeatureSetEditionDefault_Features_field_fullname protoreflect.FullName = "google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault.features" ) // Field numbers for google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault. const ( - FeatureSetDefaults_FeatureSetEditionDefault_Edition_field_number protoreflect.FieldNumber = 3 - FeatureSetDefaults_FeatureSetEditionDefault_OverridableFeatures_field_number protoreflect.FieldNumber = 4 - FeatureSetDefaults_FeatureSetEditionDefault_FixedFeatures_field_number protoreflect.FieldNumber = 5 + FeatureSetDefaults_FeatureSetEditionDefault_Edition_field_number protoreflect.FieldNumber = 3 + FeatureSetDefaults_FeatureSetEditionDefault_Features_field_number protoreflect.FieldNumber = 2 ) // Names for google.protobuf.SourceCodeInfo. diff --git a/services/vendor/google.golang.org/protobuf/internal/genid/go_features_gen.go b/services/vendor/google.golang.org/protobuf/internal/genid/go_features_gen.go index 9a652a2b..fd9015e8 100644 --- a/services/vendor/google.golang.org/protobuf/internal/genid/go_features_gen.go +++ b/services/vendor/google.golang.org/protobuf/internal/genid/go_features_gen.go @@ -10,7 +10,7 @@ import ( protoreflect "google.golang.org/protobuf/reflect/protoreflect" ) -const File_google_protobuf_go_features_proto = "google/protobuf/go_features.proto" +const File_reflect_protodesc_proto_go_features_proto = "reflect/protodesc/proto/go_features.proto" // Names for google.protobuf.GoFeatures. const ( diff --git a/services/vendor/google.golang.org/protobuf/internal/impl/api_export.go b/services/vendor/google.golang.org/protobuf/internal/impl/api_export.go index 5d5771c2..a371f98d 100644 --- a/services/vendor/google.golang.org/protobuf/internal/impl/api_export.go +++ b/services/vendor/google.golang.org/protobuf/internal/impl/api_export.go @@ -22,13 +22,13 @@ type Export struct{} // NewError formats a string according to the format specifier and arguments and // returns an error that has a "proto" prefix. -func (Export) NewError(f string, x ...any) error { +func (Export) NewError(f string, x ...interface{}) error { return errors.New(f, x...) } // enum is any enum type generated by protoc-gen-go // and must be a named int32 type. -type enum = any +type enum = interface{} // EnumOf returns the protoreflect.Enum interface over e. // It returns nil if e is nil. @@ -81,7 +81,7 @@ func (Export) EnumStringOf(ed protoreflect.EnumDescriptor, n protoreflect.EnumNu // message is any message type generated by protoc-gen-go // and must be a pointer to a named struct type. -type message = any +type message = interface{} // legacyMessageWrapper wraps a v2 message as a v1 message. type legacyMessageWrapper struct{ m protoreflect.ProtoMessage } diff --git a/services/vendor/google.golang.org/protobuf/internal/impl/checkinit.go b/services/vendor/google.golang.org/protobuf/internal/impl/checkinit.go index f29e6a8f..bff041ed 100644 --- a/services/vendor/google.golang.org/protobuf/internal/impl/checkinit.go +++ b/services/vendor/google.golang.org/protobuf/internal/impl/checkinit.go @@ -68,7 +68,7 @@ func (mi *MessageInfo) isInitExtensions(ext *map[int32]ExtensionField) error { } for _, x := range *ext { ei := getExtensionFieldInfo(x.Type()) - if ei.funcs.isInit == nil || x.isUnexpandedLazy() { + if ei.funcs.isInit == nil { continue } v := x.Value() diff --git a/services/vendor/google.golang.org/protobuf/internal/impl/codec_extension.go b/services/vendor/google.golang.org/protobuf/internal/impl/codec_extension.go index 4bb0a7a2..2b8f122c 100644 --- a/services/vendor/google.golang.org/protobuf/internal/impl/codec_extension.go +++ b/services/vendor/google.golang.org/protobuf/internal/impl/codec_extension.go @@ -99,28 +99,6 @@ func (f *ExtensionField) canLazy(xt protoreflect.ExtensionType) bool { return false } -// isUnexpandedLazy returns true if the ExensionField is lazy and not -// yet expanded, which means it's present and already checked for -// initialized required fields. -func (f *ExtensionField) isUnexpandedLazy() bool { - return f.lazy != nil && atomic.LoadUint32(&f.lazy.atomicOnce) == 0 -} - -// lazyBuffer retrieves the buffer for a lazy extension if it's not yet expanded. -// -// The returned buffer has to be kept over whatever operation we're planning, -// as re-retrieving it will fail after the message is lazily decoded. -func (f *ExtensionField) lazyBuffer() []byte { - // This function might be in the critical path, so check the atomic without - // taking a look first, then only take the lock if needed. - if !f.isUnexpandedLazy() { - return nil - } - f.lazy.mu.Lock() - defer f.lazy.mu.Unlock() - return f.lazy.b -} - func (f *ExtensionField) lazyInit() { f.lazy.mu.Lock() defer f.lazy.mu.Unlock() diff --git a/services/vendor/google.golang.org/protobuf/internal/impl/codec_field.go b/services/vendor/google.golang.org/protobuf/internal/impl/codec_field.go index 78ee47e4..3fadd241 100644 --- a/services/vendor/google.golang.org/protobuf/internal/impl/codec_field.go +++ b/services/vendor/google.golang.org/protobuf/internal/impl/codec_field.go @@ -233,15 +233,9 @@ func sizeMessageInfo(p pointer, f *coderFieldInfo, opts marshalOptions) int { } func appendMessageInfo(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) { - calculatedSize := f.mi.sizePointer(p.Elem(), opts) b = protowire.AppendVarint(b, f.wiretag) - b = protowire.AppendVarint(b, uint64(calculatedSize)) - before := len(b) - b, err := f.mi.marshalAppendPointer(b, p.Elem(), opts) - if measuredSize := len(b) - before; calculatedSize != measuredSize && err == nil { - return nil, errors.MismatchedSizeCalculation(calculatedSize, measuredSize) - } - return b, err + b = protowire.AppendVarint(b, uint64(f.mi.sizePointer(p.Elem(), opts))) + return f.mi.marshalAppendPointer(b, p.Elem(), opts) } func consumeMessageInfo(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) { @@ -268,21 +262,14 @@ func isInitMessageInfo(p pointer, f *coderFieldInfo) error { return f.mi.checkInitializedPointer(p.Elem()) } -func sizeMessage(m proto.Message, tagsize int, opts marshalOptions) int { - return protowire.SizeBytes(opts.Options().Size(m)) + tagsize +func sizeMessage(m proto.Message, tagsize int, _ marshalOptions) int { + return protowire.SizeBytes(proto.Size(m)) + tagsize } func appendMessage(b []byte, m proto.Message, wiretag uint64, opts marshalOptions) ([]byte, error) { - mopts := opts.Options() - calculatedSize := mopts.Size(m) b = protowire.AppendVarint(b, wiretag) - b = protowire.AppendVarint(b, uint64(calculatedSize)) - before := len(b) - b, err := mopts.MarshalAppend(b, m) - if measuredSize := len(b) - before; calculatedSize != measuredSize && err == nil { - return nil, errors.MismatchedSizeCalculation(calculatedSize, measuredSize) - } - return b, err + b = protowire.AppendVarint(b, uint64(proto.Size(m))) + return opts.Options().MarshalAppend(b, m) } func consumeMessage(b []byte, m proto.Message, wtyp protowire.Type, opts unmarshalOptions) (out unmarshalOutput, err error) { @@ -418,8 +405,8 @@ func consumeGroupType(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInf return f.mi.unmarshalPointer(b, p.Elem(), f.num, opts) } -func sizeGroup(m proto.Message, tagsize int, opts marshalOptions) int { - return 2*tagsize + opts.Options().Size(m) +func sizeGroup(m proto.Message, tagsize int, _ marshalOptions) int { + return 2*tagsize + proto.Size(m) } func appendGroup(b []byte, m proto.Message, wiretag uint64, opts marshalOptions) ([]byte, error) { @@ -495,14 +482,10 @@ func appendMessageSliceInfo(b []byte, p pointer, f *coderFieldInfo, opts marshal b = protowire.AppendVarint(b, f.wiretag) siz := f.mi.sizePointer(v, opts) b = protowire.AppendVarint(b, uint64(siz)) - before := len(b) b, err = f.mi.marshalAppendPointer(b, v, opts) if err != nil { return b, err } - if measuredSize := len(b) - before; siz != measuredSize { - return nil, errors.MismatchedSizeCalculation(siz, measuredSize) - } } return b, nil } @@ -537,34 +520,28 @@ func isInitMessageSliceInfo(p pointer, f *coderFieldInfo) error { return nil } -func sizeMessageSlice(p pointer, goType reflect.Type, tagsize int, opts marshalOptions) int { - mopts := opts.Options() +func sizeMessageSlice(p pointer, goType reflect.Type, tagsize int, _ marshalOptions) int { s := p.PointerSlice() n := 0 for _, v := range s { m := asMessage(v.AsValueOf(goType.Elem())) - n += protowire.SizeBytes(mopts.Size(m)) + tagsize + n += protowire.SizeBytes(proto.Size(m)) + tagsize } return n } func appendMessageSlice(b []byte, p pointer, wiretag uint64, goType reflect.Type, opts marshalOptions) ([]byte, error) { - mopts := opts.Options() s := p.PointerSlice() var err error for _, v := range s { m := asMessage(v.AsValueOf(goType.Elem())) b = protowire.AppendVarint(b, wiretag) - siz := mopts.Size(m) + siz := proto.Size(m) b = protowire.AppendVarint(b, uint64(siz)) - before := len(b) - b, err = mopts.MarshalAppend(b, m) + b, err = opts.Options().MarshalAppend(b, m) if err != nil { return b, err } - if measuredSize := len(b) - before; siz != measuredSize { - return nil, errors.MismatchedSizeCalculation(siz, measuredSize) - } } return b, nil } @@ -605,12 +582,11 @@ func isInitMessageSlice(p pointer, goType reflect.Type) error { // Slices of messages func sizeMessageSliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) int { - mopts := opts.Options() list := listv.List() n := 0 for i, llen := 0, list.Len(); i < llen; i++ { m := list.Get(i).Message().Interface() - n += protowire.SizeBytes(mopts.Size(m)) + tagsize + n += protowire.SizeBytes(proto.Size(m)) + tagsize } return n } @@ -621,17 +597,13 @@ func appendMessageSliceValue(b []byte, listv protoreflect.Value, wiretag uint64, for i, llen := 0, list.Len(); i < llen; i++ { m := list.Get(i).Message().Interface() b = protowire.AppendVarint(b, wiretag) - siz := mopts.Size(m) + siz := proto.Size(m) b = protowire.AppendVarint(b, uint64(siz)) - before := len(b) var err error b, err = mopts.MarshalAppend(b, m) if err != nil { return b, err } - if measuredSize := len(b) - before; siz != measuredSize { - return nil, errors.MismatchedSizeCalculation(siz, measuredSize) - } } return b, nil } @@ -679,12 +651,11 @@ var coderMessageSliceValue = valueCoderFuncs{ } func sizeGroupSliceValue(listv protoreflect.Value, tagsize int, opts marshalOptions) int { - mopts := opts.Options() list := listv.List() n := 0 for i, llen := 0, list.Len(); i < llen; i++ { m := list.Get(i).Message().Interface() - n += 2*tagsize + mopts.Size(m) + n += 2*tagsize + proto.Size(m) } return n } @@ -767,13 +738,12 @@ func makeGroupSliceFieldCoder(fd protoreflect.FieldDescriptor, ft reflect.Type) } } -func sizeGroupSlice(p pointer, messageType reflect.Type, tagsize int, opts marshalOptions) int { - mopts := opts.Options() +func sizeGroupSlice(p pointer, messageType reflect.Type, tagsize int, _ marshalOptions) int { s := p.PointerSlice() n := 0 for _, v := range s { m := asMessage(v.AsValueOf(messageType.Elem())) - n += 2*tagsize + mopts.Size(m) + n += 2*tagsize + proto.Size(m) } return n } diff --git a/services/vendor/google.golang.org/protobuf/internal/impl/codec_map.go b/services/vendor/google.golang.org/protobuf/internal/impl/codec_map.go index fb35f0ba..111b9d16 100644 --- a/services/vendor/google.golang.org/protobuf/internal/impl/codec_map.go +++ b/services/vendor/google.golang.org/protobuf/internal/impl/codec_map.go @@ -9,7 +9,6 @@ import ( "sort" "google.golang.org/protobuf/encoding/protowire" - "google.golang.org/protobuf/internal/errors" "google.golang.org/protobuf/internal/genid" "google.golang.org/protobuf/reflect/protoreflect" ) @@ -241,16 +240,11 @@ func appendMapItem(b []byte, keyrv, valrv reflect.Value, mapi *mapInfo, f *coder size += mapi.keyFuncs.size(key.Value(), mapKeyTagSize, opts) size += mapi.valFuncs.size(val, mapValTagSize, opts) b = protowire.AppendVarint(b, uint64(size)) - before := len(b) b, err := mapi.keyFuncs.marshal(b, key.Value(), mapi.keyWiretag, opts) if err != nil { return nil, err } - b, err = mapi.valFuncs.marshal(b, val, mapi.valWiretag, opts) - if measuredSize := len(b) - before; size != measuredSize && err == nil { - return nil, errors.MismatchedSizeCalculation(size, measuredSize) - } - return b, err + return mapi.valFuncs.marshal(b, val, mapi.valWiretag, opts) } else { key := mapi.conv.keyConv.PBValueOf(keyrv).MapKey() val := pointerOfValue(valrv) @@ -265,12 +259,7 @@ func appendMapItem(b []byte, keyrv, valrv reflect.Value, mapi *mapInfo, f *coder } b = protowire.AppendVarint(b, mapi.valWiretag) b = protowire.AppendVarint(b, uint64(valSize)) - before := len(b) - b, err = f.mi.marshalAppendPointer(b, val, opts) - if measuredSize := len(b) - before; valSize != measuredSize && err == nil { - return nil, errors.MismatchedSizeCalculation(valSize, measuredSize) - } - return b, err + return f.mi.marshalAppendPointer(b, val, opts) } } diff --git a/services/vendor/google.golang.org/protobuf/internal/impl/codec_messageset.go b/services/vendor/google.golang.org/protobuf/internal/impl/codec_messageset.go index 7a16ec13..b7a23faf 100644 --- a/services/vendor/google.golang.org/protobuf/internal/impl/codec_messageset.go +++ b/services/vendor/google.golang.org/protobuf/internal/impl/codec_messageset.go @@ -26,15 +26,6 @@ func sizeMessageSet(mi *MessageInfo, p pointer, opts marshalOptions) (size int) } num, _ := protowire.DecodeTag(xi.wiretag) size += messageset.SizeField(num) - if fullyLazyExtensions(opts) { - // Don't expand the extension, instead use the buffer to calculate size - if lb := x.lazyBuffer(); lb != nil { - // We got hold of the buffer, so it's still lazy. - // Don't count the tag size in the extension buffer, it's already added. - size += protowire.SizeTag(messageset.FieldMessage) + len(lb) - xi.tagsize - continue - } - } size += xi.funcs.size(x.Value(), protowire.SizeTag(messageset.FieldMessage), opts) } @@ -94,19 +85,6 @@ func marshalMessageSetField(mi *MessageInfo, b []byte, x ExtensionField, opts ma xi := getExtensionFieldInfo(x.Type()) num, _ := protowire.DecodeTag(xi.wiretag) b = messageset.AppendFieldStart(b, num) - - if fullyLazyExtensions(opts) { - // Don't expand the extension if it's still in wire format, instead use the buffer content. - if lb := x.lazyBuffer(); lb != nil { - // The tag inside the lazy buffer is a different tag (the extension - // number), but what we need here is the tag for FieldMessage: - b = protowire.AppendVarint(b, protowire.EncodeTag(messageset.FieldMessage, protowire.BytesType)) - b = append(b, lb[xi.tagsize:]...) - b = messageset.AppendFieldEnd(b) - return b, nil - } - } - b, err := xi.funcs.marshal(b, x.Value(), protowire.EncodeTag(messageset.FieldMessage, protowire.BytesType), opts) if err != nil { return b, err diff --git a/services/vendor/google.golang.org/protobuf/internal/impl/convert.go b/services/vendor/google.golang.org/protobuf/internal/impl/convert.go index e06ece55..185ef2ef 100644 --- a/services/vendor/google.golang.org/protobuf/internal/impl/convert.go +++ b/services/vendor/google.golang.org/protobuf/internal/impl/convert.go @@ -14,7 +14,7 @@ import ( // unwrapper unwraps the value to the underlying value. // This is implemented by List and Map. type unwrapper interface { - protoUnwrap() any + protoUnwrap() interface{} } // A Converter coverts to/from Go reflect.Value types and protobuf protoreflect.Value types. diff --git a/services/vendor/google.golang.org/protobuf/internal/impl/convert_list.go b/services/vendor/google.golang.org/protobuf/internal/impl/convert_list.go index 18cb96fd..f8913651 100644 --- a/services/vendor/google.golang.org/protobuf/internal/impl/convert_list.go +++ b/services/vendor/google.golang.org/protobuf/internal/impl/convert_list.go @@ -136,6 +136,6 @@ func (ls *listReflect) NewElement() protoreflect.Value { func (ls *listReflect) IsValid() bool { return !ls.v.IsNil() } -func (ls *listReflect) protoUnwrap() any { +func (ls *listReflect) protoUnwrap() interface{} { return ls.v.Interface() } diff --git a/services/vendor/google.golang.org/protobuf/internal/impl/convert_map.go b/services/vendor/google.golang.org/protobuf/internal/impl/convert_map.go index 304244a6..f30b0a05 100644 --- a/services/vendor/google.golang.org/protobuf/internal/impl/convert_map.go +++ b/services/vendor/google.golang.org/protobuf/internal/impl/convert_map.go @@ -116,6 +116,6 @@ func (ms *mapReflect) NewValue() protoreflect.Value { func (ms *mapReflect) IsValid() bool { return !ms.v.IsNil() } -func (ms *mapReflect) protoUnwrap() any { +func (ms *mapReflect) protoUnwrap() interface{} { return ms.v.Interface() } diff --git a/services/vendor/google.golang.org/protobuf/internal/impl/encode.go b/services/vendor/google.golang.org/protobuf/internal/impl/encode.go index febd2122..845c67d6 100644 --- a/services/vendor/google.golang.org/protobuf/internal/impl/encode.go +++ b/services/vendor/google.golang.org/protobuf/internal/impl/encode.go @@ -49,11 +49,8 @@ func (mi *MessageInfo) sizePointer(p pointer, opts marshalOptions) (size int) { return 0 } if opts.UseCachedSize() && mi.sizecacheOffset.IsValid() { - // The size cache contains the size + 1, to allow the - // zero value to be invalid, while also allowing for a - // 0 size to be cached. - if size := atomic.LoadInt32(p.Apply(mi.sizecacheOffset).Int32()); size > 0 { - return int(size - 1) + if size := atomic.LoadInt32(p.Apply(mi.sizecacheOffset).Int32()); size >= 0 { + return int(size) } } return mi.sizePointerSlow(p, opts) @@ -63,7 +60,7 @@ func (mi *MessageInfo) sizePointerSlow(p pointer, opts marshalOptions) (size int if flags.ProtoLegacy && mi.isMessageSet { size = sizeMessageSet(mi, p, opts) if mi.sizecacheOffset.IsValid() { - atomic.StoreInt32(p.Apply(mi.sizecacheOffset).Int32(), int32(size+1)) + atomic.StoreInt32(p.Apply(mi.sizecacheOffset).Int32(), int32(size)) } return size } @@ -87,16 +84,13 @@ func (mi *MessageInfo) sizePointerSlow(p pointer, opts marshalOptions) (size int } } if mi.sizecacheOffset.IsValid() { - if size > (math.MaxInt32 - 1) { + if size > math.MaxInt32 { // The size is too large for the int32 sizecache field. // We will need to recompute the size when encoding; // unfortunately expensive, but better than invalid output. - atomic.StoreInt32(p.Apply(mi.sizecacheOffset).Int32(), 0) + atomic.StoreInt32(p.Apply(mi.sizecacheOffset).Int32(), -1) } else { - // The size cache contains the size + 1, to allow the - // zero value to be invalid, while also allowing for a - // 0 size to be cached. - atomic.StoreInt32(p.Apply(mi.sizecacheOffset).Int32(), int32(size+1)) + atomic.StoreInt32(p.Apply(mi.sizecacheOffset).Int32(), int32(size)) } } return size @@ -155,14 +149,6 @@ func (mi *MessageInfo) marshalAppendPointer(b []byte, p pointer, opts marshalOpt return b, nil } -// fullyLazyExtensions returns true if we should attempt to keep extensions lazy over size and marshal. -func fullyLazyExtensions(opts marshalOptions) bool { - // When deterministic marshaling is requested, force an unmarshal for lazy - // extensions to produce a deterministic result, instead of passing through - // bytes lazily that may or may not match what Go Protobuf would produce. - return opts.flags&piface.MarshalDeterministic == 0 -} - func (mi *MessageInfo) sizeExtensions(ext *map[int32]ExtensionField, opts marshalOptions) (n int) { if ext == nil { return 0 @@ -172,14 +158,6 @@ func (mi *MessageInfo) sizeExtensions(ext *map[int32]ExtensionField, opts marsha if xi.funcs.size == nil { continue } - if fullyLazyExtensions(opts) { - // Don't expand the extension, instead use the buffer to calculate size - if lb := x.lazyBuffer(); lb != nil { - // We got hold of the buffer, so it's still lazy. - n += len(lb) - continue - } - } n += xi.funcs.size(x.Value(), xi.tagsize, opts) } return n @@ -198,13 +176,6 @@ func (mi *MessageInfo) appendExtensions(b []byte, ext *map[int32]ExtensionField, var err error for _, x := range *ext { xi := getExtensionFieldInfo(x.Type()) - if fullyLazyExtensions(opts) { - // Don't expand the extension if it's still in wire format, instead use the buffer content. - if lb := x.lazyBuffer(); lb != nil { - b = append(b, lb...) - continue - } - } b, err = xi.funcs.marshal(b, x.Value(), xi.wiretag, opts) } return b, err @@ -220,13 +191,6 @@ func (mi *MessageInfo) appendExtensions(b []byte, ext *map[int32]ExtensionField, for _, k := range keys { x := (*ext)[int32(k)] xi := getExtensionFieldInfo(x.Type()) - if fullyLazyExtensions(opts) { - // Don't expand the extension if it's still in wire format, instead use the buffer content. - if lb := x.lazyBuffer(); lb != nil { - b = append(b, lb...) - continue - } - } b, err = xi.funcs.marshal(b, x.Value(), xi.wiretag, opts) if err != nil { return b, err diff --git a/services/vendor/google.golang.org/protobuf/internal/impl/extension.go b/services/vendor/google.golang.org/protobuf/internal/impl/extension.go index e31249f6..cb25b0ba 100644 --- a/services/vendor/google.golang.org/protobuf/internal/impl/extension.go +++ b/services/vendor/google.golang.org/protobuf/internal/impl/extension.go @@ -53,7 +53,7 @@ type ExtensionInfo struct { // type returned by InterfaceOf may not be identical. // // Deprecated: Use InterfaceOf(xt.Zero()) instead. - ExtensionType any + ExtensionType interface{} // Field is the field number of the extension. // @@ -95,16 +95,16 @@ func (xi *ExtensionInfo) New() protoreflect.Value { func (xi *ExtensionInfo) Zero() protoreflect.Value { return xi.lazyInit().Zero() } -func (xi *ExtensionInfo) ValueOf(v any) protoreflect.Value { +func (xi *ExtensionInfo) ValueOf(v interface{}) protoreflect.Value { return xi.lazyInit().PBValueOf(reflect.ValueOf(v)) } -func (xi *ExtensionInfo) InterfaceOf(v protoreflect.Value) any { +func (xi *ExtensionInfo) InterfaceOf(v protoreflect.Value) interface{} { return xi.lazyInit().GoValueOf(v).Interface() } func (xi *ExtensionInfo) IsValidValue(v protoreflect.Value) bool { return xi.lazyInit().IsValidPB(v) } -func (xi *ExtensionInfo) IsValidInterface(v any) bool { +func (xi *ExtensionInfo) IsValidInterface(v interface{}) bool { return xi.lazyInit().IsValidGo(reflect.ValueOf(v)) } func (xi *ExtensionInfo) TypeDescriptor() protoreflect.ExtensionTypeDescriptor { diff --git a/services/vendor/google.golang.org/protobuf/internal/impl/legacy_enum.go b/services/vendor/google.golang.org/protobuf/internal/impl/legacy_enum.go index 81b2b1a7..c2a803bb 100644 --- a/services/vendor/google.golang.org/protobuf/internal/impl/legacy_enum.go +++ b/services/vendor/google.golang.org/protobuf/internal/impl/legacy_enum.go @@ -97,7 +97,7 @@ func (e *legacyEnumWrapper) Number() protoreflect.EnumNumber { func (e *legacyEnumWrapper) ProtoReflect() protoreflect.Enum { return e } -func (e *legacyEnumWrapper) protoUnwrap() any { +func (e *legacyEnumWrapper) protoUnwrap() interface{} { v := reflect.New(e.goTyp).Elem() v.SetInt(int64(e.num)) return v.Interface() @@ -167,7 +167,6 @@ func aberrantLoadEnumDesc(t reflect.Type) protoreflect.EnumDescriptor { ed := &filedesc.Enum{L2: new(filedesc.EnumL2)} ed.L0.FullName = AberrantDeriveFullName(t) // e.g., github_com.user.repo.MyEnum ed.L0.ParentFile = filedesc.SurrogateProto3 - ed.L1.EditionFeatures = ed.L0.ParentFile.L1.EditionFeatures ed.L2.Values.List = append(ed.L2.Values.List, filedesc.EnumValue{}) // TODO: Use the presence of a UnmarshalJSON method to determine proto2? diff --git a/services/vendor/google.golang.org/protobuf/internal/impl/legacy_extension.go b/services/vendor/google.golang.org/protobuf/internal/impl/legacy_extension.go index 6e8677ee..87b30d05 100644 --- a/services/vendor/google.golang.org/protobuf/internal/impl/legacy_extension.go +++ b/services/vendor/google.golang.org/protobuf/internal/impl/legacy_extension.go @@ -118,7 +118,7 @@ func (xi *ExtensionInfo) initFromLegacy() { xd.L1.Number = protoreflect.FieldNumber(xi.Field) xd.L1.Cardinality = fd.L1.Cardinality xd.L1.Kind = fd.L1.Kind - xd.L1.EditionFeatures = fd.L1.EditionFeatures + xd.L2.IsPacked = fd.L1.IsPacked xd.L2.Default = fd.L1.Default xd.L1.Extendee = Export{}.MessageDescriptorOf(xi.ExtendedType) xd.L2.Enum = ed diff --git a/services/vendor/google.golang.org/protobuf/internal/impl/legacy_file.go b/services/vendor/google.golang.org/protobuf/internal/impl/legacy_file.go index b649f112..9ab09108 100644 --- a/services/vendor/google.golang.org/protobuf/internal/impl/legacy_file.go +++ b/services/vendor/google.golang.org/protobuf/internal/impl/legacy_file.go @@ -7,7 +7,7 @@ package impl import ( "bytes" "compress/gzip" - "io" + "io/ioutil" "sync" "google.golang.org/protobuf/internal/filedesc" @@ -51,7 +51,7 @@ func legacyLoadFileDesc(b []byte) protoreflect.FileDescriptor { if err != nil { panic(err) } - b2, err := io.ReadAll(zr) + b2, err := ioutil.ReadAll(zr) if err != nil { panic(err) } diff --git a/services/vendor/google.golang.org/protobuf/internal/impl/legacy_message.go b/services/vendor/google.golang.org/protobuf/internal/impl/legacy_message.go index bf0b6049..2ab2c629 100644 --- a/services/vendor/google.golang.org/protobuf/internal/impl/legacy_message.go +++ b/services/vendor/google.golang.org/protobuf/internal/impl/legacy_message.go @@ -204,7 +204,6 @@ func aberrantLoadMessageDescReentrant(t reflect.Type, name protoreflect.FullName } } - md.L1.EditionFeatures = md.L0.ParentFile.L1.EditionFeatures // Obtain a list of oneof wrapper types. var oneofWrappers []reflect.Type methods := make([]reflect.Method, 0, 2) @@ -216,7 +215,7 @@ func aberrantLoadMessageDescReentrant(t reflect.Type, name protoreflect.FullName } for _, fn := range methods { for _, v := range fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))}) { - if vs, ok := v.Interface().([]any); ok { + if vs, ok := v.Interface().([]interface{}); ok { for _, v := range vs { oneofWrappers = append(oneofWrappers, reflect.TypeOf(v)) } @@ -251,7 +250,6 @@ func aberrantLoadMessageDescReentrant(t reflect.Type, name protoreflect.FullName od := &md.L2.Oneofs.List[n] od.L0.FullName = md.FullName().Append(protoreflect.Name(tag)) od.L0.ParentFile = md.L0.ParentFile - od.L1.EditionFeatures = md.L1.EditionFeatures od.L0.Parent = md od.L0.Index = n @@ -262,7 +260,6 @@ func aberrantLoadMessageDescReentrant(t reflect.Type, name protoreflect.FullName aberrantAppendField(md, f.Type, tag, "", "") fd := &md.L2.Fields.List[len(md.L2.Fields.List)-1] fd.L1.ContainingOneof = od - fd.L1.EditionFeatures = od.L1.EditionFeatures od.L1.Fields.List = append(od.L1.Fields.List, fd) } } @@ -310,14 +307,14 @@ func aberrantAppendField(md *filedesc.Message, goType reflect.Type, tag, tagKey, fd.L0.Parent = md fd.L0.Index = n - if fd.L1.IsWeak || fd.L1.EditionFeatures.IsPacked { + if fd.L1.IsWeak || fd.L1.HasPacked { fd.L1.Options = func() protoreflect.ProtoMessage { opts := descopts.Field.ProtoReflect().New() if fd.L1.IsWeak { opts.Set(opts.Descriptor().Fields().ByName("weak"), protoreflect.ValueOfBool(true)) } - if fd.L1.EditionFeatures.IsPacked { - opts.Set(opts.Descriptor().Fields().ByName("packed"), protoreflect.ValueOfBool(fd.L1.EditionFeatures.IsPacked)) + if fd.L1.HasPacked { + opts.Set(opts.Descriptor().Fields().ByName("packed"), protoreflect.ValueOfBool(fd.L1.IsPacked)) } return opts.Interface() } @@ -347,7 +344,6 @@ func aberrantAppendField(md *filedesc.Message, goType reflect.Type, tag, tagKey, md2.L0.ParentFile = md.L0.ParentFile md2.L0.Parent = md md2.L0.Index = n - md2.L1.EditionFeatures = md.L1.EditionFeatures md2.L1.IsMapEntry = true md2.L2.Options = func() protoreflect.ProtoMessage { @@ -567,6 +563,6 @@ func (m aberrantMessage) IsValid() bool { func (m aberrantMessage) ProtoMethods() *protoiface.Methods { return aberrantProtoMethods } -func (m aberrantMessage) protoUnwrap() any { +func (m aberrantMessage) protoUnwrap() interface{} { return m.v.Interface() } diff --git a/services/vendor/google.golang.org/protobuf/internal/impl/message.go b/services/vendor/google.golang.org/protobuf/internal/impl/message.go index 019399d4..629bacdc 100644 --- a/services/vendor/google.golang.org/protobuf/internal/impl/message.go +++ b/services/vendor/google.golang.org/protobuf/internal/impl/message.go @@ -35,7 +35,7 @@ type MessageInfo struct { Exporter exporter // OneofWrappers is list of pointers to oneof wrapper struct types. - OneofWrappers []any + OneofWrappers []interface{} initMu sync.Mutex // protects all unexported fields initDone uint32 @@ -47,7 +47,7 @@ type MessageInfo struct { // exporter is a function that returns a reference to the ith field of v, // where v is a pointer to a struct. It returns nil if it does not support // exporting the requested field (e.g., already exported). -type exporter func(v any, i int) any +type exporter func(v interface{}, i int) interface{} // getMessageInfo returns the MessageInfo for any message type that // is generated by our implementation of protoc-gen-go (for v2 and on). @@ -201,7 +201,7 @@ fieldLoop: } for _, fn := range methods { for _, v := range fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))}) { - if vs, ok := v.Interface().([]any); ok { + if vs, ok := v.Interface().([]interface{}); ok { oneofWrappers = vs } } @@ -256,7 +256,7 @@ func (mi *MessageInfo) Message(i int) protoreflect.MessageType { type mapEntryType struct { desc protoreflect.MessageDescriptor - valType any // zero value of enum or message type + valType interface{} // zero value of enum or message type } func (mt mapEntryType) New() protoreflect.Message { diff --git a/services/vendor/google.golang.org/protobuf/internal/impl/message_reflect.go b/services/vendor/google.golang.org/protobuf/internal/impl/message_reflect.go index ecb4623d..d9ea010b 100644 --- a/services/vendor/google.golang.org/protobuf/internal/impl/message_reflect.go +++ b/services/vendor/google.golang.org/protobuf/internal/impl/message_reflect.go @@ -20,7 +20,7 @@ type reflectMessageInfo struct { // fieldTypes contains the zero value of an enum or message field. // For lists, it contains the element type. // For maps, it contains the entry value type. - fieldTypes map[protoreflect.FieldNumber]any + fieldTypes map[protoreflect.FieldNumber]interface{} // denseFields is a subset of fields where: // 0 < fieldDesc.Number() < len(denseFields) @@ -28,7 +28,7 @@ type reflectMessageInfo struct { denseFields []*fieldInfo // rangeInfos is a list of all fields (not belonging to a oneof) and oneofs. - rangeInfos []any // either *fieldInfo or *oneofInfo + rangeInfos []interface{} // either *fieldInfo or *oneofInfo getUnknown func(pointer) protoreflect.RawFields setUnknown func(pointer, protoreflect.RawFields) @@ -224,7 +224,7 @@ func (mi *MessageInfo) makeFieldTypes(si structInfo) { } if ft != nil { if mi.fieldTypes == nil { - mi.fieldTypes = make(map[protoreflect.FieldNumber]any) + mi.fieldTypes = make(map[protoreflect.FieldNumber]interface{}) } mi.fieldTypes[fd.Number()] = reflect.Zero(ft).Interface() } @@ -247,39 +247,39 @@ func (m *extensionMap) Range(f func(protoreflect.FieldDescriptor, protoreflect.V } } } -func (m *extensionMap) Has(xd protoreflect.ExtensionTypeDescriptor) (ok bool) { +func (m *extensionMap) Has(xt protoreflect.ExtensionType) (ok bool) { if m == nil { return false } + xd := xt.TypeDescriptor() x, ok := (*m)[int32(xd.Number())] if !ok { return false } - if x.isUnexpandedLazy() { - // Avoid calling x.Value(), which triggers a lazy unmarshal. - return true - } switch { case xd.IsList(): return x.Value().List().Len() > 0 case xd.IsMap(): return x.Value().Map().Len() > 0 + case xd.Message() != nil: + return x.Value().Message().IsValid() } return true } -func (m *extensionMap) Clear(xd protoreflect.ExtensionTypeDescriptor) { - delete(*m, int32(xd.Number())) +func (m *extensionMap) Clear(xt protoreflect.ExtensionType) { + delete(*m, int32(xt.TypeDescriptor().Number())) } -func (m *extensionMap) Get(xd protoreflect.ExtensionTypeDescriptor) protoreflect.Value { +func (m *extensionMap) Get(xt protoreflect.ExtensionType) protoreflect.Value { + xd := xt.TypeDescriptor() if m != nil { if x, ok := (*m)[int32(xd.Number())]; ok { return x.Value() } } - return xd.Type().Zero() + return xt.Zero() } -func (m *extensionMap) Set(xd protoreflect.ExtensionTypeDescriptor, v protoreflect.Value) { - xt := xd.Type() +func (m *extensionMap) Set(xt protoreflect.ExtensionType, v protoreflect.Value) { + xd := xt.TypeDescriptor() isValid := true switch { case !xt.IsValidValue(v): @@ -292,7 +292,7 @@ func (m *extensionMap) Set(xd protoreflect.ExtensionTypeDescriptor, v protorefle isValid = v.Message().IsValid() } if !isValid { - panic(fmt.Sprintf("%v: assigning invalid value", xd.FullName())) + panic(fmt.Sprintf("%v: assigning invalid value", xt.TypeDescriptor().FullName())) } if *m == nil { @@ -302,15 +302,16 @@ func (m *extensionMap) Set(xd protoreflect.ExtensionTypeDescriptor, v protorefle x.Set(xt, v) (*m)[int32(xd.Number())] = x } -func (m *extensionMap) Mutable(xd protoreflect.ExtensionTypeDescriptor) protoreflect.Value { +func (m *extensionMap) Mutable(xt protoreflect.ExtensionType) protoreflect.Value { + xd := xt.TypeDescriptor() if xd.Kind() != protoreflect.MessageKind && xd.Kind() != protoreflect.GroupKind && !xd.IsList() && !xd.IsMap() { panic("invalid Mutable on field with non-composite type") } if x, ok := (*m)[int32(xd.Number())]; ok { return x.Value() } - v := xd.Type().New() - m.Set(xd, v) + v := xt.New() + m.Set(xt, v) return v } @@ -393,7 +394,7 @@ var ( // MessageOf returns a reflective view over a message. The input must be a // pointer to a named Go struct. If the provided type has a ProtoReflect method, // it must be implemented by calling this method. -func (mi *MessageInfo) MessageOf(m any) protoreflect.Message { +func (mi *MessageInfo) MessageOf(m interface{}) protoreflect.Message { if reflect.TypeOf(m) != mi.GoReflectType { panic(fmt.Sprintf("type mismatch: got %T, want %v", m, mi.GoReflectType)) } @@ -421,13 +422,13 @@ func (m *messageIfaceWrapper) Reset() { func (m *messageIfaceWrapper) ProtoReflect() protoreflect.Message { return (*messageReflectWrapper)(m) } -func (m *messageIfaceWrapper) protoUnwrap() any { +func (m *messageIfaceWrapper) protoUnwrap() interface{} { return m.p.AsIfaceOf(m.mi.GoReflectType.Elem()) } // checkField verifies that the provided field descriptor is valid. // Exactly one of the returned values is populated. -func (mi *MessageInfo) checkField(fd protoreflect.FieldDescriptor) (*fieldInfo, protoreflect.ExtensionTypeDescriptor) { +func (mi *MessageInfo) checkField(fd protoreflect.FieldDescriptor) (*fieldInfo, protoreflect.ExtensionType) { var fi *fieldInfo if n := fd.Number(); 0 < n && int(n) < len(mi.denseFields) { fi = mi.denseFields[n] @@ -456,7 +457,7 @@ func (mi *MessageInfo) checkField(fd protoreflect.FieldDescriptor) (*fieldInfo, if !ok { panic(fmt.Sprintf("extension %v does not implement protoreflect.ExtensionTypeDescriptor", fd.FullName())) } - return nil, xtd + return nil, xtd.Type() } panic(fmt.Sprintf("field %v is invalid", fd.FullName())) } diff --git a/services/vendor/google.golang.org/protobuf/internal/impl/message_reflect_gen.go b/services/vendor/google.golang.org/protobuf/internal/impl/message_reflect_gen.go index 99dc23c6..741d6e5b 100644 --- a/services/vendor/google.golang.org/protobuf/internal/impl/message_reflect_gen.go +++ b/services/vendor/google.golang.org/protobuf/internal/impl/message_reflect_gen.go @@ -23,13 +23,12 @@ func (m *messageState) New() protoreflect.Message { func (m *messageState) Interface() protoreflect.ProtoMessage { return m.protoUnwrap().(protoreflect.ProtoMessage) } -func (m *messageState) protoUnwrap() any { +func (m *messageState) protoUnwrap() interface{} { return m.pointer().AsIfaceOf(m.messageInfo().GoReflectType.Elem()) } func (m *messageState) ProtoMethods() *protoiface.Methods { - mi := m.messageInfo() - mi.init() - return &mi.methods + m.messageInfo().init() + return &m.messageInfo().methods } // ProtoMessageInfo is a pseudo-internal API for allowing the v1 code @@ -42,9 +41,8 @@ func (m *messageState) ProtoMessageInfo() *MessageInfo { } func (m *messageState) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { - mi := m.messageInfo() - mi.init() - for _, ri := range mi.rangeInfos { + m.messageInfo().init() + for _, ri := range m.messageInfo().rangeInfos { switch ri := ri.(type) { case *fieldInfo: if ri.has(m.pointer()) { @@ -54,86 +52,77 @@ func (m *messageState) Range(f func(protoreflect.FieldDescriptor, protoreflect.V } case *oneofInfo: if n := ri.which(m.pointer()); n > 0 { - fi := mi.fields[n] + fi := m.messageInfo().fields[n] if !f(fi.fieldDesc, fi.get(m.pointer())) { return } } } } - mi.extensionMap(m.pointer()).Range(f) + m.messageInfo().extensionMap(m.pointer()).Range(f) } func (m *messageState) Has(fd protoreflect.FieldDescriptor) bool { - mi := m.messageInfo() - mi.init() - if fi, xd := mi.checkField(fd); fi != nil { + m.messageInfo().init() + if fi, xt := m.messageInfo().checkField(fd); fi != nil { return fi.has(m.pointer()) } else { - return mi.extensionMap(m.pointer()).Has(xd) + return m.messageInfo().extensionMap(m.pointer()).Has(xt) } } func (m *messageState) Clear(fd protoreflect.FieldDescriptor) { - mi := m.messageInfo() - mi.init() - if fi, xd := mi.checkField(fd); fi != nil { + m.messageInfo().init() + if fi, xt := m.messageInfo().checkField(fd); fi != nil { fi.clear(m.pointer()) } else { - mi.extensionMap(m.pointer()).Clear(xd) + m.messageInfo().extensionMap(m.pointer()).Clear(xt) } } func (m *messageState) Get(fd protoreflect.FieldDescriptor) protoreflect.Value { - mi := m.messageInfo() - mi.init() - if fi, xd := mi.checkField(fd); fi != nil { + m.messageInfo().init() + if fi, xt := m.messageInfo().checkField(fd); fi != nil { return fi.get(m.pointer()) } else { - return mi.extensionMap(m.pointer()).Get(xd) + return m.messageInfo().extensionMap(m.pointer()).Get(xt) } } func (m *messageState) Set(fd protoreflect.FieldDescriptor, v protoreflect.Value) { - mi := m.messageInfo() - mi.init() - if fi, xd := mi.checkField(fd); fi != nil { + m.messageInfo().init() + if fi, xt := m.messageInfo().checkField(fd); fi != nil { fi.set(m.pointer(), v) } else { - mi.extensionMap(m.pointer()).Set(xd, v) + m.messageInfo().extensionMap(m.pointer()).Set(xt, v) } } func (m *messageState) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { - mi := m.messageInfo() - mi.init() - if fi, xd := mi.checkField(fd); fi != nil { + m.messageInfo().init() + if fi, xt := m.messageInfo().checkField(fd); fi != nil { return fi.mutable(m.pointer()) } else { - return mi.extensionMap(m.pointer()).Mutable(xd) + return m.messageInfo().extensionMap(m.pointer()).Mutable(xt) } } func (m *messageState) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { - mi := m.messageInfo() - mi.init() - if fi, xd := mi.checkField(fd); fi != nil { + m.messageInfo().init() + if fi, xt := m.messageInfo().checkField(fd); fi != nil { return fi.newField() } else { - return xd.Type().New() + return xt.New() } } func (m *messageState) WhichOneof(od protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { - mi := m.messageInfo() - mi.init() - if oi := mi.oneofs[od.Name()]; oi != nil && oi.oneofDesc == od { + m.messageInfo().init() + if oi := m.messageInfo().oneofs[od.Name()]; oi != nil && oi.oneofDesc == od { return od.Fields().ByNumber(oi.which(m.pointer())) } panic("invalid oneof descriptor " + string(od.FullName()) + " for message " + string(m.Descriptor().FullName())) } func (m *messageState) GetUnknown() protoreflect.RawFields { - mi := m.messageInfo() - mi.init() - return mi.getUnknown(m.pointer()) + m.messageInfo().init() + return m.messageInfo().getUnknown(m.pointer()) } func (m *messageState) SetUnknown(b protoreflect.RawFields) { - mi := m.messageInfo() - mi.init() - mi.setUnknown(m.pointer(), b) + m.messageInfo().init() + m.messageInfo().setUnknown(m.pointer(), b) } func (m *messageState) IsValid() bool { return !m.pointer().IsNil() @@ -154,13 +143,12 @@ func (m *messageReflectWrapper) Interface() protoreflect.ProtoMessage { } return (*messageIfaceWrapper)(m) } -func (m *messageReflectWrapper) protoUnwrap() any { +func (m *messageReflectWrapper) protoUnwrap() interface{} { return m.pointer().AsIfaceOf(m.messageInfo().GoReflectType.Elem()) } func (m *messageReflectWrapper) ProtoMethods() *protoiface.Methods { - mi := m.messageInfo() - mi.init() - return &mi.methods + m.messageInfo().init() + return &m.messageInfo().methods } // ProtoMessageInfo is a pseudo-internal API for allowing the v1 code @@ -173,9 +161,8 @@ func (m *messageReflectWrapper) ProtoMessageInfo() *MessageInfo { } func (m *messageReflectWrapper) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { - mi := m.messageInfo() - mi.init() - for _, ri := range mi.rangeInfos { + m.messageInfo().init() + for _, ri := range m.messageInfo().rangeInfos { switch ri := ri.(type) { case *fieldInfo: if ri.has(m.pointer()) { @@ -185,86 +172,77 @@ func (m *messageReflectWrapper) Range(f func(protoreflect.FieldDescriptor, proto } case *oneofInfo: if n := ri.which(m.pointer()); n > 0 { - fi := mi.fields[n] + fi := m.messageInfo().fields[n] if !f(fi.fieldDesc, fi.get(m.pointer())) { return } } } } - mi.extensionMap(m.pointer()).Range(f) + m.messageInfo().extensionMap(m.pointer()).Range(f) } func (m *messageReflectWrapper) Has(fd protoreflect.FieldDescriptor) bool { - mi := m.messageInfo() - mi.init() - if fi, xd := mi.checkField(fd); fi != nil { + m.messageInfo().init() + if fi, xt := m.messageInfo().checkField(fd); fi != nil { return fi.has(m.pointer()) } else { - return mi.extensionMap(m.pointer()).Has(xd) + return m.messageInfo().extensionMap(m.pointer()).Has(xt) } } func (m *messageReflectWrapper) Clear(fd protoreflect.FieldDescriptor) { - mi := m.messageInfo() - mi.init() - if fi, xd := mi.checkField(fd); fi != nil { + m.messageInfo().init() + if fi, xt := m.messageInfo().checkField(fd); fi != nil { fi.clear(m.pointer()) } else { - mi.extensionMap(m.pointer()).Clear(xd) + m.messageInfo().extensionMap(m.pointer()).Clear(xt) } } func (m *messageReflectWrapper) Get(fd protoreflect.FieldDescriptor) protoreflect.Value { - mi := m.messageInfo() - mi.init() - if fi, xd := mi.checkField(fd); fi != nil { + m.messageInfo().init() + if fi, xt := m.messageInfo().checkField(fd); fi != nil { return fi.get(m.pointer()) } else { - return mi.extensionMap(m.pointer()).Get(xd) + return m.messageInfo().extensionMap(m.pointer()).Get(xt) } } func (m *messageReflectWrapper) Set(fd protoreflect.FieldDescriptor, v protoreflect.Value) { - mi := m.messageInfo() - mi.init() - if fi, xd := mi.checkField(fd); fi != nil { + m.messageInfo().init() + if fi, xt := m.messageInfo().checkField(fd); fi != nil { fi.set(m.pointer(), v) } else { - mi.extensionMap(m.pointer()).Set(xd, v) + m.messageInfo().extensionMap(m.pointer()).Set(xt, v) } } func (m *messageReflectWrapper) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { - mi := m.messageInfo() - mi.init() - if fi, xd := mi.checkField(fd); fi != nil { + m.messageInfo().init() + if fi, xt := m.messageInfo().checkField(fd); fi != nil { return fi.mutable(m.pointer()) } else { - return mi.extensionMap(m.pointer()).Mutable(xd) + return m.messageInfo().extensionMap(m.pointer()).Mutable(xt) } } func (m *messageReflectWrapper) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { - mi := m.messageInfo() - mi.init() - if fi, xd := mi.checkField(fd); fi != nil { + m.messageInfo().init() + if fi, xt := m.messageInfo().checkField(fd); fi != nil { return fi.newField() } else { - return xd.Type().New() + return xt.New() } } func (m *messageReflectWrapper) WhichOneof(od protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { - mi := m.messageInfo() - mi.init() - if oi := mi.oneofs[od.Name()]; oi != nil && oi.oneofDesc == od { + m.messageInfo().init() + if oi := m.messageInfo().oneofs[od.Name()]; oi != nil && oi.oneofDesc == od { return od.Fields().ByNumber(oi.which(m.pointer())) } panic("invalid oneof descriptor " + string(od.FullName()) + " for message " + string(m.Descriptor().FullName())) } func (m *messageReflectWrapper) GetUnknown() protoreflect.RawFields { - mi := m.messageInfo() - mi.init() - return mi.getUnknown(m.pointer()) + m.messageInfo().init() + return m.messageInfo().getUnknown(m.pointer()) } func (m *messageReflectWrapper) SetUnknown(b protoreflect.RawFields) { - mi := m.messageInfo() - mi.init() - mi.setUnknown(m.pointer(), b) + m.messageInfo().init() + m.messageInfo().setUnknown(m.pointer(), b) } func (m *messageReflectWrapper) IsValid() bool { return !m.pointer().IsNil() diff --git a/services/vendor/google.golang.org/protobuf/internal/impl/pointer_reflect.go b/services/vendor/google.golang.org/protobuf/internal/impl/pointer_reflect.go index da685e8a..517e9443 100644 --- a/services/vendor/google.golang.org/protobuf/internal/impl/pointer_reflect.go +++ b/services/vendor/google.golang.org/protobuf/internal/impl/pointer_reflect.go @@ -16,7 +16,7 @@ import ( const UnsafeEnabled = false // Pointer is an opaque pointer type. -type Pointer any +type Pointer interface{} // offset represents the offset to a struct field, accessible from a pointer. // The offset is the field index into a struct. @@ -62,7 +62,7 @@ func pointerOfValue(v reflect.Value) pointer { } // pointerOfIface returns the pointer portion of an interface. -func pointerOfIface(v any) pointer { +func pointerOfIface(v interface{}) pointer { return pointer{v: reflect.ValueOf(v)} } @@ -93,7 +93,7 @@ func (p pointer) AsValueOf(t reflect.Type) reflect.Value { // AsIfaceOf treats p as a pointer to an object of type t and returns the value. // It is equivalent to p.AsValueOf(t).Interface() -func (p pointer) AsIfaceOf(t reflect.Type) any { +func (p pointer) AsIfaceOf(t reflect.Type) interface{} { return p.AsValueOf(t).Interface() } diff --git a/services/vendor/google.golang.org/protobuf/internal/impl/pointer_unsafe.go b/services/vendor/google.golang.org/protobuf/internal/impl/pointer_unsafe.go index 5f20ca5d..4b020e31 100644 --- a/services/vendor/google.golang.org/protobuf/internal/impl/pointer_unsafe.go +++ b/services/vendor/google.golang.org/protobuf/internal/impl/pointer_unsafe.go @@ -50,7 +50,7 @@ func pointerOfValue(v reflect.Value) pointer { } // pointerOfIface returns the pointer portion of an interface. -func pointerOfIface(v any) pointer { +func pointerOfIface(v interface{}) pointer { type ifaceHeader struct { Type unsafe.Pointer Data unsafe.Pointer @@ -80,7 +80,7 @@ func (p pointer) AsValueOf(t reflect.Type) reflect.Value { // AsIfaceOf treats p as a pointer to an object of type t and returns the value. // It is equivalent to p.AsValueOf(t).Interface() -func (p pointer) AsIfaceOf(t reflect.Type) any { +func (p pointer) AsIfaceOf(t reflect.Type) interface{} { // TODO: Use tricky unsafe magic to directly create ifaceHeader. return p.AsValueOf(t).Interface() } diff --git a/services/vendor/google.golang.org/protobuf/internal/order/range.go b/services/vendor/google.golang.org/protobuf/internal/order/range.go index a1f09162..1665a68e 100644 --- a/services/vendor/google.golang.org/protobuf/internal/order/range.go +++ b/services/vendor/google.golang.org/protobuf/internal/order/range.go @@ -18,7 +18,7 @@ type messageField struct { } var messageFieldPool = sync.Pool{ - New: func() any { return new([]messageField) }, + New: func() interface{} { return new([]messageField) }, } type ( @@ -69,7 +69,7 @@ type mapEntry struct { } var mapEntryPool = sync.Pool{ - New: func() any { return new([]mapEntry) }, + New: func() interface{} { return new([]mapEntry) }, } type ( diff --git a/services/vendor/google.golang.org/protobuf/internal/version/version.go b/services/vendor/google.golang.org/protobuf/internal/version/version.go index dbbf1f68..a50fcfb4 100644 --- a/services/vendor/google.golang.org/protobuf/internal/version/version.go +++ b/services/vendor/google.golang.org/protobuf/internal/version/version.go @@ -51,8 +51,8 @@ import ( // 10. Send out the CL for review and submit it. const ( Major = 1 - Minor = 34 - Patch = 2 + Minor = 33 + Patch = 0 PreRelease = "" ) diff --git a/services/vendor/google.golang.org/protobuf/proto/decode.go b/services/vendor/google.golang.org/protobuf/proto/decode.go index d75a6534..e5b03b56 100644 --- a/services/vendor/google.golang.org/protobuf/proto/decode.go +++ b/services/vendor/google.golang.org/protobuf/proto/decode.go @@ -51,8 +51,6 @@ type UnmarshalOptions struct { // Unmarshal parses the wire-format message in b and places the result in m. // The provided message must be mutable (e.g., a non-nil pointer to a message). -// -// See the [UnmarshalOptions] type if you need more control. func Unmarshal(b []byte, m Message) error { _, err := UnmarshalOptions{RecursionLimit: protowire.DefaultRecursionLimit}.unmarshal(b, m.ProtoReflect()) return err diff --git a/services/vendor/google.golang.org/protobuf/proto/encode.go b/services/vendor/google.golang.org/protobuf/proto/encode.go index 1f847bcc..4fed202f 100644 --- a/services/vendor/google.golang.org/protobuf/proto/encode.go +++ b/services/vendor/google.golang.org/protobuf/proto/encode.go @@ -5,17 +5,12 @@ package proto import ( - "errors" - "fmt" - "google.golang.org/protobuf/encoding/protowire" "google.golang.org/protobuf/internal/encoding/messageset" "google.golang.org/protobuf/internal/order" "google.golang.org/protobuf/internal/pragma" "google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/runtime/protoiface" - - protoerrors "google.golang.org/protobuf/internal/errors" ) // MarshalOptions configures the marshaler. @@ -75,32 +70,7 @@ type MarshalOptions struct { UseCachedSize bool } -// flags turns the specified MarshalOptions (user-facing) into -// protoiface.MarshalInputFlags (used internally by the marshaler). -// -// See impl.marshalOptions.Options for the inverse operation. -func (o MarshalOptions) flags() protoiface.MarshalInputFlags { - var flags protoiface.MarshalInputFlags - - // Note: o.AllowPartial is always forced to true by MarshalOptions.marshal, - // which is why it is not a part of MarshalInputFlags. - - if o.Deterministic { - flags |= protoiface.MarshalDeterministic - } - - if o.UseCachedSize { - flags |= protoiface.MarshalUseCachedSize - } - - return flags -} - // Marshal returns the wire-format encoding of m. -// -// This is the most common entry point for encoding a Protobuf message. -// -// See the [MarshalOptions] type if you need more control. func Marshal(m Message) ([]byte, error) { // Treat nil message interface as an empty message; nothing to output. if m == nil { @@ -146,9 +116,6 @@ func emptyBytesForMessage(m Message) []byte { // MarshalAppend appends the wire-format encoding of m to b, // returning the result. -// -// This is a less common entry point than [Marshal], which is only needed if you -// need to supply your own buffers for performance reasons. func (o MarshalOptions) MarshalAppend(b []byte, m Message) ([]byte, error) { // Treat nil message interface as an empty message; nothing to append. if m == nil { @@ -178,7 +145,12 @@ func (o MarshalOptions) marshal(b []byte, m protoreflect.Message) (out protoifac in := protoiface.MarshalInput{ Message: m, Buf: b, - Flags: o.flags(), + } + if o.Deterministic { + in.Flags |= protoiface.MarshalDeterministic + } + if o.UseCachedSize { + in.Flags |= protoiface.MarshalUseCachedSize } if methods.Size != nil { sout := methods.Size(protoiface.SizeInput{ @@ -196,10 +168,6 @@ func (o MarshalOptions) marshal(b []byte, m protoreflect.Message) (out protoifac out.Buf, err = o.marshalMessageSlow(b, m) } if err != nil { - var mismatch *protoerrors.SizeMismatchError - if errors.As(err, &mismatch) { - return out, fmt.Errorf("marshaling %s: %v", string(m.Descriptor().FullName()), err) - } return out, err } if allowPartial { diff --git a/services/vendor/google.golang.org/protobuf/proto/extension.go b/services/vendor/google.golang.org/protobuf/proto/extension.go index d248f292..17899a3a 100644 --- a/services/vendor/google.golang.org/protobuf/proto/extension.go +++ b/services/vendor/google.golang.org/protobuf/proto/extension.go @@ -11,21 +11,18 @@ import ( // HasExtension reports whether an extension field is populated. // It returns false if m is invalid or if xt does not extend m. func HasExtension(m Message, xt protoreflect.ExtensionType) bool { - // Treat nil message interface or descriptor as an empty message; no populated - // fields. - if m == nil || xt == nil { + // Treat nil message interface as an empty message; no populated fields. + if m == nil { return false } // As a special-case, we reports invalid or mismatching descriptors // as always not being populated (since they aren't). - mr := m.ProtoReflect() - xd := xt.TypeDescriptor() - if mr.Descriptor() != xd.ContainingMessage() { + if xt == nil || m.ProtoReflect().Descriptor() != xt.TypeDescriptor().ContainingMessage() { return false } - return mr.Has(xd) + return m.ProtoReflect().Has(xt.TypeDescriptor()) } // ClearExtension clears an extension field such that subsequent @@ -39,7 +36,7 @@ func ClearExtension(m Message, xt protoreflect.ExtensionType) { // If the field is unpopulated, it returns the default value for // scalars and an immutable, empty value for lists or messages. // It panics if xt does not extend m. -func GetExtension(m Message, xt protoreflect.ExtensionType) any { +func GetExtension(m Message, xt protoreflect.ExtensionType) interface{} { // Treat nil message interface as an empty message; return the default. if m == nil { return xt.InterfaceOf(xt.Zero()) @@ -51,7 +48,7 @@ func GetExtension(m Message, xt protoreflect.ExtensionType) any { // SetExtension stores the value of an extension field. // It panics if m is invalid, xt does not extend m, or if type of v // is invalid for the specified extension field. -func SetExtension(m Message, xt protoreflect.ExtensionType, v any) { +func SetExtension(m Message, xt protoreflect.ExtensionType, v interface{}) { xd := xt.TypeDescriptor() pv := xt.ValueOf(v) @@ -78,7 +75,7 @@ func SetExtension(m Message, xt protoreflect.ExtensionType, v any) { // It returns immediately if f returns false. // While iterating, mutating operations may only be performed // on the current extension field. -func RangeExtensions(m Message, f func(protoreflect.ExtensionType, any) bool) { +func RangeExtensions(m Message, f func(protoreflect.ExtensionType, interface{}) bool) { // Treat nil message interface as an empty message; nothing to range over. if m == nil { return diff --git a/services/vendor/google.golang.org/protobuf/proto/messageset.go b/services/vendor/google.golang.org/protobuf/proto/messageset.go index 575d1483..312d5d45 100644 --- a/services/vendor/google.golang.org/protobuf/proto/messageset.go +++ b/services/vendor/google.golang.org/protobuf/proto/messageset.go @@ -47,16 +47,11 @@ func (o MarshalOptions) marshalMessageSet(b []byte, m protoreflect.Message) ([]b func (o MarshalOptions) marshalMessageSetField(b []byte, fd protoreflect.FieldDescriptor, value protoreflect.Value) ([]byte, error) { b = messageset.AppendFieldStart(b, fd.Number()) b = protowire.AppendTag(b, messageset.FieldMessage, protowire.BytesType) - calculatedSize := o.Size(value.Message().Interface()) - b = protowire.AppendVarint(b, uint64(calculatedSize)) - before := len(b) + b = protowire.AppendVarint(b, uint64(o.Size(value.Message().Interface()))) b, err := o.marshalMessage(b, value.Message()) if err != nil { return b, err } - if measuredSize := len(b) - before; calculatedSize != measuredSize { - return nil, errors.MismatchedSizeCalculation(calculatedSize, measuredSize) - } b = messageset.AppendFieldEnd(b) return b, nil } diff --git a/services/vendor/google.golang.org/protobuf/proto/size.go b/services/vendor/google.golang.org/protobuf/proto/size.go index 052fb5ae..f1692b49 100644 --- a/services/vendor/google.golang.org/protobuf/proto/size.go +++ b/services/vendor/google.golang.org/protobuf/proto/size.go @@ -34,7 +34,6 @@ func (o MarshalOptions) size(m protoreflect.Message) (size int) { if methods != nil && methods.Size != nil { out := methods.Size(protoiface.SizeInput{ Message: m, - Flags: o.flags(), }) return out.Size } @@ -43,7 +42,6 @@ func (o MarshalOptions) size(m protoreflect.Message) (size int) { // This case is mainly used for legacy types with a Marshal method. out, _ := methods.Marshal(protoiface.MarshalInput{ Message: m, - Flags: o.flags(), }) return len(out.Buf) } diff --git a/services/vendor/google.golang.org/protobuf/reflect/protodesc/desc.go b/services/vendor/google.golang.org/protobuf/reflect/protodesc/desc.go new file mode 100644 index 00000000..baa0cc62 --- /dev/null +++ b/services/vendor/google.golang.org/protobuf/reflect/protodesc/desc.go @@ -0,0 +1,285 @@ +// Copyright 2018 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 protodesc provides functionality for converting +// FileDescriptorProto messages to/from [protoreflect.FileDescriptor] values. +// +// The google.protobuf.FileDescriptorProto is a protobuf message that describes +// the type information for a .proto file in a form that is easily serializable. +// The [protoreflect.FileDescriptor] is a more structured representation of +// the FileDescriptorProto message where references and remote dependencies +// can be directly followed. +package protodesc + +import ( + "google.golang.org/protobuf/internal/errors" + "google.golang.org/protobuf/internal/filedesc" + "google.golang.org/protobuf/internal/pragma" + "google.golang.org/protobuf/internal/strs" + "google.golang.org/protobuf/proto" + "google.golang.org/protobuf/reflect/protoreflect" + "google.golang.org/protobuf/reflect/protoregistry" + + "google.golang.org/protobuf/types/descriptorpb" +) + +// Resolver is the resolver used by [NewFile] to resolve dependencies. +// The enums and messages provided must belong to some parent file, +// which is also registered. +// +// It is implemented by [protoregistry.Files]. +type Resolver interface { + FindFileByPath(string) (protoreflect.FileDescriptor, error) + FindDescriptorByName(protoreflect.FullName) (protoreflect.Descriptor, error) +} + +// FileOptions configures the construction of file descriptors. +type FileOptions struct { + pragma.NoUnkeyedLiterals + + // AllowUnresolvable configures New to permissively allow unresolvable + // file, enum, or message dependencies. Unresolved dependencies are replaced + // by placeholder equivalents. + // + // The following dependencies may be left unresolved: + // • Resolving an imported file. + // • Resolving the type for a message field or extension field. + // If the kind of the field is unknown, then a placeholder is used for both + // the Enum and Message accessors on the protoreflect.FieldDescriptor. + // • Resolving an enum value set as the default for an optional enum field. + // If unresolvable, the protoreflect.FieldDescriptor.Default is set to the + // first value in the associated enum (or zero if the also enum dependency + // is also unresolvable). The protoreflect.FieldDescriptor.DefaultEnumValue + // is populated with a placeholder. + // • Resolving the extended message type for an extension field. + // • Resolving the input or output message type for a service method. + // + // If the unresolved dependency uses a relative name, + // then the placeholder will contain an invalid FullName with a "*." prefix, + // indicating that the starting prefix of the full name is unknown. + AllowUnresolvable bool +} + +// NewFile creates a new [protoreflect.FileDescriptor] from the provided +// file descriptor message. See [FileOptions.New] for more information. +func NewFile(fd *descriptorpb.FileDescriptorProto, r Resolver) (protoreflect.FileDescriptor, error) { + return FileOptions{}.New(fd, r) +} + +// NewFiles creates a new [protoregistry.Files] from the provided +// FileDescriptorSet message. See [FileOptions.NewFiles] for more information. +func NewFiles(fd *descriptorpb.FileDescriptorSet) (*protoregistry.Files, error) { + return FileOptions{}.NewFiles(fd) +} + +// New creates a new [protoreflect.FileDescriptor] from the provided +// file descriptor message. The file must represent a valid proto file according +// to protobuf semantics. The returned descriptor is a deep copy of the input. +// +// Any imported files, enum types, or message types referenced in the file are +// resolved using the provided registry. When looking up an import file path, +// the path must be unique. The newly created file descriptor is not registered +// back into the provided file registry. +func (o FileOptions) New(fd *descriptorpb.FileDescriptorProto, r Resolver) (protoreflect.FileDescriptor, error) { + if r == nil { + r = (*protoregistry.Files)(nil) // empty resolver + } + + // Handle the file descriptor content. + f := &filedesc.File{L2: &filedesc.FileL2{}} + switch fd.GetSyntax() { + case "proto2", "": + f.L1.Syntax = protoreflect.Proto2 + case "proto3": + f.L1.Syntax = protoreflect.Proto3 + case "editions": + f.L1.Syntax = protoreflect.Editions + f.L1.Edition = fromEditionProto(fd.GetEdition()) + default: + return nil, errors.New("invalid syntax: %q", fd.GetSyntax()) + } + if f.L1.Syntax == protoreflect.Editions && (fd.GetEdition() < SupportedEditionsMinimum || fd.GetEdition() > SupportedEditionsMaximum) { + return nil, errors.New("use of edition %v not yet supported by the Go Protobuf runtime", fd.GetEdition()) + } + f.L1.Path = fd.GetName() + if f.L1.Path == "" { + return nil, errors.New("file path must be populated") + } + f.L1.Package = protoreflect.FullName(fd.GetPackage()) + if !f.L1.Package.IsValid() && f.L1.Package != "" { + return nil, errors.New("invalid package: %q", f.L1.Package) + } + if opts := fd.GetOptions(); opts != nil { + opts = proto.Clone(opts).(*descriptorpb.FileOptions) + f.L2.Options = func() protoreflect.ProtoMessage { return opts } + } + if f.L1.Syntax == protoreflect.Editions { + initFileDescFromFeatureSet(f, fd.GetOptions().GetFeatures()) + } + + f.L2.Imports = make(filedesc.FileImports, len(fd.GetDependency())) + for _, i := range fd.GetPublicDependency() { + if !(0 <= i && int(i) < len(f.L2.Imports)) || f.L2.Imports[i].IsPublic { + return nil, errors.New("invalid or duplicate public import index: %d", i) + } + f.L2.Imports[i].IsPublic = true + } + for _, i := range fd.GetWeakDependency() { + if !(0 <= i && int(i) < len(f.L2.Imports)) || f.L2.Imports[i].IsWeak { + return nil, errors.New("invalid or duplicate weak import index: %d", i) + } + f.L2.Imports[i].IsWeak = true + } + imps := importSet{f.Path(): true} + for i, path := range fd.GetDependency() { + imp := &f.L2.Imports[i] + f, err := r.FindFileByPath(path) + if err == protoregistry.NotFound && (o.AllowUnresolvable || imp.IsWeak) { + f = filedesc.PlaceholderFile(path) + } else if err != nil { + return nil, errors.New("could not resolve import %q: %v", path, err) + } + imp.FileDescriptor = f + + if imps[imp.Path()] { + return nil, errors.New("already imported %q", path) + } + imps[imp.Path()] = true + } + for i := range fd.GetDependency() { + imp := &f.L2.Imports[i] + imps.importPublic(imp.Imports()) + } + + // Handle source locations. + f.L2.Locations.File = f + for _, loc := range fd.GetSourceCodeInfo().GetLocation() { + var l protoreflect.SourceLocation + // TODO: Validate that the path points to an actual declaration? + l.Path = protoreflect.SourcePath(loc.GetPath()) + s := loc.GetSpan() + switch len(s) { + case 3: + l.StartLine, l.StartColumn, l.EndLine, l.EndColumn = int(s[0]), int(s[1]), int(s[0]), int(s[2]) + case 4: + l.StartLine, l.StartColumn, l.EndLine, l.EndColumn = int(s[0]), int(s[1]), int(s[2]), int(s[3]) + default: + return nil, errors.New("invalid span: %v", s) + } + // TODO: Validate that the span information is sensible? + // See https://github.com/protocolbuffers/protobuf/issues/6378. + if false && (l.EndLine < l.StartLine || l.StartLine < 0 || l.StartColumn < 0 || l.EndColumn < 0 || + (l.StartLine == l.EndLine && l.EndColumn <= l.StartColumn)) { + return nil, errors.New("invalid span: %v", s) + } + l.LeadingDetachedComments = loc.GetLeadingDetachedComments() + l.LeadingComments = loc.GetLeadingComments() + l.TrailingComments = loc.GetTrailingComments() + f.L2.Locations.List = append(f.L2.Locations.List, l) + } + + // Step 1: Allocate and derive the names for all declarations. + // This copies all fields from the descriptor proto except: + // google.protobuf.FieldDescriptorProto.type_name + // google.protobuf.FieldDescriptorProto.default_value + // google.protobuf.FieldDescriptorProto.oneof_index + // google.protobuf.FieldDescriptorProto.extendee + // google.protobuf.MethodDescriptorProto.input + // google.protobuf.MethodDescriptorProto.output + var err error + sb := new(strs.Builder) + r1 := make(descsByName) + if f.L1.Enums.List, err = r1.initEnumDeclarations(fd.GetEnumType(), f, sb); err != nil { + return nil, err + } + if f.L1.Messages.List, err = r1.initMessagesDeclarations(fd.GetMessageType(), f, sb); err != nil { + return nil, err + } + if f.L1.Extensions.List, err = r1.initExtensionDeclarations(fd.GetExtension(), f, sb); err != nil { + return nil, err + } + if f.L1.Services.List, err = r1.initServiceDeclarations(fd.GetService(), f, sb); err != nil { + return nil, err + } + + // Step 2: Resolve every dependency reference not handled by step 1. + r2 := &resolver{local: r1, remote: r, imports: imps, allowUnresolvable: o.AllowUnresolvable} + if err := r2.resolveMessageDependencies(f.L1.Messages.List, fd.GetMessageType()); err != nil { + return nil, err + } + if err := r2.resolveExtensionDependencies(f.L1.Extensions.List, fd.GetExtension()); err != nil { + return nil, err + } + if err := r2.resolveServiceDependencies(f.L1.Services.List, fd.GetService()); err != nil { + return nil, err + } + + // Step 3: Validate every enum, message, and extension declaration. + if err := validateEnumDeclarations(f.L1.Enums.List, fd.GetEnumType()); err != nil { + return nil, err + } + if err := validateMessageDeclarations(f.L1.Messages.List, fd.GetMessageType()); err != nil { + return nil, err + } + if err := validateExtensionDeclarations(f.L1.Extensions.List, fd.GetExtension()); err != nil { + return nil, err + } + + return f, nil +} + +type importSet map[string]bool + +func (is importSet) importPublic(imps protoreflect.FileImports) { + for i := 0; i < imps.Len(); i++ { + if imp := imps.Get(i); imp.IsPublic { + is[imp.Path()] = true + is.importPublic(imp.Imports()) + } + } +} + +// NewFiles creates a new [protoregistry.Files] from the provided +// FileDescriptorSet message. The descriptor set must include only +// valid files according to protobuf semantics. The returned descriptors +// are a deep copy of the input. +func (o FileOptions) NewFiles(fds *descriptorpb.FileDescriptorSet) (*protoregistry.Files, error) { + files := make(map[string]*descriptorpb.FileDescriptorProto) + for _, fd := range fds.File { + if _, ok := files[fd.GetName()]; ok { + return nil, errors.New("file appears multiple times: %q", fd.GetName()) + } + files[fd.GetName()] = fd + } + r := &protoregistry.Files{} + for _, fd := range files { + if err := o.addFileDeps(r, fd, files); err != nil { + return nil, err + } + } + return r, nil +} +func (o FileOptions) addFileDeps(r *protoregistry.Files, fd *descriptorpb.FileDescriptorProto, files map[string]*descriptorpb.FileDescriptorProto) error { + // Set the entry to nil while descending into a file's dependencies to detect cycles. + files[fd.GetName()] = nil + for _, dep := range fd.Dependency { + depfd, ok := files[dep] + if depfd == nil { + if ok { + return errors.New("import cycle in file: %q", dep) + } + continue + } + if err := o.addFileDeps(r, depfd, files); err != nil { + return err + } + } + // Delete the entry once dependencies are processed. + delete(files, fd.GetName()) + f, err := o.New(fd, r) + if err != nil { + return err + } + return r.RegisterFile(f) +} diff --git a/services/vendor/google.golang.org/protobuf/reflect/protodesc/desc_init.go b/services/vendor/google.golang.org/protobuf/reflect/protodesc/desc_init.go new file mode 100644 index 00000000..b3278163 --- /dev/null +++ b/services/vendor/google.golang.org/protobuf/reflect/protodesc/desc_init.go @@ -0,0 +1,304 @@ +// Copyright 2019 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 protodesc + +import ( + "google.golang.org/protobuf/internal/errors" + "google.golang.org/protobuf/internal/filedesc" + "google.golang.org/protobuf/internal/strs" + "google.golang.org/protobuf/proto" + "google.golang.org/protobuf/reflect/protoreflect" + + "google.golang.org/protobuf/types/descriptorpb" +) + +type descsByName map[protoreflect.FullName]protoreflect.Descriptor + +func (r descsByName) initEnumDeclarations(eds []*descriptorpb.EnumDescriptorProto, parent protoreflect.Descriptor, sb *strs.Builder) (es []filedesc.Enum, err error) { + es = make([]filedesc.Enum, len(eds)) // allocate up-front to ensure stable pointers + for i, ed := range eds { + e := &es[i] + e.L2 = new(filedesc.EnumL2) + if e.L0, err = r.makeBase(e, parent, ed.GetName(), i, sb); err != nil { + return nil, err + } + if opts := ed.GetOptions(); opts != nil { + opts = proto.Clone(opts).(*descriptorpb.EnumOptions) + e.L2.Options = func() protoreflect.ProtoMessage { return opts } + } + e.L1.EditionFeatures = mergeEditionFeatures(parent, ed.GetOptions().GetFeatures()) + for _, s := range ed.GetReservedName() { + e.L2.ReservedNames.List = append(e.L2.ReservedNames.List, protoreflect.Name(s)) + } + for _, rr := range ed.GetReservedRange() { + e.L2.ReservedRanges.List = append(e.L2.ReservedRanges.List, [2]protoreflect.EnumNumber{ + protoreflect.EnumNumber(rr.GetStart()), + protoreflect.EnumNumber(rr.GetEnd()), + }) + } + if e.L2.Values.List, err = r.initEnumValuesFromDescriptorProto(ed.GetValue(), e, sb); err != nil { + return nil, err + } + } + return es, nil +} + +func (r descsByName) initEnumValuesFromDescriptorProto(vds []*descriptorpb.EnumValueDescriptorProto, parent protoreflect.Descriptor, sb *strs.Builder) (vs []filedesc.EnumValue, err error) { + vs = make([]filedesc.EnumValue, len(vds)) // allocate up-front to ensure stable pointers + for i, vd := range vds { + v := &vs[i] + if v.L0, err = r.makeBase(v, parent, vd.GetName(), i, sb); err != nil { + return nil, err + } + if opts := vd.GetOptions(); opts != nil { + opts = proto.Clone(opts).(*descriptorpb.EnumValueOptions) + v.L1.Options = func() protoreflect.ProtoMessage { return opts } + } + v.L1.Number = protoreflect.EnumNumber(vd.GetNumber()) + } + return vs, nil +} + +func (r descsByName) initMessagesDeclarations(mds []*descriptorpb.DescriptorProto, parent protoreflect.Descriptor, sb *strs.Builder) (ms []filedesc.Message, err error) { + ms = make([]filedesc.Message, len(mds)) // allocate up-front to ensure stable pointers + for i, md := range mds { + m := &ms[i] + m.L2 = new(filedesc.MessageL2) + if m.L0, err = r.makeBase(m, parent, md.GetName(), i, sb); err != nil { + return nil, err + } + if m.Base.L0.ParentFile.Syntax() == protoreflect.Editions { + m.L1.EditionFeatures = mergeEditionFeatures(parent, md.GetOptions().GetFeatures()) + } + if opts := md.GetOptions(); opts != nil { + opts = proto.Clone(opts).(*descriptorpb.MessageOptions) + m.L2.Options = func() protoreflect.ProtoMessage { return opts } + m.L1.IsMapEntry = opts.GetMapEntry() + m.L1.IsMessageSet = opts.GetMessageSetWireFormat() + } + for _, s := range md.GetReservedName() { + m.L2.ReservedNames.List = append(m.L2.ReservedNames.List, protoreflect.Name(s)) + } + for _, rr := range md.GetReservedRange() { + m.L2.ReservedRanges.List = append(m.L2.ReservedRanges.List, [2]protoreflect.FieldNumber{ + protoreflect.FieldNumber(rr.GetStart()), + protoreflect.FieldNumber(rr.GetEnd()), + }) + } + for _, xr := range md.GetExtensionRange() { + m.L2.ExtensionRanges.List = append(m.L2.ExtensionRanges.List, [2]protoreflect.FieldNumber{ + protoreflect.FieldNumber(xr.GetStart()), + protoreflect.FieldNumber(xr.GetEnd()), + }) + var optsFunc func() protoreflect.ProtoMessage + if opts := xr.GetOptions(); opts != nil { + opts = proto.Clone(opts).(*descriptorpb.ExtensionRangeOptions) + optsFunc = func() protoreflect.ProtoMessage { return opts } + } + m.L2.ExtensionRangeOptions = append(m.L2.ExtensionRangeOptions, optsFunc) + } + if m.L2.Fields.List, err = r.initFieldsFromDescriptorProto(md.GetField(), m, sb); err != nil { + return nil, err + } + if m.L2.Oneofs.List, err = r.initOneofsFromDescriptorProto(md.GetOneofDecl(), m, sb); err != nil { + return nil, err + } + if m.L1.Enums.List, err = r.initEnumDeclarations(md.GetEnumType(), m, sb); err != nil { + return nil, err + } + if m.L1.Messages.List, err = r.initMessagesDeclarations(md.GetNestedType(), m, sb); err != nil { + return nil, err + } + if m.L1.Extensions.List, err = r.initExtensionDeclarations(md.GetExtension(), m, sb); err != nil { + return nil, err + } + } + return ms, nil +} + +// canBePacked returns whether the field can use packed encoding: +// https://protobuf.dev/programming-guides/encoding/#packed +func canBePacked(fd *descriptorpb.FieldDescriptorProto) bool { + if fd.GetLabel() != descriptorpb.FieldDescriptorProto_LABEL_REPEATED { + return false // not a repeated field + } + + switch protoreflect.Kind(fd.GetType()) { + case protoreflect.MessageKind, protoreflect.GroupKind: + return false // not a scalar type field + + case protoreflect.StringKind, protoreflect.BytesKind: + // string and bytes can explicitly not be declared as packed, + // see https://protobuf.dev/programming-guides/encoding/#packed + return false + + default: + return true + } +} + +func (r descsByName) initFieldsFromDescriptorProto(fds []*descriptorpb.FieldDescriptorProto, parent protoreflect.Descriptor, sb *strs.Builder) (fs []filedesc.Field, err error) { + fs = make([]filedesc.Field, len(fds)) // allocate up-front to ensure stable pointers + for i, fd := range fds { + f := &fs[i] + if f.L0, err = r.makeBase(f, parent, fd.GetName(), i, sb); err != nil { + return nil, err + } + f.L1.IsProto3Optional = fd.GetProto3Optional() + if opts := fd.GetOptions(); opts != nil { + opts = proto.Clone(opts).(*descriptorpb.FieldOptions) + f.L1.Options = func() protoreflect.ProtoMessage { return opts } + f.L1.IsWeak = opts.GetWeak() + f.L1.HasPacked = opts.Packed != nil + f.L1.IsPacked = opts.GetPacked() + } + f.L1.Number = protoreflect.FieldNumber(fd.GetNumber()) + f.L1.Cardinality = protoreflect.Cardinality(fd.GetLabel()) + if fd.Type != nil { + f.L1.Kind = protoreflect.Kind(fd.GetType()) + } + if fd.JsonName != nil { + f.L1.StringName.InitJSON(fd.GetJsonName()) + } + + if f.Base.L0.ParentFile.Syntax() == protoreflect.Editions { + f.L1.EditionFeatures = mergeEditionFeatures(parent, fd.GetOptions().GetFeatures()) + + if f.L1.EditionFeatures.IsLegacyRequired { + f.L1.Cardinality = protoreflect.Required + } + // We reuse the existing field because the old option `[packed = + // true]` is mutually exclusive with the editions feature. + if canBePacked(fd) { + f.L1.HasPacked = true + f.L1.IsPacked = f.L1.EditionFeatures.IsPacked + } + + // We pretend this option is always explicitly set because the only + // use of HasEnforceUTF8 is to determine whether to use EnforceUTF8 + // or to return the appropriate default. + // When using editions we either parse the option or resolve the + // appropriate default here (instead of later when this option is + // requested from the descriptor). + // In proto2/proto3 syntax HasEnforceUTF8 might be false. + f.L1.HasEnforceUTF8 = true + f.L1.EnforceUTF8 = f.L1.EditionFeatures.IsUTF8Validated + + if f.L1.Kind == protoreflect.MessageKind && f.L1.EditionFeatures.IsDelimitedEncoded { + f.L1.Kind = protoreflect.GroupKind + } + } + } + return fs, nil +} + +func (r descsByName) initOneofsFromDescriptorProto(ods []*descriptorpb.OneofDescriptorProto, parent protoreflect.Descriptor, sb *strs.Builder) (os []filedesc.Oneof, err error) { + os = make([]filedesc.Oneof, len(ods)) // allocate up-front to ensure stable pointers + for i, od := range ods { + o := &os[i] + if o.L0, err = r.makeBase(o, parent, od.GetName(), i, sb); err != nil { + return nil, err + } + if opts := od.GetOptions(); opts != nil { + opts = proto.Clone(opts).(*descriptorpb.OneofOptions) + o.L1.Options = func() protoreflect.ProtoMessage { return opts } + if parent.Syntax() == protoreflect.Editions { + o.L1.EditionFeatures = mergeEditionFeatures(parent, opts.GetFeatures()) + } + } + } + return os, nil +} + +func (r descsByName) initExtensionDeclarations(xds []*descriptorpb.FieldDescriptorProto, parent protoreflect.Descriptor, sb *strs.Builder) (xs []filedesc.Extension, err error) { + xs = make([]filedesc.Extension, len(xds)) // allocate up-front to ensure stable pointers + for i, xd := range xds { + x := &xs[i] + x.L2 = new(filedesc.ExtensionL2) + if x.L0, err = r.makeBase(x, parent, xd.GetName(), i, sb); err != nil { + return nil, err + } + if opts := xd.GetOptions(); opts != nil { + opts = proto.Clone(opts).(*descriptorpb.FieldOptions) + x.L2.Options = func() protoreflect.ProtoMessage { return opts } + x.L2.IsPacked = opts.GetPacked() + } + x.L1.Number = protoreflect.FieldNumber(xd.GetNumber()) + x.L1.Cardinality = protoreflect.Cardinality(xd.GetLabel()) + if xd.Type != nil { + x.L1.Kind = protoreflect.Kind(xd.GetType()) + } + if xd.JsonName != nil { + x.L2.StringName.InitJSON(xd.GetJsonName()) + } + } + return xs, nil +} + +func (r descsByName) initServiceDeclarations(sds []*descriptorpb.ServiceDescriptorProto, parent protoreflect.Descriptor, sb *strs.Builder) (ss []filedesc.Service, err error) { + ss = make([]filedesc.Service, len(sds)) // allocate up-front to ensure stable pointers + for i, sd := range sds { + s := &ss[i] + s.L2 = new(filedesc.ServiceL2) + if s.L0, err = r.makeBase(s, parent, sd.GetName(), i, sb); err != nil { + return nil, err + } + if opts := sd.GetOptions(); opts != nil { + opts = proto.Clone(opts).(*descriptorpb.ServiceOptions) + s.L2.Options = func() protoreflect.ProtoMessage { return opts } + } + if s.L2.Methods.List, err = r.initMethodsFromDescriptorProto(sd.GetMethod(), s, sb); err != nil { + return nil, err + } + } + return ss, nil +} + +func (r descsByName) initMethodsFromDescriptorProto(mds []*descriptorpb.MethodDescriptorProto, parent protoreflect.Descriptor, sb *strs.Builder) (ms []filedesc.Method, err error) { + ms = make([]filedesc.Method, len(mds)) // allocate up-front to ensure stable pointers + for i, md := range mds { + m := &ms[i] + if m.L0, err = r.makeBase(m, parent, md.GetName(), i, sb); err != nil { + return nil, err + } + if opts := md.GetOptions(); opts != nil { + opts = proto.Clone(opts).(*descriptorpb.MethodOptions) + m.L1.Options = func() protoreflect.ProtoMessage { return opts } + } + m.L1.IsStreamingClient = md.GetClientStreaming() + m.L1.IsStreamingServer = md.GetServerStreaming() + } + return ms, nil +} + +func (r descsByName) makeBase(child, parent protoreflect.Descriptor, name string, idx int, sb *strs.Builder) (filedesc.BaseL0, error) { + if !protoreflect.Name(name).IsValid() { + return filedesc.BaseL0{}, errors.New("descriptor %q has an invalid nested name: %q", parent.FullName(), name) + } + + // Derive the full name of the child. + // Note that enum values are a sibling to the enum parent in the namespace. + var fullName protoreflect.FullName + if _, ok := parent.(protoreflect.EnumDescriptor); ok { + fullName = sb.AppendFullName(parent.FullName().Parent(), protoreflect.Name(name)) + } else { + fullName = sb.AppendFullName(parent.FullName(), protoreflect.Name(name)) + } + if _, ok := r[fullName]; ok { + return filedesc.BaseL0{}, errors.New("descriptor %q already declared", fullName) + } + r[fullName] = child + + // TODO: Verify that the full name does not already exist in the resolver? + // This is not as critical since most usages of NewFile will register + // the created file back into the registry, which will perform this check. + + return filedesc.BaseL0{ + FullName: fullName, + ParentFile: parent.ParentFile().(*filedesc.File), + Parent: parent, + Index: idx, + }, nil +} diff --git a/services/vendor/google.golang.org/protobuf/reflect/protodesc/desc_resolve.go b/services/vendor/google.golang.org/protobuf/reflect/protodesc/desc_resolve.go new file mode 100644 index 00000000..254ca585 --- /dev/null +++ b/services/vendor/google.golang.org/protobuf/reflect/protodesc/desc_resolve.go @@ -0,0 +1,286 @@ +// Copyright 2019 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 protodesc + +import ( + "google.golang.org/protobuf/internal/encoding/defval" + "google.golang.org/protobuf/internal/errors" + "google.golang.org/protobuf/internal/filedesc" + "google.golang.org/protobuf/reflect/protoreflect" + "google.golang.org/protobuf/reflect/protoregistry" + + "google.golang.org/protobuf/types/descriptorpb" +) + +// resolver is a wrapper around a local registry of declarations within the file +// and the remote resolver. The remote resolver is restricted to only return +// descriptors that have been imported. +type resolver struct { + local descsByName + remote Resolver + imports importSet + + allowUnresolvable bool +} + +func (r *resolver) resolveMessageDependencies(ms []filedesc.Message, mds []*descriptorpb.DescriptorProto) (err error) { + for i, md := range mds { + m := &ms[i] + for j, fd := range md.GetField() { + f := &m.L2.Fields.List[j] + if f.L1.Cardinality == protoreflect.Required { + m.L2.RequiredNumbers.List = append(m.L2.RequiredNumbers.List, f.L1.Number) + } + if fd.OneofIndex != nil { + k := int(fd.GetOneofIndex()) + if !(0 <= k && k < len(md.GetOneofDecl())) { + return errors.New("message field %q has an invalid oneof index: %d", f.FullName(), k) + } + o := &m.L2.Oneofs.List[k] + f.L1.ContainingOneof = o + o.L1.Fields.List = append(o.L1.Fields.List, f) + } + + if f.L1.Kind, f.L1.Enum, f.L1.Message, err = r.findTarget(f.Kind(), f.Parent().FullName(), partialName(fd.GetTypeName()), f.IsWeak()); err != nil { + return errors.New("message field %q cannot resolve type: %v", f.FullName(), err) + } + if fd.DefaultValue != nil { + v, ev, err := unmarshalDefault(fd.GetDefaultValue(), f, r.allowUnresolvable) + if err != nil { + return errors.New("message field %q has invalid default: %v", f.FullName(), err) + } + f.L1.Default = filedesc.DefaultValue(v, ev) + } + } + + if err := r.resolveMessageDependencies(m.L1.Messages.List, md.GetNestedType()); err != nil { + return err + } + if err := r.resolveExtensionDependencies(m.L1.Extensions.List, md.GetExtension()); err != nil { + return err + } + } + return nil +} + +func (r *resolver) resolveExtensionDependencies(xs []filedesc.Extension, xds []*descriptorpb.FieldDescriptorProto) (err error) { + for i, xd := range xds { + x := &xs[i] + if x.L1.Extendee, err = r.findMessageDescriptor(x.Parent().FullName(), partialName(xd.GetExtendee()), false); err != nil { + return errors.New("extension field %q cannot resolve extendee: %v", x.FullName(), err) + } + if x.L1.Kind, x.L2.Enum, x.L2.Message, err = r.findTarget(x.Kind(), x.Parent().FullName(), partialName(xd.GetTypeName()), false); err != nil { + return errors.New("extension field %q cannot resolve type: %v", x.FullName(), err) + } + if xd.DefaultValue != nil { + v, ev, err := unmarshalDefault(xd.GetDefaultValue(), x, r.allowUnresolvable) + if err != nil { + return errors.New("extension field %q has invalid default: %v", x.FullName(), err) + } + x.L2.Default = filedesc.DefaultValue(v, ev) + } + } + return nil +} + +func (r *resolver) resolveServiceDependencies(ss []filedesc.Service, sds []*descriptorpb.ServiceDescriptorProto) (err error) { + for i, sd := range sds { + s := &ss[i] + for j, md := range sd.GetMethod() { + m := &s.L2.Methods.List[j] + m.L1.Input, err = r.findMessageDescriptor(m.Parent().FullName(), partialName(md.GetInputType()), false) + if err != nil { + return errors.New("service method %q cannot resolve input: %v", m.FullName(), err) + } + m.L1.Output, err = r.findMessageDescriptor(s.FullName(), partialName(md.GetOutputType()), false) + if err != nil { + return errors.New("service method %q cannot resolve output: %v", m.FullName(), err) + } + } + } + return nil +} + +// findTarget finds an enum or message descriptor if k is an enum, message, +// group, or unknown. If unknown, and the name could be resolved, the kind +// returned kind is set based on the type of the resolved descriptor. +func (r *resolver) findTarget(k protoreflect.Kind, scope protoreflect.FullName, ref partialName, isWeak bool) (protoreflect.Kind, protoreflect.EnumDescriptor, protoreflect.MessageDescriptor, error) { + switch k { + case protoreflect.EnumKind: + ed, err := r.findEnumDescriptor(scope, ref, isWeak) + if err != nil { + return 0, nil, nil, err + } + return k, ed, nil, nil + case protoreflect.MessageKind, protoreflect.GroupKind: + md, err := r.findMessageDescriptor(scope, ref, isWeak) + if err != nil { + return 0, nil, nil, err + } + return k, nil, md, nil + case 0: + // Handle unspecified kinds (possible with parsers that operate + // on a per-file basis without knowledge of dependencies). + d, err := r.findDescriptor(scope, ref) + if err == protoregistry.NotFound && (r.allowUnresolvable || isWeak) { + return k, filedesc.PlaceholderEnum(ref.FullName()), filedesc.PlaceholderMessage(ref.FullName()), nil + } else if err == protoregistry.NotFound { + return 0, nil, nil, errors.New("%q not found", ref.FullName()) + } else if err != nil { + return 0, nil, nil, err + } + switch d := d.(type) { + case protoreflect.EnumDescriptor: + return protoreflect.EnumKind, d, nil, nil + case protoreflect.MessageDescriptor: + return protoreflect.MessageKind, nil, d, nil + default: + return 0, nil, nil, errors.New("unknown kind") + } + default: + if ref != "" { + return 0, nil, nil, errors.New("target name cannot be specified for %v", k) + } + if !k.IsValid() { + return 0, nil, nil, errors.New("invalid kind: %d", k) + } + return k, nil, nil, nil + } +} + +// findDescriptor finds the descriptor by name, +// which may be a relative name within some scope. +// +// Suppose the scope was "fizz.buzz" and the reference was "Foo.Bar", +// then the following full names are searched: +// - fizz.buzz.Foo.Bar +// - fizz.Foo.Bar +// - Foo.Bar +func (r *resolver) findDescriptor(scope protoreflect.FullName, ref partialName) (protoreflect.Descriptor, error) { + if !ref.IsValid() { + return nil, errors.New("invalid name reference: %q", ref) + } + if ref.IsFull() { + scope, ref = "", ref[1:] + } + var foundButNotImported protoreflect.Descriptor + for { + // Derive the full name to search. + s := protoreflect.FullName(ref) + if scope != "" { + s = scope + "." + s + } + + // Check the current file for the descriptor. + if d, ok := r.local[s]; ok { + return d, nil + } + + // Check the remote registry for the descriptor. + d, err := r.remote.FindDescriptorByName(s) + if err == nil { + // Only allow descriptors covered by one of the imports. + if r.imports[d.ParentFile().Path()] { + return d, nil + } + foundButNotImported = d + } else if err != protoregistry.NotFound { + return nil, errors.Wrap(err, "%q", s) + } + + // Continue on at a higher level of scoping. + if scope == "" { + if d := foundButNotImported; d != nil { + return nil, errors.New("resolved %q, but %q is not imported", d.FullName(), d.ParentFile().Path()) + } + return nil, protoregistry.NotFound + } + scope = scope.Parent() + } +} + +func (r *resolver) findEnumDescriptor(scope protoreflect.FullName, ref partialName, isWeak bool) (protoreflect.EnumDescriptor, error) { + d, err := r.findDescriptor(scope, ref) + if err == protoregistry.NotFound && (r.allowUnresolvable || isWeak) { + return filedesc.PlaceholderEnum(ref.FullName()), nil + } else if err == protoregistry.NotFound { + return nil, errors.New("%q not found", ref.FullName()) + } else if err != nil { + return nil, err + } + ed, ok := d.(protoreflect.EnumDescriptor) + if !ok { + return nil, errors.New("resolved %q, but it is not an enum", d.FullName()) + } + return ed, nil +} + +func (r *resolver) findMessageDescriptor(scope protoreflect.FullName, ref partialName, isWeak bool) (protoreflect.MessageDescriptor, error) { + d, err := r.findDescriptor(scope, ref) + if err == protoregistry.NotFound && (r.allowUnresolvable || isWeak) { + return filedesc.PlaceholderMessage(ref.FullName()), nil + } else if err == protoregistry.NotFound { + return nil, errors.New("%q not found", ref.FullName()) + } else if err != nil { + return nil, err + } + md, ok := d.(protoreflect.MessageDescriptor) + if !ok { + return nil, errors.New("resolved %q, but it is not an message", d.FullName()) + } + return md, nil +} + +// partialName is the partial name. A leading dot means that the name is full, +// otherwise the name is relative to some current scope. +// See google.protobuf.FieldDescriptorProto.type_name. +type partialName string + +func (s partialName) IsFull() bool { + return len(s) > 0 && s[0] == '.' +} + +func (s partialName) IsValid() bool { + if s.IsFull() { + return protoreflect.FullName(s[1:]).IsValid() + } + return protoreflect.FullName(s).IsValid() +} + +const unknownPrefix = "*." + +// FullName converts the partial name to a full name on a best-effort basis. +// If relative, it creates an invalid full name, using a "*." prefix +// to indicate that the start of the full name is unknown. +func (s partialName) FullName() protoreflect.FullName { + if s.IsFull() { + return protoreflect.FullName(s[1:]) + } + return protoreflect.FullName(unknownPrefix + s) +} + +func unmarshalDefault(s string, fd protoreflect.FieldDescriptor, allowUnresolvable bool) (protoreflect.Value, protoreflect.EnumValueDescriptor, error) { + var evs protoreflect.EnumValueDescriptors + if fd.Enum() != nil { + evs = fd.Enum().Values() + } + v, ev, err := defval.Unmarshal(s, fd.Kind(), evs, defval.Descriptor) + if err != nil && allowUnresolvable && evs != nil && protoreflect.Name(s).IsValid() { + v = protoreflect.ValueOfEnum(0) + if evs.Len() > 0 { + v = protoreflect.ValueOfEnum(evs.Get(0).Number()) + } + ev = filedesc.PlaceholderEnumValue(fd.Enum().FullName().Parent().Append(protoreflect.Name(s))) + } else if err != nil { + return v, ev, err + } + if !fd.HasPresence() { + return v, ev, errors.New("cannot be specified with implicit field presence") + } + if fd.Kind() == protoreflect.MessageKind || fd.Kind() == protoreflect.GroupKind || fd.Cardinality() == protoreflect.Repeated { + return v, ev, errors.New("cannot be specified on composite types") + } + return v, ev, nil +} diff --git a/services/vendor/google.golang.org/protobuf/reflect/protodesc/desc_validate.go b/services/vendor/google.golang.org/protobuf/reflect/protodesc/desc_validate.go new file mode 100644 index 00000000..e4dcaf87 --- /dev/null +++ b/services/vendor/google.golang.org/protobuf/reflect/protodesc/desc_validate.go @@ -0,0 +1,374 @@ +// Copyright 2019 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 protodesc + +import ( + "strings" + "unicode" + + "google.golang.org/protobuf/encoding/protowire" + "google.golang.org/protobuf/internal/errors" + "google.golang.org/protobuf/internal/filedesc" + "google.golang.org/protobuf/internal/flags" + "google.golang.org/protobuf/internal/genid" + "google.golang.org/protobuf/internal/strs" + "google.golang.org/protobuf/reflect/protoreflect" + + "google.golang.org/protobuf/types/descriptorpb" +) + +func validateEnumDeclarations(es []filedesc.Enum, eds []*descriptorpb.EnumDescriptorProto) error { + for i, ed := range eds { + e := &es[i] + if err := e.L2.ReservedNames.CheckValid(); err != nil { + return errors.New("enum %q reserved names has %v", e.FullName(), err) + } + if err := e.L2.ReservedRanges.CheckValid(); err != nil { + return errors.New("enum %q reserved ranges has %v", e.FullName(), err) + } + if len(ed.GetValue()) == 0 { + return errors.New("enum %q must contain at least one value declaration", e.FullName()) + } + allowAlias := ed.GetOptions().GetAllowAlias() + foundAlias := false + for i := 0; i < e.Values().Len(); i++ { + v1 := e.Values().Get(i) + if v2 := e.Values().ByNumber(v1.Number()); v1 != v2 { + foundAlias = true + if !allowAlias { + return errors.New("enum %q has conflicting non-aliased values on number %d: %q with %q", e.FullName(), v1.Number(), v1.Name(), v2.Name()) + } + } + } + if allowAlias && !foundAlias { + return errors.New("enum %q allows aliases, but none were found", e.FullName()) + } + if e.Syntax() == protoreflect.Proto3 { + if v := e.Values().Get(0); v.Number() != 0 { + return errors.New("enum %q using proto3 semantics must have zero number for the first value", v.FullName()) + } + // Verify that value names in proto3 do not conflict if the + // case-insensitive prefix is removed. + // See protoc v3.8.0: src/google/protobuf/descriptor.cc:4991-5055 + names := map[string]protoreflect.EnumValueDescriptor{} + prefix := strings.Replace(strings.ToLower(string(e.Name())), "_", "", -1) + for i := 0; i < e.Values().Len(); i++ { + v1 := e.Values().Get(i) + s := strs.EnumValueName(strs.TrimEnumPrefix(string(v1.Name()), prefix)) + if v2, ok := names[s]; ok && v1.Number() != v2.Number() { + return errors.New("enum %q using proto3 semantics has conflict: %q with %q", e.FullName(), v1.Name(), v2.Name()) + } + names[s] = v1 + } + } + + for j, vd := range ed.GetValue() { + v := &e.L2.Values.List[j] + if vd.Number == nil { + return errors.New("enum value %q must have a specified number", v.FullName()) + } + if e.L2.ReservedNames.Has(v.Name()) { + return errors.New("enum value %q must not use reserved name", v.FullName()) + } + if e.L2.ReservedRanges.Has(v.Number()) { + return errors.New("enum value %q must not use reserved number %d", v.FullName(), v.Number()) + } + } + } + return nil +} + +func validateMessageDeclarations(ms []filedesc.Message, mds []*descriptorpb.DescriptorProto) error { + for i, md := range mds { + m := &ms[i] + + // Handle the message descriptor itself. + isMessageSet := md.GetOptions().GetMessageSetWireFormat() + if err := m.L2.ReservedNames.CheckValid(); err != nil { + return errors.New("message %q reserved names has %v", m.FullName(), err) + } + if err := m.L2.ReservedRanges.CheckValid(isMessageSet); err != nil { + return errors.New("message %q reserved ranges has %v", m.FullName(), err) + } + if err := m.L2.ExtensionRanges.CheckValid(isMessageSet); err != nil { + return errors.New("message %q extension ranges has %v", m.FullName(), err) + } + if err := (*filedesc.FieldRanges).CheckOverlap(&m.L2.ReservedRanges, &m.L2.ExtensionRanges); err != nil { + return errors.New("message %q reserved and extension ranges has %v", m.FullName(), err) + } + for i := 0; i < m.Fields().Len(); i++ { + f1 := m.Fields().Get(i) + if f2 := m.Fields().ByNumber(f1.Number()); f1 != f2 { + return errors.New("message %q has conflicting fields: %q with %q", m.FullName(), f1.Name(), f2.Name()) + } + } + if isMessageSet && !flags.ProtoLegacy { + return errors.New("message %q is a MessageSet, which is a legacy proto1 feature that is no longer supported", m.FullName()) + } + if isMessageSet && (m.Syntax() == protoreflect.Proto3 || m.Fields().Len() > 0 || m.ExtensionRanges().Len() == 0) { + return errors.New("message %q is an invalid proto1 MessageSet", m.FullName()) + } + if m.Syntax() == protoreflect.Proto3 { + if m.ExtensionRanges().Len() > 0 { + return errors.New("message %q using proto3 semantics cannot have extension ranges", m.FullName()) + } + // Verify that field names in proto3 do not conflict if lowercased + // with all underscores removed. + // See protoc v3.8.0: src/google/protobuf/descriptor.cc:5830-5847 + names := map[string]protoreflect.FieldDescriptor{} + for i := 0; i < m.Fields().Len(); i++ { + f1 := m.Fields().Get(i) + s := strings.Replace(strings.ToLower(string(f1.Name())), "_", "", -1) + if f2, ok := names[s]; ok { + return errors.New("message %q using proto3 semantics has conflict: %q with %q", m.FullName(), f1.Name(), f2.Name()) + } + names[s] = f1 + } + } + + for j, fd := range md.GetField() { + f := &m.L2.Fields.List[j] + if m.L2.ReservedNames.Has(f.Name()) { + return errors.New("message field %q must not use reserved name", f.FullName()) + } + if !f.Number().IsValid() { + return errors.New("message field %q has an invalid number: %d", f.FullName(), f.Number()) + } + if !f.Cardinality().IsValid() { + return errors.New("message field %q has an invalid cardinality: %d", f.FullName(), f.Cardinality()) + } + if m.L2.ReservedRanges.Has(f.Number()) { + return errors.New("message field %q must not use reserved number %d", f.FullName(), f.Number()) + } + if m.L2.ExtensionRanges.Has(f.Number()) { + return errors.New("message field %q with number %d in extension range", f.FullName(), f.Number()) + } + if fd.Extendee != nil { + return errors.New("message field %q may not have extendee: %q", f.FullName(), fd.GetExtendee()) + } + if f.L1.IsProto3Optional { + if f.Syntax() != protoreflect.Proto3 { + return errors.New("message field %q under proto3 optional semantics must be specified in the proto3 syntax", f.FullName()) + } + if f.Cardinality() != protoreflect.Optional { + return errors.New("message field %q under proto3 optional semantics must have optional cardinality", f.FullName()) + } + if f.ContainingOneof() != nil && f.ContainingOneof().Fields().Len() != 1 { + return errors.New("message field %q under proto3 optional semantics must be within a single element oneof", f.FullName()) + } + } + if f.IsWeak() && !flags.ProtoLegacy { + return errors.New("message field %q is a weak field, which is a legacy proto1 feature that is no longer supported", f.FullName()) + } + if f.IsWeak() && (f.Syntax() != protoreflect.Proto2 || !isOptionalMessage(f) || f.ContainingOneof() != nil) { + return errors.New("message field %q may only be weak for an optional message", f.FullName()) + } + if f.IsPacked() && !isPackable(f) { + return errors.New("message field %q is not packable", f.FullName()) + } + if err := checkValidGroup(f); err != nil { + return errors.New("message field %q is an invalid group: %v", f.FullName(), err) + } + if err := checkValidMap(f); err != nil { + return errors.New("message field %q is an invalid map: %v", f.FullName(), err) + } + if f.Syntax() == protoreflect.Proto3 { + if f.Cardinality() == protoreflect.Required { + return errors.New("message field %q using proto3 semantics cannot be required", f.FullName()) + } + if f.Enum() != nil && !f.Enum().IsPlaceholder() && f.Enum().Syntax() != protoreflect.Proto3 { + return errors.New("message field %q using proto3 semantics may only depend on a proto3 enum", f.FullName()) + } + } + } + seenSynthetic := false // synthetic oneofs for proto3 optional must come after real oneofs + for j := range md.GetOneofDecl() { + o := &m.L2.Oneofs.List[j] + if o.Fields().Len() == 0 { + return errors.New("message oneof %q must contain at least one field declaration", o.FullName()) + } + if n := o.Fields().Len(); n-1 != (o.Fields().Get(n-1).Index() - o.Fields().Get(0).Index()) { + return errors.New("message oneof %q must have consecutively declared fields", o.FullName()) + } + + if o.IsSynthetic() { + seenSynthetic = true + continue + } + if !o.IsSynthetic() && seenSynthetic { + return errors.New("message oneof %q must be declared before synthetic oneofs", o.FullName()) + } + + for i := 0; i < o.Fields().Len(); i++ { + f := o.Fields().Get(i) + if f.Cardinality() != protoreflect.Optional { + return errors.New("message field %q belongs in a oneof and must be optional", f.FullName()) + } + if f.IsWeak() { + return errors.New("message field %q belongs in a oneof and must not be a weak reference", f.FullName()) + } + } + } + + if err := validateEnumDeclarations(m.L1.Enums.List, md.GetEnumType()); err != nil { + return err + } + if err := validateMessageDeclarations(m.L1.Messages.List, md.GetNestedType()); err != nil { + return err + } + if err := validateExtensionDeclarations(m.L1.Extensions.List, md.GetExtension()); err != nil { + return err + } + } + return nil +} + +func validateExtensionDeclarations(xs []filedesc.Extension, xds []*descriptorpb.FieldDescriptorProto) error { + for i, xd := range xds { + x := &xs[i] + // NOTE: Avoid using the IsValid method since extensions to MessageSet + // may have a field number higher than normal. This check only verifies + // that the number is not negative or reserved. We check again later + // if we know that the extendee is definitely not a MessageSet. + if n := x.Number(); n < 0 || (protowire.FirstReservedNumber <= n && n <= protowire.LastReservedNumber) { + return errors.New("extension field %q has an invalid number: %d", x.FullName(), x.Number()) + } + if !x.Cardinality().IsValid() || x.Cardinality() == protoreflect.Required { + return errors.New("extension field %q has an invalid cardinality: %d", x.FullName(), x.Cardinality()) + } + if xd.JsonName != nil { + // A bug in older versions of protoc would always populate the + // "json_name" option for extensions when it is meaningless. + // When it did so, it would always use the camel-cased field name. + if xd.GetJsonName() != strs.JSONCamelCase(string(x.Name())) { + return errors.New("extension field %q may not have an explicitly set JSON name: %q", x.FullName(), xd.GetJsonName()) + } + } + if xd.OneofIndex != nil { + return errors.New("extension field %q may not be part of a oneof", x.FullName()) + } + if md := x.ContainingMessage(); !md.IsPlaceholder() { + if !md.ExtensionRanges().Has(x.Number()) { + return errors.New("extension field %q extends %q with non-extension field number: %d", x.FullName(), md.FullName(), x.Number()) + } + isMessageSet := md.Options().(*descriptorpb.MessageOptions).GetMessageSetWireFormat() + if isMessageSet && !isOptionalMessage(x) { + return errors.New("extension field %q extends MessageSet and must be an optional message", x.FullName()) + } + if !isMessageSet && !x.Number().IsValid() { + return errors.New("extension field %q has an invalid number: %d", x.FullName(), x.Number()) + } + } + if xd.GetOptions().GetWeak() { + return errors.New("extension field %q cannot be a weak reference", x.FullName()) + } + if x.IsPacked() && !isPackable(x) { + return errors.New("extension field %q is not packable", x.FullName()) + } + if err := checkValidGroup(x); err != nil { + return errors.New("extension field %q is an invalid group: %v", x.FullName(), err) + } + if md := x.Message(); md != nil && md.IsMapEntry() { + return errors.New("extension field %q cannot be a map entry", x.FullName()) + } + if x.Syntax() == protoreflect.Proto3 { + switch x.ContainingMessage().FullName() { + case (*descriptorpb.FileOptions)(nil).ProtoReflect().Descriptor().FullName(): + case (*descriptorpb.EnumOptions)(nil).ProtoReflect().Descriptor().FullName(): + case (*descriptorpb.EnumValueOptions)(nil).ProtoReflect().Descriptor().FullName(): + case (*descriptorpb.MessageOptions)(nil).ProtoReflect().Descriptor().FullName(): + case (*descriptorpb.FieldOptions)(nil).ProtoReflect().Descriptor().FullName(): + case (*descriptorpb.OneofOptions)(nil).ProtoReflect().Descriptor().FullName(): + case (*descriptorpb.ExtensionRangeOptions)(nil).ProtoReflect().Descriptor().FullName(): + case (*descriptorpb.ServiceOptions)(nil).ProtoReflect().Descriptor().FullName(): + case (*descriptorpb.MethodOptions)(nil).ProtoReflect().Descriptor().FullName(): + default: + return errors.New("extension field %q cannot be declared in proto3 unless extended descriptor options", x.FullName()) + } + } + } + return nil +} + +// isOptionalMessage reports whether this is an optional message. +// If the kind is unknown, it is assumed to be a message. +func isOptionalMessage(fd protoreflect.FieldDescriptor) bool { + return (fd.Kind() == 0 || fd.Kind() == protoreflect.MessageKind) && fd.Cardinality() == protoreflect.Optional +} + +// isPackable checks whether the pack option can be specified. +func isPackable(fd protoreflect.FieldDescriptor) bool { + switch fd.Kind() { + case protoreflect.StringKind, protoreflect.BytesKind, protoreflect.MessageKind, protoreflect.GroupKind: + return false + } + return fd.IsList() +} + +// checkValidGroup reports whether fd is a valid group according to the same +// rules that protoc imposes. +func checkValidGroup(fd protoreflect.FieldDescriptor) error { + md := fd.Message() + switch { + case fd.Kind() != protoreflect.GroupKind: + return nil + case fd.Syntax() == protoreflect.Proto3: + return errors.New("invalid under proto3 semantics") + case md == nil || md.IsPlaceholder(): + return errors.New("message must be resolvable") + case fd.FullName().Parent() != md.FullName().Parent(): + return errors.New("message and field must be declared in the same scope") + case !unicode.IsUpper(rune(md.Name()[0])): + return errors.New("message name must start with an uppercase") + case fd.Name() != protoreflect.Name(strings.ToLower(string(md.Name()))): + return errors.New("field name must be lowercased form of the message name") + } + return nil +} + +// checkValidMap checks whether the field is a valid map according to the same +// rules that protoc imposes. +// See protoc v3.8.0: src/google/protobuf/descriptor.cc:6045-6115 +func checkValidMap(fd protoreflect.FieldDescriptor) error { + md := fd.Message() + switch { + case md == nil || !md.IsMapEntry(): + return nil + case fd.FullName().Parent() != md.FullName().Parent(): + return errors.New("message and field must be declared in the same scope") + case md.Name() != protoreflect.Name(strs.MapEntryName(string(fd.Name()))): + return errors.New("incorrect implicit map entry name") + case fd.Cardinality() != protoreflect.Repeated: + return errors.New("field must be repeated") + case md.Fields().Len() != 2: + return errors.New("message must have exactly two fields") + case md.ExtensionRanges().Len() > 0: + return errors.New("message must not have any extension ranges") + case md.Enums().Len()+md.Messages().Len()+md.Extensions().Len() > 0: + return errors.New("message must not have any nested declarations") + } + kf := md.Fields().Get(0) + vf := md.Fields().Get(1) + switch { + case kf.Name() != genid.MapEntry_Key_field_name || kf.Number() != genid.MapEntry_Key_field_number || kf.Cardinality() != protoreflect.Optional || kf.ContainingOneof() != nil || kf.HasDefault(): + return errors.New("invalid key field") + case vf.Name() != genid.MapEntry_Value_field_name || vf.Number() != genid.MapEntry_Value_field_number || vf.Cardinality() != protoreflect.Optional || vf.ContainingOneof() != nil || vf.HasDefault(): + return errors.New("invalid value field") + } + switch kf.Kind() { + case protoreflect.BoolKind: // bool + case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind: // int32 + case protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind: // int64 + case protoreflect.Uint32Kind, protoreflect.Fixed32Kind: // uint32 + case protoreflect.Uint64Kind, protoreflect.Fixed64Kind: // uint64 + case protoreflect.StringKind: // string + default: + return errors.New("invalid key kind: %v", kf.Kind()) + } + if e := vf.Enum(); e != nil && e.Values().Len() > 0 && e.Values().Get(0).Number() != 0 { + return errors.New("map enum value must have zero number for the first value") + } + return nil +} diff --git a/services/vendor/google.golang.org/protobuf/reflect/protodesc/editions.go b/services/vendor/google.golang.org/protobuf/reflect/protodesc/editions.go new file mode 100644 index 00000000..2a6b29d1 --- /dev/null +++ b/services/vendor/google.golang.org/protobuf/reflect/protodesc/editions.go @@ -0,0 +1,148 @@ +// Copyright 2019 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 protodesc + +import ( + "fmt" + "os" + "sync" + + "google.golang.org/protobuf/internal/editiondefaults" + "google.golang.org/protobuf/internal/filedesc" + "google.golang.org/protobuf/proto" + "google.golang.org/protobuf/reflect/protoreflect" + "google.golang.org/protobuf/types/descriptorpb" + gofeaturespb "google.golang.org/protobuf/types/gofeaturespb" +) + +const ( + SupportedEditionsMinimum = descriptorpb.Edition_EDITION_PROTO2 + SupportedEditionsMaximum = descriptorpb.Edition_EDITION_2023 +) + +var defaults = &descriptorpb.FeatureSetDefaults{} +var defaultsCacheMu sync.Mutex +var defaultsCache = make(map[filedesc.Edition]*descriptorpb.FeatureSet) + +func init() { + err := proto.Unmarshal(editiondefaults.Defaults, defaults) + if err != nil { + fmt.Fprintf(os.Stderr, "unmarshal editions defaults: %v\n", err) + os.Exit(1) + } +} + +func fromEditionProto(epb descriptorpb.Edition) filedesc.Edition { + return filedesc.Edition(epb) +} + +func toEditionProto(ed filedesc.Edition) descriptorpb.Edition { + switch ed { + case filedesc.EditionUnknown: + return descriptorpb.Edition_EDITION_UNKNOWN + case filedesc.EditionProto2: + return descriptorpb.Edition_EDITION_PROTO2 + case filedesc.EditionProto3: + return descriptorpb.Edition_EDITION_PROTO3 + case filedesc.Edition2023: + return descriptorpb.Edition_EDITION_2023 + default: + panic(fmt.Sprintf("unknown value for edition: %v", ed)) + } +} + +func getFeatureSetFor(ed filedesc.Edition) *descriptorpb.FeatureSet { + defaultsCacheMu.Lock() + defer defaultsCacheMu.Unlock() + if def, ok := defaultsCache[ed]; ok { + return def + } + edpb := toEditionProto(ed) + if defaults.GetMinimumEdition() > edpb || defaults.GetMaximumEdition() < edpb { + // This should never happen protodesc.(FileOptions).New would fail when + // initializing the file descriptor. + // This most likely means the embedded defaults were not updated. + fmt.Fprintf(os.Stderr, "internal error: unsupported edition %v (did you forget to update the embedded defaults (i.e. the bootstrap descriptor proto)?)\n", edpb) + os.Exit(1) + } + fs := defaults.GetDefaults()[0].GetFeatures() + // Using a linear search for now. + // Editions are guaranteed to be sorted and thus we could use a binary search. + // Given that there are only a handful of editions (with one more per year) + // there is not much reason to use a binary search. + for _, def := range defaults.GetDefaults() { + if def.GetEdition() <= edpb { + fs = def.GetFeatures() + } else { + break + } + } + defaultsCache[ed] = fs + return fs +} + +// mergeEditionFeatures merges the parent and child feature sets. This function +// should be used when initializing Go descriptors from descriptor protos which +// is why the parent is a filedesc.EditionsFeatures (Go representation) while +// the child is a descriptorproto.FeatureSet (protoc representation). +// Any feature set by the child overwrites what is set by the parent. +func mergeEditionFeatures(parentDesc protoreflect.Descriptor, child *descriptorpb.FeatureSet) filedesc.EditionFeatures { + var parentFS filedesc.EditionFeatures + switch p := parentDesc.(type) { + case *filedesc.File: + parentFS = p.L1.EditionFeatures + case *filedesc.Message: + parentFS = p.L1.EditionFeatures + default: + panic(fmt.Sprintf("unknown parent type %T", parentDesc)) + } + if child == nil { + return parentFS + } + if fp := child.FieldPresence; fp != nil { + parentFS.IsFieldPresence = *fp == descriptorpb.FeatureSet_LEGACY_REQUIRED || + *fp == descriptorpb.FeatureSet_EXPLICIT + parentFS.IsLegacyRequired = *fp == descriptorpb.FeatureSet_LEGACY_REQUIRED + } + if et := child.EnumType; et != nil { + parentFS.IsOpenEnum = *et == descriptorpb.FeatureSet_OPEN + } + + if rfe := child.RepeatedFieldEncoding; rfe != nil { + parentFS.IsPacked = *rfe == descriptorpb.FeatureSet_PACKED + } + + if utf8val := child.Utf8Validation; utf8val != nil { + parentFS.IsUTF8Validated = *utf8val == descriptorpb.FeatureSet_VERIFY + } + + if me := child.MessageEncoding; me != nil { + parentFS.IsDelimitedEncoded = *me == descriptorpb.FeatureSet_DELIMITED + } + + if jf := child.JsonFormat; jf != nil { + parentFS.IsJSONCompliant = *jf == descriptorpb.FeatureSet_ALLOW + } + + if goFeatures, ok := proto.GetExtension(child, gofeaturespb.E_Go).(*gofeaturespb.GoFeatures); ok && goFeatures != nil { + if luje := goFeatures.LegacyUnmarshalJsonEnum; luje != nil { + parentFS.GenerateLegacyUnmarshalJSON = *luje + } + } + + return parentFS +} + +// initFileDescFromFeatureSet initializes editions related fields in fd based +// on fs. If fs is nil it is assumed to be an empty featureset and all fields +// will be initialized with the appropriate default. fd.L1.Edition must be set +// before calling this function. +func initFileDescFromFeatureSet(fd *filedesc.File, fs *descriptorpb.FeatureSet) { + dfs := getFeatureSetFor(fd.L1.Edition) + // initialize the featureset with the defaults + fd.L1.EditionFeatures = mergeEditionFeatures(fd, dfs) + // overwrite any options explicitly specified + fd.L1.EditionFeatures = mergeEditionFeatures(fd, fs) +} diff --git a/services/vendor/google.golang.org/protobuf/reflect/protodesc/proto.go b/services/vendor/google.golang.org/protobuf/reflect/protodesc/proto.go new file mode 100644 index 00000000..9d6e0542 --- /dev/null +++ b/services/vendor/google.golang.org/protobuf/reflect/protodesc/proto.go @@ -0,0 +1,252 @@ +// Copyright 2019 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 protodesc + +import ( + "fmt" + "strings" + + "google.golang.org/protobuf/internal/encoding/defval" + "google.golang.org/protobuf/internal/strs" + "google.golang.org/protobuf/proto" + "google.golang.org/protobuf/reflect/protoreflect" + + "google.golang.org/protobuf/types/descriptorpb" +) + +// ToFileDescriptorProto copies a [protoreflect.FileDescriptor] into a +// google.protobuf.FileDescriptorProto message. +func ToFileDescriptorProto(file protoreflect.FileDescriptor) *descriptorpb.FileDescriptorProto { + p := &descriptorpb.FileDescriptorProto{ + Name: proto.String(file.Path()), + Options: proto.Clone(file.Options()).(*descriptorpb.FileOptions), + } + if file.Package() != "" { + p.Package = proto.String(string(file.Package())) + } + for i, imports := 0, file.Imports(); i < imports.Len(); i++ { + imp := imports.Get(i) + p.Dependency = append(p.Dependency, imp.Path()) + if imp.IsPublic { + p.PublicDependency = append(p.PublicDependency, int32(i)) + } + if imp.IsWeak { + p.WeakDependency = append(p.WeakDependency, int32(i)) + } + } + for i, locs := 0, file.SourceLocations(); i < locs.Len(); i++ { + loc := locs.Get(i) + l := &descriptorpb.SourceCodeInfo_Location{} + l.Path = append(l.Path, loc.Path...) + if loc.StartLine == loc.EndLine { + l.Span = []int32{int32(loc.StartLine), int32(loc.StartColumn), int32(loc.EndColumn)} + } else { + l.Span = []int32{int32(loc.StartLine), int32(loc.StartColumn), int32(loc.EndLine), int32(loc.EndColumn)} + } + l.LeadingDetachedComments = append([]string(nil), loc.LeadingDetachedComments...) + if loc.LeadingComments != "" { + l.LeadingComments = proto.String(loc.LeadingComments) + } + if loc.TrailingComments != "" { + l.TrailingComments = proto.String(loc.TrailingComments) + } + if p.SourceCodeInfo == nil { + p.SourceCodeInfo = &descriptorpb.SourceCodeInfo{} + } + p.SourceCodeInfo.Location = append(p.SourceCodeInfo.Location, l) + + } + for i, messages := 0, file.Messages(); i < messages.Len(); i++ { + p.MessageType = append(p.MessageType, ToDescriptorProto(messages.Get(i))) + } + for i, enums := 0, file.Enums(); i < enums.Len(); i++ { + p.EnumType = append(p.EnumType, ToEnumDescriptorProto(enums.Get(i))) + } + for i, services := 0, file.Services(); i < services.Len(); i++ { + p.Service = append(p.Service, ToServiceDescriptorProto(services.Get(i))) + } + for i, exts := 0, file.Extensions(); i < exts.Len(); i++ { + p.Extension = append(p.Extension, ToFieldDescriptorProto(exts.Get(i))) + } + if syntax := file.Syntax(); syntax != protoreflect.Proto2 && syntax.IsValid() { + p.Syntax = proto.String(file.Syntax().String()) + } + return p +} + +// ToDescriptorProto copies a [protoreflect.MessageDescriptor] into a +// google.protobuf.DescriptorProto message. +func ToDescriptorProto(message protoreflect.MessageDescriptor) *descriptorpb.DescriptorProto { + p := &descriptorpb.DescriptorProto{ + Name: proto.String(string(message.Name())), + Options: proto.Clone(message.Options()).(*descriptorpb.MessageOptions), + } + for i, fields := 0, message.Fields(); i < fields.Len(); i++ { + p.Field = append(p.Field, ToFieldDescriptorProto(fields.Get(i))) + } + for i, exts := 0, message.Extensions(); i < exts.Len(); i++ { + p.Extension = append(p.Extension, ToFieldDescriptorProto(exts.Get(i))) + } + for i, messages := 0, message.Messages(); i < messages.Len(); i++ { + p.NestedType = append(p.NestedType, ToDescriptorProto(messages.Get(i))) + } + for i, enums := 0, message.Enums(); i < enums.Len(); i++ { + p.EnumType = append(p.EnumType, ToEnumDescriptorProto(enums.Get(i))) + } + for i, xranges := 0, message.ExtensionRanges(); i < xranges.Len(); i++ { + xrange := xranges.Get(i) + p.ExtensionRange = append(p.ExtensionRange, &descriptorpb.DescriptorProto_ExtensionRange{ + Start: proto.Int32(int32(xrange[0])), + End: proto.Int32(int32(xrange[1])), + Options: proto.Clone(message.ExtensionRangeOptions(i)).(*descriptorpb.ExtensionRangeOptions), + }) + } + for i, oneofs := 0, message.Oneofs(); i < oneofs.Len(); i++ { + p.OneofDecl = append(p.OneofDecl, ToOneofDescriptorProto(oneofs.Get(i))) + } + for i, ranges := 0, message.ReservedRanges(); i < ranges.Len(); i++ { + rrange := ranges.Get(i) + p.ReservedRange = append(p.ReservedRange, &descriptorpb.DescriptorProto_ReservedRange{ + Start: proto.Int32(int32(rrange[0])), + End: proto.Int32(int32(rrange[1])), + }) + } + for i, names := 0, message.ReservedNames(); i < names.Len(); i++ { + p.ReservedName = append(p.ReservedName, string(names.Get(i))) + } + return p +} + +// ToFieldDescriptorProto copies a [protoreflect.FieldDescriptor] into a +// google.protobuf.FieldDescriptorProto message. +func ToFieldDescriptorProto(field protoreflect.FieldDescriptor) *descriptorpb.FieldDescriptorProto { + p := &descriptorpb.FieldDescriptorProto{ + Name: proto.String(string(field.Name())), + Number: proto.Int32(int32(field.Number())), + Label: descriptorpb.FieldDescriptorProto_Label(field.Cardinality()).Enum(), + Options: proto.Clone(field.Options()).(*descriptorpb.FieldOptions), + } + if field.IsExtension() { + p.Extendee = fullNameOf(field.ContainingMessage()) + } + if field.Kind().IsValid() { + p.Type = descriptorpb.FieldDescriptorProto_Type(field.Kind()).Enum() + } + if field.Enum() != nil { + p.TypeName = fullNameOf(field.Enum()) + } + if field.Message() != nil { + p.TypeName = fullNameOf(field.Message()) + } + if field.HasJSONName() { + // A bug in older versions of protoc would always populate the + // "json_name" option for extensions when it is meaningless. + // When it did so, it would always use the camel-cased field name. + if field.IsExtension() { + p.JsonName = proto.String(strs.JSONCamelCase(string(field.Name()))) + } else { + p.JsonName = proto.String(field.JSONName()) + } + } + if field.Syntax() == protoreflect.Proto3 && field.HasOptionalKeyword() { + p.Proto3Optional = proto.Bool(true) + } + if field.HasDefault() { + def, err := defval.Marshal(field.Default(), field.DefaultEnumValue(), field.Kind(), defval.Descriptor) + if err != nil && field.DefaultEnumValue() != nil { + def = string(field.DefaultEnumValue().Name()) // occurs for unresolved enum values + } else if err != nil { + panic(fmt.Sprintf("%v: %v", field.FullName(), err)) + } + p.DefaultValue = proto.String(def) + } + if oneof := field.ContainingOneof(); oneof != nil { + p.OneofIndex = proto.Int32(int32(oneof.Index())) + } + return p +} + +// ToOneofDescriptorProto copies a [protoreflect.OneofDescriptor] into a +// google.protobuf.OneofDescriptorProto message. +func ToOneofDescriptorProto(oneof protoreflect.OneofDescriptor) *descriptorpb.OneofDescriptorProto { + return &descriptorpb.OneofDescriptorProto{ + Name: proto.String(string(oneof.Name())), + Options: proto.Clone(oneof.Options()).(*descriptorpb.OneofOptions), + } +} + +// ToEnumDescriptorProto copies a [protoreflect.EnumDescriptor] into a +// google.protobuf.EnumDescriptorProto message. +func ToEnumDescriptorProto(enum protoreflect.EnumDescriptor) *descriptorpb.EnumDescriptorProto { + p := &descriptorpb.EnumDescriptorProto{ + Name: proto.String(string(enum.Name())), + Options: proto.Clone(enum.Options()).(*descriptorpb.EnumOptions), + } + for i, values := 0, enum.Values(); i < values.Len(); i++ { + p.Value = append(p.Value, ToEnumValueDescriptorProto(values.Get(i))) + } + for i, ranges := 0, enum.ReservedRanges(); i < ranges.Len(); i++ { + rrange := ranges.Get(i) + p.ReservedRange = append(p.ReservedRange, &descriptorpb.EnumDescriptorProto_EnumReservedRange{ + Start: proto.Int32(int32(rrange[0])), + End: proto.Int32(int32(rrange[1])), + }) + } + for i, names := 0, enum.ReservedNames(); i < names.Len(); i++ { + p.ReservedName = append(p.ReservedName, string(names.Get(i))) + } + return p +} + +// ToEnumValueDescriptorProto copies a [protoreflect.EnumValueDescriptor] into a +// google.protobuf.EnumValueDescriptorProto message. +func ToEnumValueDescriptorProto(value protoreflect.EnumValueDescriptor) *descriptorpb.EnumValueDescriptorProto { + return &descriptorpb.EnumValueDescriptorProto{ + Name: proto.String(string(value.Name())), + Number: proto.Int32(int32(value.Number())), + Options: proto.Clone(value.Options()).(*descriptorpb.EnumValueOptions), + } +} + +// ToServiceDescriptorProto copies a [protoreflect.ServiceDescriptor] into a +// google.protobuf.ServiceDescriptorProto message. +func ToServiceDescriptorProto(service protoreflect.ServiceDescriptor) *descriptorpb.ServiceDescriptorProto { + p := &descriptorpb.ServiceDescriptorProto{ + Name: proto.String(string(service.Name())), + Options: proto.Clone(service.Options()).(*descriptorpb.ServiceOptions), + } + for i, methods := 0, service.Methods(); i < methods.Len(); i++ { + p.Method = append(p.Method, ToMethodDescriptorProto(methods.Get(i))) + } + return p +} + +// ToMethodDescriptorProto copies a [protoreflect.MethodDescriptor] into a +// google.protobuf.MethodDescriptorProto message. +func ToMethodDescriptorProto(method protoreflect.MethodDescriptor) *descriptorpb.MethodDescriptorProto { + p := &descriptorpb.MethodDescriptorProto{ + Name: proto.String(string(method.Name())), + InputType: fullNameOf(method.Input()), + OutputType: fullNameOf(method.Output()), + Options: proto.Clone(method.Options()).(*descriptorpb.MethodOptions), + } + if method.IsStreamingClient() { + p.ClientStreaming = proto.Bool(true) + } + if method.IsStreamingServer() { + p.ServerStreaming = proto.Bool(true) + } + return p +} + +func fullNameOf(d protoreflect.Descriptor) *string { + if d == nil { + return nil + } + if strings.HasPrefix(string(d.FullName()), unknownPrefix) { + return proto.String(string(d.FullName()[len(unknownPrefix):])) + } + return proto.String("." + string(d.FullName())) +} diff --git a/services/vendor/google.golang.org/protobuf/reflect/protoreflect/proto.go b/services/vendor/google.golang.org/protobuf/reflect/protoreflect/proto.go index c85bfaa5..00b01fbd 100644 --- a/services/vendor/google.golang.org/protobuf/reflect/protoreflect/proto.go +++ b/services/vendor/google.golang.org/protobuf/reflect/protoreflect/proto.go @@ -161,7 +161,7 @@ const ( // IsValid reports whether the syntax is valid. func (s Syntax) IsValid() bool { switch s { - case Proto2, Proto3, Editions: + case Proto2, Proto3: return true default: return false diff --git a/services/vendor/google.golang.org/protobuf/reflect/protoreflect/source_gen.go b/services/vendor/google.golang.org/protobuf/reflect/protoreflect/source_gen.go index ea154eec..7dcc2ff0 100644 --- a/services/vendor/google.golang.org/protobuf/reflect/protoreflect/source_gen.go +++ b/services/vendor/google.golang.org/protobuf/reflect/protoreflect/source_gen.go @@ -373,8 +373,6 @@ func (p *SourcePath) appendFieldOptions(b []byte) []byte { b = p.appendRepeatedField(b, "edition_defaults", (*SourcePath).appendFieldOptions_EditionDefault) case 21: b = p.appendSingularField(b, "features", (*SourcePath).appendFeatureSet) - case 22: - b = p.appendSingularField(b, "feature_support", (*SourcePath).appendFieldOptions_FeatureSupport) case 999: b = p.appendRepeatedField(b, "uninterpreted_option", (*SourcePath).appendUninterpretedOption) } @@ -485,8 +483,6 @@ func (p *SourcePath) appendEnumValueOptions(b []byte) []byte { b = p.appendSingularField(b, "features", (*SourcePath).appendFeatureSet) case 3: b = p.appendSingularField(b, "debug_redact", nil) - case 4: - b = p.appendSingularField(b, "feature_support", (*SourcePath).appendFieldOptions_FeatureSupport) case 999: b = p.appendRepeatedField(b, "uninterpreted_option", (*SourcePath).appendUninterpretedOption) } @@ -523,23 +519,6 @@ func (p *SourcePath) appendFieldOptions_EditionDefault(b []byte) []byte { return b } -func (p *SourcePath) appendFieldOptions_FeatureSupport(b []byte) []byte { - if len(*p) == 0 { - return b - } - switch (*p)[0] { - case 1: - b = p.appendSingularField(b, "edition_introduced", nil) - case 2: - b = p.appendSingularField(b, "edition_deprecated", nil) - case 3: - b = p.appendSingularField(b, "deprecation_warning", nil) - case 4: - b = p.appendSingularField(b, "edition_removed", nil) - } - return b -} - func (p *SourcePath) appendUninterpretedOption_NamePart(b []byte) []byte { if len(*p) == 0 { return b diff --git a/services/vendor/google.golang.org/protobuf/reflect/protoreflect/type.go b/services/vendor/google.golang.org/protobuf/reflect/protoreflect/type.go index cd8fadba..60ff62b4 100644 --- a/services/vendor/google.golang.org/protobuf/reflect/protoreflect/type.go +++ b/services/vendor/google.golang.org/protobuf/reflect/protoreflect/type.go @@ -510,7 +510,7 @@ type ExtensionType interface { // // ValueOf is more extensive than protoreflect.ValueOf for a given field's // value as it has more type information available. - ValueOf(any) Value + ValueOf(interface{}) Value // InterfaceOf completely unwraps the Value to the underlying Go type. // InterfaceOf panics if the input is nil or does not represent the @@ -519,13 +519,13 @@ type ExtensionType interface { // // InterfaceOf is able to unwrap the Value further than Value.Interface // as it has more type information available. - InterfaceOf(Value) any + InterfaceOf(Value) interface{} // IsValidValue reports whether the Value is valid to assign to the field. IsValidValue(Value) bool // IsValidInterface reports whether the input is valid to assign to the field. - IsValidInterface(any) bool + IsValidInterface(interface{}) bool } // EnumDescriptor describes an enum and @@ -544,12 +544,6 @@ type EnumDescriptor interface { // ReservedRanges is a list of reserved ranges of enum numbers. ReservedRanges() EnumRanges - // IsClosed reports whether this enum uses closed semantics. - // See https://protobuf.dev/programming-guides/enum/#definitions. - // Note: the Go protobuf implementation is not spec compliant and treats - // all enums as open enums. - IsClosed() bool - isEnumDescriptor } type isEnumDescriptor interface{ ProtoType(EnumDescriptor) } diff --git a/services/vendor/google.golang.org/protobuf/reflect/protoreflect/value_pure.go b/services/vendor/google.golang.org/protobuf/reflect/protoreflect/value_pure.go index 75f83a2a..7ced876f 100644 --- a/services/vendor/google.golang.org/protobuf/reflect/protoreflect/value_pure.go +++ b/services/vendor/google.golang.org/protobuf/reflect/protoreflect/value_pure.go @@ -32,11 +32,11 @@ const ( type value struct { pragma.DoNotCompare // 0B - typ valueType // 8B - num uint64 // 8B - str string // 16B - bin []byte // 24B - iface any // 16B + typ valueType // 8B + num uint64 // 8B + str string // 16B + bin []byte // 24B + iface interface{} // 16B } func valueOfString(v string) Value { @@ -45,7 +45,7 @@ func valueOfString(v string) Value { func valueOfBytes(v []byte) Value { return Value{typ: bytesType, bin: v} } -func valueOfIface(v any) Value { +func valueOfIface(v interface{}) Value { return Value{typ: ifaceType, iface: v} } @@ -55,6 +55,6 @@ func (v Value) getString() string { func (v Value) getBytes() []byte { return v.bin } -func (v Value) getIface() any { +func (v Value) getIface() interface{} { return v.iface } diff --git a/services/vendor/google.golang.org/protobuf/reflect/protoreflect/value_union.go b/services/vendor/google.golang.org/protobuf/reflect/protoreflect/value_union.go index 9fe83cef..16030973 100644 --- a/services/vendor/google.golang.org/protobuf/reflect/protoreflect/value_union.go +++ b/services/vendor/google.golang.org/protobuf/reflect/protoreflect/value_union.go @@ -69,8 +69,8 @@ import ( // composite Value. Modifying an empty, read-only value panics. type Value value -// The protoreflect API uses a custom Value union type instead of any -// to keep the future open for performance optimizations. Using an any +// The protoreflect API uses a custom Value union type instead of interface{} +// to keep the future open for performance optimizations. Using an interface{} // always incurs an allocation for primitives (e.g., int64) since it needs to // be boxed on the heap (as interfaces can only contain pointers natively). // Instead, we represent the Value union as a flat struct that internally keeps @@ -85,7 +85,7 @@ type Value value // ValueOf returns a Value initialized with the concrete value stored in v. // This panics if the type does not match one of the allowed types in the // Value union. -func ValueOf(v any) Value { +func ValueOf(v interface{}) Value { switch v := v.(type) { case nil: return Value{} @@ -192,10 +192,10 @@ func (v Value) IsValid() bool { return v.typ != nilType } -// Interface returns v as an any. +// Interface returns v as an interface{}. // // Invariant: v == ValueOf(v).Interface() -func (v Value) Interface() any { +func (v Value) Interface() interface{} { switch v.typ { case nilType: return nil @@ -406,8 +406,8 @@ func (k MapKey) IsValid() bool { return Value(k).IsValid() } -// Interface returns k as an any. -func (k MapKey) Interface() any { +// Interface returns k as an interface{}. +func (k MapKey) Interface() interface{} { return Value(k).Interface() } diff --git a/services/vendor/google.golang.org/protobuf/reflect/protoreflect/value_unsafe_go120.go b/services/vendor/google.golang.org/protobuf/reflect/protoreflect/value_unsafe_go120.go index 7f3583ea..b1fdbe3e 100644 --- a/services/vendor/google.golang.org/protobuf/reflect/protoreflect/value_unsafe_go120.go +++ b/services/vendor/google.golang.org/protobuf/reflect/protoreflect/value_unsafe_go120.go @@ -45,7 +45,7 @@ var ( // typeOf returns a pointer to the Go type information. // The pointer is comparable and equal if and only if the types are identical. -func typeOf(t any) unsafe.Pointer { +func typeOf(t interface{}) unsafe.Pointer { return (*ifaceHeader)(unsafe.Pointer(&t)).Type } @@ -80,7 +80,7 @@ func valueOfBytes(v []byte) Value { p := (*sliceHeader)(unsafe.Pointer(&v)) return Value{typ: bytesType, ptr: p.Data, num: uint64(len(v))} } -func valueOfIface(v any) Value { +func valueOfIface(v interface{}) Value { p := (*ifaceHeader)(unsafe.Pointer(&v)) return Value{typ: p.Type, ptr: p.Data} } @@ -93,7 +93,7 @@ func (v Value) getBytes() (x []byte) { *(*sliceHeader)(unsafe.Pointer(&x)) = sliceHeader{Data: v.ptr, Len: int(v.num), Cap: int(v.num)} return x } -func (v Value) getIface() (x any) { +func (v Value) getIface() (x interface{}) { *(*ifaceHeader)(unsafe.Pointer(&x)) = ifaceHeader{Type: v.typ, Data: v.ptr} return x } diff --git a/services/vendor/google.golang.org/protobuf/reflect/protoreflect/value_unsafe_go121.go b/services/vendor/google.golang.org/protobuf/reflect/protoreflect/value_unsafe_go121.go index f7d38699..43547011 100644 --- a/services/vendor/google.golang.org/protobuf/reflect/protoreflect/value_unsafe_go121.go +++ b/services/vendor/google.golang.org/protobuf/reflect/protoreflect/value_unsafe_go121.go @@ -15,7 +15,7 @@ import ( type ( ifaceHeader struct { - _ [0]any // if interfaces have greater alignment than unsafe.Pointer, this will enforce it. + _ [0]interface{} // if interfaces have greater alignment than unsafe.Pointer, this will enforce it. Type unsafe.Pointer Data unsafe.Pointer } @@ -37,7 +37,7 @@ var ( // typeOf returns a pointer to the Go type information. // The pointer is comparable and equal if and only if the types are identical. -func typeOf(t any) unsafe.Pointer { +func typeOf(t interface{}) unsafe.Pointer { return (*ifaceHeader)(unsafe.Pointer(&t)).Type } @@ -70,7 +70,7 @@ func valueOfString(v string) Value { func valueOfBytes(v []byte) Value { return Value{typ: bytesType, ptr: unsafe.Pointer(unsafe.SliceData(v)), num: uint64(len(v))} } -func valueOfIface(v any) Value { +func valueOfIface(v interface{}) Value { p := (*ifaceHeader)(unsafe.Pointer(&v)) return Value{typ: p.Type, ptr: p.Data} } @@ -81,7 +81,7 @@ func (v Value) getString() string { func (v Value) getBytes() []byte { return unsafe.Slice((*byte)(v.ptr), v.num) } -func (v Value) getIface() (x any) { +func (v Value) getIface() (x interface{}) { *(*ifaceHeader)(unsafe.Pointer(&x)) = ifaceHeader{Type: v.typ, Data: v.ptr} return x } diff --git a/services/vendor/google.golang.org/protobuf/reflect/protoregistry/registry.go b/services/vendor/google.golang.org/protobuf/reflect/protoregistry/registry.go index de177733..6267dc52 100644 --- a/services/vendor/google.golang.org/protobuf/reflect/protoregistry/registry.go +++ b/services/vendor/google.golang.org/protobuf/reflect/protoregistry/registry.go @@ -95,7 +95,7 @@ type Files struct { // multiple files. Only top-level declarations are registered. // Note that enum values are in the top-level since that are in the same // scope as the parent enum. - descsByName map[protoreflect.FullName]any + descsByName map[protoreflect.FullName]interface{} filesByPath map[string][]protoreflect.FileDescriptor numFiles int } @@ -117,7 +117,7 @@ func (r *Files) RegisterFile(file protoreflect.FileDescriptor) error { defer globalMutex.Unlock() } if r.descsByName == nil { - r.descsByName = map[protoreflect.FullName]any{ + r.descsByName = map[protoreflect.FullName]interface{}{ "": &packageDescriptor{}, } r.filesByPath = make(map[string][]protoreflect.FileDescriptor) @@ -485,7 +485,7 @@ type Types struct { } type ( - typesByName map[protoreflect.FullName]any + typesByName map[protoreflect.FullName]interface{} extensionsByMessage map[protoreflect.FullName]extensionsByNumber extensionsByNumber map[protoreflect.FieldNumber]protoreflect.ExtensionType ) @@ -570,7 +570,7 @@ func (r *Types) RegisterExtension(xt protoreflect.ExtensionType) error { return nil } -func (r *Types) register(kind string, desc protoreflect.Descriptor, typ any) error { +func (r *Types) register(kind string, desc protoreflect.Descriptor, typ interface{}) error { name := desc.FullName() prev := r.typesByName[name] if prev != nil { @@ -841,7 +841,7 @@ func (r *Types) RangeExtensionsByMessage(message protoreflect.FullName, f func(p } } -func typeName(t any) string { +func typeName(t interface{}) string { switch t.(type) { case protoreflect.EnumType: return "enum" @@ -854,7 +854,7 @@ func typeName(t any) string { } } -func amendErrorWithCaller(err error, prev, curr any) error { +func amendErrorWithCaller(err error, prev, curr interface{}) error { prevPkg := goPackage(prev) currPkg := goPackage(curr) if prevPkg == "" || currPkg == "" || prevPkg == currPkg { @@ -863,7 +863,7 @@ func amendErrorWithCaller(err error, prev, curr any) error { return errors.New("%s\n\tpreviously from: %q\n\tcurrently from: %q", err, prevPkg, currPkg) } -func goPackage(v any) string { +func goPackage(v interface{}) string { switch d := v.(type) { case protoreflect.EnumType: v = d.Descriptor() diff --git a/services/vendor/google.golang.org/protobuf/types/descriptorpb/descriptor.pb.go b/services/vendor/google.golang.org/protobuf/types/descriptorpb/descriptor.pb.go new file mode 100644 index 00000000..78624cf6 --- /dev/null +++ b/services/vendor/google.golang.org/protobuf/types/descriptorpb/descriptor.pb.go @@ -0,0 +1,5648 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Author: kenton@google.com (Kenton Varda) +// Based on original Protocol Buffers design by +// Sanjay Ghemawat, Jeff Dean, and others. +// +// The messages in this file describe the definitions found in .proto files. +// A valid .proto file can be translated directly to a FileDescriptorProto +// without any other information (e.g. without reading its imports). + +// Code generated by protoc-gen-go. DO NOT EDIT. +// source: google/protobuf/descriptor.proto + +package descriptorpb + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +// The full set of known editions. +type Edition int32 + +const ( + // A placeholder for an unknown edition value. + Edition_EDITION_UNKNOWN Edition = 0 + // Legacy syntax "editions". These pre-date editions, but behave much like + // distinct editions. These can't be used to specify the edition of proto + // files, but feature definitions must supply proto2/proto3 defaults for + // backwards compatibility. + Edition_EDITION_PROTO2 Edition = 998 + Edition_EDITION_PROTO3 Edition = 999 + // Editions that have been released. The specific values are arbitrary and + // should not be depended on, but they will always be time-ordered for easy + // comparison. + Edition_EDITION_2023 Edition = 1000 + Edition_EDITION_2024 Edition = 1001 + // Placeholder editions for testing feature resolution. These should not be + // used or relyed on outside of tests. + Edition_EDITION_1_TEST_ONLY Edition = 1 + Edition_EDITION_2_TEST_ONLY Edition = 2 + Edition_EDITION_99997_TEST_ONLY Edition = 99997 + Edition_EDITION_99998_TEST_ONLY Edition = 99998 + Edition_EDITION_99999_TEST_ONLY Edition = 99999 + // Placeholder for specifying unbounded edition support. This should only + // ever be used by plugins that can expect to never require any changes to + // support a new edition. + Edition_EDITION_MAX Edition = 2147483647 +) + +// Enum value maps for Edition. +var ( + Edition_name = map[int32]string{ + 0: "EDITION_UNKNOWN", + 998: "EDITION_PROTO2", + 999: "EDITION_PROTO3", + 1000: "EDITION_2023", + 1001: "EDITION_2024", + 1: "EDITION_1_TEST_ONLY", + 2: "EDITION_2_TEST_ONLY", + 99997: "EDITION_99997_TEST_ONLY", + 99998: "EDITION_99998_TEST_ONLY", + 99999: "EDITION_99999_TEST_ONLY", + 2147483647: "EDITION_MAX", + } + Edition_value = map[string]int32{ + "EDITION_UNKNOWN": 0, + "EDITION_PROTO2": 998, + "EDITION_PROTO3": 999, + "EDITION_2023": 1000, + "EDITION_2024": 1001, + "EDITION_1_TEST_ONLY": 1, + "EDITION_2_TEST_ONLY": 2, + "EDITION_99997_TEST_ONLY": 99997, + "EDITION_99998_TEST_ONLY": 99998, + "EDITION_99999_TEST_ONLY": 99999, + "EDITION_MAX": 2147483647, + } +) + +func (x Edition) Enum() *Edition { + p := new(Edition) + *p = x + return p +} + +func (x Edition) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (Edition) Descriptor() protoreflect.EnumDescriptor { + return file_google_protobuf_descriptor_proto_enumTypes[0].Descriptor() +} + +func (Edition) Type() protoreflect.EnumType { + return &file_google_protobuf_descriptor_proto_enumTypes[0] +} + +func (x Edition) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Do not use. +func (x *Edition) UnmarshalJSON(b []byte) error { + num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b) + if err != nil { + return err + } + *x = Edition(num) + return nil +} + +// Deprecated: Use Edition.Descriptor instead. +func (Edition) EnumDescriptor() ([]byte, []int) { + return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{0} +} + +// The verification state of the extension range. +type ExtensionRangeOptions_VerificationState int32 + +const ( + // All the extensions of the range must be declared. + ExtensionRangeOptions_DECLARATION ExtensionRangeOptions_VerificationState = 0 + ExtensionRangeOptions_UNVERIFIED ExtensionRangeOptions_VerificationState = 1 +) + +// Enum value maps for ExtensionRangeOptions_VerificationState. +var ( + ExtensionRangeOptions_VerificationState_name = map[int32]string{ + 0: "DECLARATION", + 1: "UNVERIFIED", + } + ExtensionRangeOptions_VerificationState_value = map[string]int32{ + "DECLARATION": 0, + "UNVERIFIED": 1, + } +) + +func (x ExtensionRangeOptions_VerificationState) Enum() *ExtensionRangeOptions_VerificationState { + p := new(ExtensionRangeOptions_VerificationState) + *p = x + return p +} + +func (x ExtensionRangeOptions_VerificationState) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (ExtensionRangeOptions_VerificationState) Descriptor() protoreflect.EnumDescriptor { + return file_google_protobuf_descriptor_proto_enumTypes[1].Descriptor() +} + +func (ExtensionRangeOptions_VerificationState) Type() protoreflect.EnumType { + return &file_google_protobuf_descriptor_proto_enumTypes[1] +} + +func (x ExtensionRangeOptions_VerificationState) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Do not use. +func (x *ExtensionRangeOptions_VerificationState) UnmarshalJSON(b []byte) error { + num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b) + if err != nil { + return err + } + *x = ExtensionRangeOptions_VerificationState(num) + return nil +} + +// Deprecated: Use ExtensionRangeOptions_VerificationState.Descriptor instead. +func (ExtensionRangeOptions_VerificationState) EnumDescriptor() ([]byte, []int) { + return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{3, 0} +} + +type FieldDescriptorProto_Type int32 + +const ( + // 0 is reserved for errors. + // Order is weird for historical reasons. + FieldDescriptorProto_TYPE_DOUBLE FieldDescriptorProto_Type = 1 + FieldDescriptorProto_TYPE_FLOAT FieldDescriptorProto_Type = 2 + // Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT64 if + // negative values are likely. + FieldDescriptorProto_TYPE_INT64 FieldDescriptorProto_Type = 3 + FieldDescriptorProto_TYPE_UINT64 FieldDescriptorProto_Type = 4 + // Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT32 if + // negative values are likely. + FieldDescriptorProto_TYPE_INT32 FieldDescriptorProto_Type = 5 + FieldDescriptorProto_TYPE_FIXED64 FieldDescriptorProto_Type = 6 + FieldDescriptorProto_TYPE_FIXED32 FieldDescriptorProto_Type = 7 + FieldDescriptorProto_TYPE_BOOL FieldDescriptorProto_Type = 8 + FieldDescriptorProto_TYPE_STRING FieldDescriptorProto_Type = 9 + // Tag-delimited aggregate. + // Group type is deprecated and not supported after google.protobuf. However, Proto3 + // implementations should still be able to parse the group wire format and + // treat group fields as unknown fields. In Editions, the group wire format + // can be enabled via the `message_encoding` feature. + FieldDescriptorProto_TYPE_GROUP FieldDescriptorProto_Type = 10 + FieldDescriptorProto_TYPE_MESSAGE FieldDescriptorProto_Type = 11 // Length-delimited aggregate. + // New in version 2. + FieldDescriptorProto_TYPE_BYTES FieldDescriptorProto_Type = 12 + FieldDescriptorProto_TYPE_UINT32 FieldDescriptorProto_Type = 13 + FieldDescriptorProto_TYPE_ENUM FieldDescriptorProto_Type = 14 + FieldDescriptorProto_TYPE_SFIXED32 FieldDescriptorProto_Type = 15 + FieldDescriptorProto_TYPE_SFIXED64 FieldDescriptorProto_Type = 16 + FieldDescriptorProto_TYPE_SINT32 FieldDescriptorProto_Type = 17 // Uses ZigZag encoding. + FieldDescriptorProto_TYPE_SINT64 FieldDescriptorProto_Type = 18 // Uses ZigZag encoding. +) + +// Enum value maps for FieldDescriptorProto_Type. +var ( + FieldDescriptorProto_Type_name = map[int32]string{ + 1: "TYPE_DOUBLE", + 2: "TYPE_FLOAT", + 3: "TYPE_INT64", + 4: "TYPE_UINT64", + 5: "TYPE_INT32", + 6: "TYPE_FIXED64", + 7: "TYPE_FIXED32", + 8: "TYPE_BOOL", + 9: "TYPE_STRING", + 10: "TYPE_GROUP", + 11: "TYPE_MESSAGE", + 12: "TYPE_BYTES", + 13: "TYPE_UINT32", + 14: "TYPE_ENUM", + 15: "TYPE_SFIXED32", + 16: "TYPE_SFIXED64", + 17: "TYPE_SINT32", + 18: "TYPE_SINT64", + } + FieldDescriptorProto_Type_value = map[string]int32{ + "TYPE_DOUBLE": 1, + "TYPE_FLOAT": 2, + "TYPE_INT64": 3, + "TYPE_UINT64": 4, + "TYPE_INT32": 5, + "TYPE_FIXED64": 6, + "TYPE_FIXED32": 7, + "TYPE_BOOL": 8, + "TYPE_STRING": 9, + "TYPE_GROUP": 10, + "TYPE_MESSAGE": 11, + "TYPE_BYTES": 12, + "TYPE_UINT32": 13, + "TYPE_ENUM": 14, + "TYPE_SFIXED32": 15, + "TYPE_SFIXED64": 16, + "TYPE_SINT32": 17, + "TYPE_SINT64": 18, + } +) + +func (x FieldDescriptorProto_Type) Enum() *FieldDescriptorProto_Type { + p := new(FieldDescriptorProto_Type) + *p = x + return p +} + +func (x FieldDescriptorProto_Type) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (FieldDescriptorProto_Type) Descriptor() protoreflect.EnumDescriptor { + return file_google_protobuf_descriptor_proto_enumTypes[2].Descriptor() +} + +func (FieldDescriptorProto_Type) Type() protoreflect.EnumType { + return &file_google_protobuf_descriptor_proto_enumTypes[2] +} + +func (x FieldDescriptorProto_Type) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Do not use. +func (x *FieldDescriptorProto_Type) UnmarshalJSON(b []byte) error { + num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b) + if err != nil { + return err + } + *x = FieldDescriptorProto_Type(num) + return nil +} + +// Deprecated: Use FieldDescriptorProto_Type.Descriptor instead. +func (FieldDescriptorProto_Type) EnumDescriptor() ([]byte, []int) { + return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{4, 0} +} + +type FieldDescriptorProto_Label int32 + +const ( + // 0 is reserved for errors + FieldDescriptorProto_LABEL_OPTIONAL FieldDescriptorProto_Label = 1 + FieldDescriptorProto_LABEL_REPEATED FieldDescriptorProto_Label = 3 + // The required label is only allowed in google.protobuf. In proto3 and Editions + // it's explicitly prohibited. In Editions, the `field_presence` feature + // can be used to get this behavior. + FieldDescriptorProto_LABEL_REQUIRED FieldDescriptorProto_Label = 2 +) + +// Enum value maps for FieldDescriptorProto_Label. +var ( + FieldDescriptorProto_Label_name = map[int32]string{ + 1: "LABEL_OPTIONAL", + 3: "LABEL_REPEATED", + 2: "LABEL_REQUIRED", + } + FieldDescriptorProto_Label_value = map[string]int32{ + "LABEL_OPTIONAL": 1, + "LABEL_REPEATED": 3, + "LABEL_REQUIRED": 2, + } +) + +func (x FieldDescriptorProto_Label) Enum() *FieldDescriptorProto_Label { + p := new(FieldDescriptorProto_Label) + *p = x + return p +} + +func (x FieldDescriptorProto_Label) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (FieldDescriptorProto_Label) Descriptor() protoreflect.EnumDescriptor { + return file_google_protobuf_descriptor_proto_enumTypes[3].Descriptor() +} + +func (FieldDescriptorProto_Label) Type() protoreflect.EnumType { + return &file_google_protobuf_descriptor_proto_enumTypes[3] +} + +func (x FieldDescriptorProto_Label) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Do not use. +func (x *FieldDescriptorProto_Label) UnmarshalJSON(b []byte) error { + num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b) + if err != nil { + return err + } + *x = FieldDescriptorProto_Label(num) + return nil +} + +// Deprecated: Use FieldDescriptorProto_Label.Descriptor instead. +func (FieldDescriptorProto_Label) EnumDescriptor() ([]byte, []int) { + return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{4, 1} +} + +// Generated classes can be optimized for speed or code size. +type FileOptions_OptimizeMode int32 + +const ( + FileOptions_SPEED FileOptions_OptimizeMode = 1 // Generate complete code for parsing, serialization, + // etc. + FileOptions_CODE_SIZE FileOptions_OptimizeMode = 2 // Use ReflectionOps to implement these methods. + FileOptions_LITE_RUNTIME FileOptions_OptimizeMode = 3 // Generate code using MessageLite and the lite runtime. +) + +// Enum value maps for FileOptions_OptimizeMode. +var ( + FileOptions_OptimizeMode_name = map[int32]string{ + 1: "SPEED", + 2: "CODE_SIZE", + 3: "LITE_RUNTIME", + } + FileOptions_OptimizeMode_value = map[string]int32{ + "SPEED": 1, + "CODE_SIZE": 2, + "LITE_RUNTIME": 3, + } +) + +func (x FileOptions_OptimizeMode) Enum() *FileOptions_OptimizeMode { + p := new(FileOptions_OptimizeMode) + *p = x + return p +} + +func (x FileOptions_OptimizeMode) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (FileOptions_OptimizeMode) Descriptor() protoreflect.EnumDescriptor { + return file_google_protobuf_descriptor_proto_enumTypes[4].Descriptor() +} + +func (FileOptions_OptimizeMode) Type() protoreflect.EnumType { + return &file_google_protobuf_descriptor_proto_enumTypes[4] +} + +func (x FileOptions_OptimizeMode) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Do not use. +func (x *FileOptions_OptimizeMode) UnmarshalJSON(b []byte) error { + num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b) + if err != nil { + return err + } + *x = FileOptions_OptimizeMode(num) + return nil +} + +// Deprecated: Use FileOptions_OptimizeMode.Descriptor instead. +func (FileOptions_OptimizeMode) EnumDescriptor() ([]byte, []int) { + return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{10, 0} +} + +type FieldOptions_CType int32 + +const ( + // Default mode. + FieldOptions_STRING FieldOptions_CType = 0 + // The option [ctype=CORD] may be applied to a non-repeated field of type + // "bytes". It indicates that in C++, the data should be stored in a Cord + // instead of a string. For very large strings, this may reduce memory + // fragmentation. It may also allow better performance when parsing from a + // Cord, or when parsing with aliasing enabled, as the parsed Cord may then + // alias the original buffer. + FieldOptions_CORD FieldOptions_CType = 1 + FieldOptions_STRING_PIECE FieldOptions_CType = 2 +) + +// Enum value maps for FieldOptions_CType. +var ( + FieldOptions_CType_name = map[int32]string{ + 0: "STRING", + 1: "CORD", + 2: "STRING_PIECE", + } + FieldOptions_CType_value = map[string]int32{ + "STRING": 0, + "CORD": 1, + "STRING_PIECE": 2, + } +) + +func (x FieldOptions_CType) Enum() *FieldOptions_CType { + p := new(FieldOptions_CType) + *p = x + return p +} + +func (x FieldOptions_CType) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (FieldOptions_CType) Descriptor() protoreflect.EnumDescriptor { + return file_google_protobuf_descriptor_proto_enumTypes[5].Descriptor() +} + +func (FieldOptions_CType) Type() protoreflect.EnumType { + return &file_google_protobuf_descriptor_proto_enumTypes[5] +} + +func (x FieldOptions_CType) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Do not use. +func (x *FieldOptions_CType) UnmarshalJSON(b []byte) error { + num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b) + if err != nil { + return err + } + *x = FieldOptions_CType(num) + return nil +} + +// Deprecated: Use FieldOptions_CType.Descriptor instead. +func (FieldOptions_CType) EnumDescriptor() ([]byte, []int) { + return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{12, 0} +} + +type FieldOptions_JSType int32 + +const ( + // Use the default type. + FieldOptions_JS_NORMAL FieldOptions_JSType = 0 + // Use JavaScript strings. + FieldOptions_JS_STRING FieldOptions_JSType = 1 + // Use JavaScript numbers. + FieldOptions_JS_NUMBER FieldOptions_JSType = 2 +) + +// Enum value maps for FieldOptions_JSType. +var ( + FieldOptions_JSType_name = map[int32]string{ + 0: "JS_NORMAL", + 1: "JS_STRING", + 2: "JS_NUMBER", + } + FieldOptions_JSType_value = map[string]int32{ + "JS_NORMAL": 0, + "JS_STRING": 1, + "JS_NUMBER": 2, + } +) + +func (x FieldOptions_JSType) Enum() *FieldOptions_JSType { + p := new(FieldOptions_JSType) + *p = x + return p +} + +func (x FieldOptions_JSType) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (FieldOptions_JSType) Descriptor() protoreflect.EnumDescriptor { + return file_google_protobuf_descriptor_proto_enumTypes[6].Descriptor() +} + +func (FieldOptions_JSType) Type() protoreflect.EnumType { + return &file_google_protobuf_descriptor_proto_enumTypes[6] +} + +func (x FieldOptions_JSType) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Do not use. +func (x *FieldOptions_JSType) UnmarshalJSON(b []byte) error { + num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b) + if err != nil { + return err + } + *x = FieldOptions_JSType(num) + return nil +} + +// Deprecated: Use FieldOptions_JSType.Descriptor instead. +func (FieldOptions_JSType) EnumDescriptor() ([]byte, []int) { + return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{12, 1} +} + +// If set to RETENTION_SOURCE, the option will be omitted from the binary. +// Note: as of January 2023, support for this is in progress and does not yet +// have an effect (b/264593489). +type FieldOptions_OptionRetention int32 + +const ( + FieldOptions_RETENTION_UNKNOWN FieldOptions_OptionRetention = 0 + FieldOptions_RETENTION_RUNTIME FieldOptions_OptionRetention = 1 + FieldOptions_RETENTION_SOURCE FieldOptions_OptionRetention = 2 +) + +// Enum value maps for FieldOptions_OptionRetention. +var ( + FieldOptions_OptionRetention_name = map[int32]string{ + 0: "RETENTION_UNKNOWN", + 1: "RETENTION_RUNTIME", + 2: "RETENTION_SOURCE", + } + FieldOptions_OptionRetention_value = map[string]int32{ + "RETENTION_UNKNOWN": 0, + "RETENTION_RUNTIME": 1, + "RETENTION_SOURCE": 2, + } +) + +func (x FieldOptions_OptionRetention) Enum() *FieldOptions_OptionRetention { + p := new(FieldOptions_OptionRetention) + *p = x + return p +} + +func (x FieldOptions_OptionRetention) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (FieldOptions_OptionRetention) Descriptor() protoreflect.EnumDescriptor { + return file_google_protobuf_descriptor_proto_enumTypes[7].Descriptor() +} + +func (FieldOptions_OptionRetention) Type() protoreflect.EnumType { + return &file_google_protobuf_descriptor_proto_enumTypes[7] +} + +func (x FieldOptions_OptionRetention) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Do not use. +func (x *FieldOptions_OptionRetention) UnmarshalJSON(b []byte) error { + num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b) + if err != nil { + return err + } + *x = FieldOptions_OptionRetention(num) + return nil +} + +// Deprecated: Use FieldOptions_OptionRetention.Descriptor instead. +func (FieldOptions_OptionRetention) EnumDescriptor() ([]byte, []int) { + return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{12, 2} +} + +// This indicates the types of entities that the field may apply to when used +// as an option. If it is unset, then the field may be freely used as an +// option on any kind of entity. Note: as of January 2023, support for this is +// in progress and does not yet have an effect (b/264593489). +type FieldOptions_OptionTargetType int32 + +const ( + FieldOptions_TARGET_TYPE_UNKNOWN FieldOptions_OptionTargetType = 0 + FieldOptions_TARGET_TYPE_FILE FieldOptions_OptionTargetType = 1 + FieldOptions_TARGET_TYPE_EXTENSION_RANGE FieldOptions_OptionTargetType = 2 + FieldOptions_TARGET_TYPE_MESSAGE FieldOptions_OptionTargetType = 3 + FieldOptions_TARGET_TYPE_FIELD FieldOptions_OptionTargetType = 4 + FieldOptions_TARGET_TYPE_ONEOF FieldOptions_OptionTargetType = 5 + FieldOptions_TARGET_TYPE_ENUM FieldOptions_OptionTargetType = 6 + FieldOptions_TARGET_TYPE_ENUM_ENTRY FieldOptions_OptionTargetType = 7 + FieldOptions_TARGET_TYPE_SERVICE FieldOptions_OptionTargetType = 8 + FieldOptions_TARGET_TYPE_METHOD FieldOptions_OptionTargetType = 9 +) + +// Enum value maps for FieldOptions_OptionTargetType. +var ( + FieldOptions_OptionTargetType_name = map[int32]string{ + 0: "TARGET_TYPE_UNKNOWN", + 1: "TARGET_TYPE_FILE", + 2: "TARGET_TYPE_EXTENSION_RANGE", + 3: "TARGET_TYPE_MESSAGE", + 4: "TARGET_TYPE_FIELD", + 5: "TARGET_TYPE_ONEOF", + 6: "TARGET_TYPE_ENUM", + 7: "TARGET_TYPE_ENUM_ENTRY", + 8: "TARGET_TYPE_SERVICE", + 9: "TARGET_TYPE_METHOD", + } + FieldOptions_OptionTargetType_value = map[string]int32{ + "TARGET_TYPE_UNKNOWN": 0, + "TARGET_TYPE_FILE": 1, + "TARGET_TYPE_EXTENSION_RANGE": 2, + "TARGET_TYPE_MESSAGE": 3, + "TARGET_TYPE_FIELD": 4, + "TARGET_TYPE_ONEOF": 5, + "TARGET_TYPE_ENUM": 6, + "TARGET_TYPE_ENUM_ENTRY": 7, + "TARGET_TYPE_SERVICE": 8, + "TARGET_TYPE_METHOD": 9, + } +) + +func (x FieldOptions_OptionTargetType) Enum() *FieldOptions_OptionTargetType { + p := new(FieldOptions_OptionTargetType) + *p = x + return p +} + +func (x FieldOptions_OptionTargetType) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (FieldOptions_OptionTargetType) Descriptor() protoreflect.EnumDescriptor { + return file_google_protobuf_descriptor_proto_enumTypes[8].Descriptor() +} + +func (FieldOptions_OptionTargetType) Type() protoreflect.EnumType { + return &file_google_protobuf_descriptor_proto_enumTypes[8] +} + +func (x FieldOptions_OptionTargetType) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Do not use. +func (x *FieldOptions_OptionTargetType) UnmarshalJSON(b []byte) error { + num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b) + if err != nil { + return err + } + *x = FieldOptions_OptionTargetType(num) + return nil +} + +// Deprecated: Use FieldOptions_OptionTargetType.Descriptor instead. +func (FieldOptions_OptionTargetType) EnumDescriptor() ([]byte, []int) { + return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{12, 3} +} + +// Is this method side-effect-free (or safe in HTTP parlance), or idempotent, +// or neither? HTTP based RPC implementation may choose GET verb for safe +// methods, and PUT verb for idempotent methods instead of the default POST. +type MethodOptions_IdempotencyLevel int32 + +const ( + MethodOptions_IDEMPOTENCY_UNKNOWN MethodOptions_IdempotencyLevel = 0 + MethodOptions_NO_SIDE_EFFECTS MethodOptions_IdempotencyLevel = 1 // implies idempotent + MethodOptions_IDEMPOTENT MethodOptions_IdempotencyLevel = 2 // idempotent, but may have side effects +) + +// Enum value maps for MethodOptions_IdempotencyLevel. +var ( + MethodOptions_IdempotencyLevel_name = map[int32]string{ + 0: "IDEMPOTENCY_UNKNOWN", + 1: "NO_SIDE_EFFECTS", + 2: "IDEMPOTENT", + } + MethodOptions_IdempotencyLevel_value = map[string]int32{ + "IDEMPOTENCY_UNKNOWN": 0, + "NO_SIDE_EFFECTS": 1, + "IDEMPOTENT": 2, + } +) + +func (x MethodOptions_IdempotencyLevel) Enum() *MethodOptions_IdempotencyLevel { + p := new(MethodOptions_IdempotencyLevel) + *p = x + return p +} + +func (x MethodOptions_IdempotencyLevel) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (MethodOptions_IdempotencyLevel) Descriptor() protoreflect.EnumDescriptor { + return file_google_protobuf_descriptor_proto_enumTypes[9].Descriptor() +} + +func (MethodOptions_IdempotencyLevel) Type() protoreflect.EnumType { + return &file_google_protobuf_descriptor_proto_enumTypes[9] +} + +func (x MethodOptions_IdempotencyLevel) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Do not use. +func (x *MethodOptions_IdempotencyLevel) UnmarshalJSON(b []byte) error { + num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b) + if err != nil { + return err + } + *x = MethodOptions_IdempotencyLevel(num) + return nil +} + +// Deprecated: Use MethodOptions_IdempotencyLevel.Descriptor instead. +func (MethodOptions_IdempotencyLevel) EnumDescriptor() ([]byte, []int) { + return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{17, 0} +} + +type FeatureSet_FieldPresence int32 + +const ( + FeatureSet_FIELD_PRESENCE_UNKNOWN FeatureSet_FieldPresence = 0 + FeatureSet_EXPLICIT FeatureSet_FieldPresence = 1 + FeatureSet_IMPLICIT FeatureSet_FieldPresence = 2 + FeatureSet_LEGACY_REQUIRED FeatureSet_FieldPresence = 3 +) + +// Enum value maps for FeatureSet_FieldPresence. +var ( + FeatureSet_FieldPresence_name = map[int32]string{ + 0: "FIELD_PRESENCE_UNKNOWN", + 1: "EXPLICIT", + 2: "IMPLICIT", + 3: "LEGACY_REQUIRED", + } + FeatureSet_FieldPresence_value = map[string]int32{ + "FIELD_PRESENCE_UNKNOWN": 0, + "EXPLICIT": 1, + "IMPLICIT": 2, + "LEGACY_REQUIRED": 3, + } +) + +func (x FeatureSet_FieldPresence) Enum() *FeatureSet_FieldPresence { + p := new(FeatureSet_FieldPresence) + *p = x + return p +} + +func (x FeatureSet_FieldPresence) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (FeatureSet_FieldPresence) Descriptor() protoreflect.EnumDescriptor { + return file_google_protobuf_descriptor_proto_enumTypes[10].Descriptor() +} + +func (FeatureSet_FieldPresence) Type() protoreflect.EnumType { + return &file_google_protobuf_descriptor_proto_enumTypes[10] +} + +func (x FeatureSet_FieldPresence) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Do not use. +func (x *FeatureSet_FieldPresence) UnmarshalJSON(b []byte) error { + num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b) + if err != nil { + return err + } + *x = FeatureSet_FieldPresence(num) + return nil +} + +// Deprecated: Use FeatureSet_FieldPresence.Descriptor instead. +func (FeatureSet_FieldPresence) EnumDescriptor() ([]byte, []int) { + return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{19, 0} +} + +type FeatureSet_EnumType int32 + +const ( + FeatureSet_ENUM_TYPE_UNKNOWN FeatureSet_EnumType = 0 + FeatureSet_OPEN FeatureSet_EnumType = 1 + FeatureSet_CLOSED FeatureSet_EnumType = 2 +) + +// Enum value maps for FeatureSet_EnumType. +var ( + FeatureSet_EnumType_name = map[int32]string{ + 0: "ENUM_TYPE_UNKNOWN", + 1: "OPEN", + 2: "CLOSED", + } + FeatureSet_EnumType_value = map[string]int32{ + "ENUM_TYPE_UNKNOWN": 0, + "OPEN": 1, + "CLOSED": 2, + } +) + +func (x FeatureSet_EnumType) Enum() *FeatureSet_EnumType { + p := new(FeatureSet_EnumType) + *p = x + return p +} + +func (x FeatureSet_EnumType) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (FeatureSet_EnumType) Descriptor() protoreflect.EnumDescriptor { + return file_google_protobuf_descriptor_proto_enumTypes[11].Descriptor() +} + +func (FeatureSet_EnumType) Type() protoreflect.EnumType { + return &file_google_protobuf_descriptor_proto_enumTypes[11] +} + +func (x FeatureSet_EnumType) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Do not use. +func (x *FeatureSet_EnumType) UnmarshalJSON(b []byte) error { + num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b) + if err != nil { + return err + } + *x = FeatureSet_EnumType(num) + return nil +} + +// Deprecated: Use FeatureSet_EnumType.Descriptor instead. +func (FeatureSet_EnumType) EnumDescriptor() ([]byte, []int) { + return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{19, 1} +} + +type FeatureSet_RepeatedFieldEncoding int32 + +const ( + FeatureSet_REPEATED_FIELD_ENCODING_UNKNOWN FeatureSet_RepeatedFieldEncoding = 0 + FeatureSet_PACKED FeatureSet_RepeatedFieldEncoding = 1 + FeatureSet_EXPANDED FeatureSet_RepeatedFieldEncoding = 2 +) + +// Enum value maps for FeatureSet_RepeatedFieldEncoding. +var ( + FeatureSet_RepeatedFieldEncoding_name = map[int32]string{ + 0: "REPEATED_FIELD_ENCODING_UNKNOWN", + 1: "PACKED", + 2: "EXPANDED", + } + FeatureSet_RepeatedFieldEncoding_value = map[string]int32{ + "REPEATED_FIELD_ENCODING_UNKNOWN": 0, + "PACKED": 1, + "EXPANDED": 2, + } +) + +func (x FeatureSet_RepeatedFieldEncoding) Enum() *FeatureSet_RepeatedFieldEncoding { + p := new(FeatureSet_RepeatedFieldEncoding) + *p = x + return p +} + +func (x FeatureSet_RepeatedFieldEncoding) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (FeatureSet_RepeatedFieldEncoding) Descriptor() protoreflect.EnumDescriptor { + return file_google_protobuf_descriptor_proto_enumTypes[12].Descriptor() +} + +func (FeatureSet_RepeatedFieldEncoding) Type() protoreflect.EnumType { + return &file_google_protobuf_descriptor_proto_enumTypes[12] +} + +func (x FeatureSet_RepeatedFieldEncoding) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Do not use. +func (x *FeatureSet_RepeatedFieldEncoding) UnmarshalJSON(b []byte) error { + num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b) + if err != nil { + return err + } + *x = FeatureSet_RepeatedFieldEncoding(num) + return nil +} + +// Deprecated: Use FeatureSet_RepeatedFieldEncoding.Descriptor instead. +func (FeatureSet_RepeatedFieldEncoding) EnumDescriptor() ([]byte, []int) { + return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{19, 2} +} + +type FeatureSet_Utf8Validation int32 + +const ( + FeatureSet_UTF8_VALIDATION_UNKNOWN FeatureSet_Utf8Validation = 0 + FeatureSet_VERIFY FeatureSet_Utf8Validation = 2 + FeatureSet_NONE FeatureSet_Utf8Validation = 3 +) + +// Enum value maps for FeatureSet_Utf8Validation. +var ( + FeatureSet_Utf8Validation_name = map[int32]string{ + 0: "UTF8_VALIDATION_UNKNOWN", + 2: "VERIFY", + 3: "NONE", + } + FeatureSet_Utf8Validation_value = map[string]int32{ + "UTF8_VALIDATION_UNKNOWN": 0, + "VERIFY": 2, + "NONE": 3, + } +) + +func (x FeatureSet_Utf8Validation) Enum() *FeatureSet_Utf8Validation { + p := new(FeatureSet_Utf8Validation) + *p = x + return p +} + +func (x FeatureSet_Utf8Validation) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (FeatureSet_Utf8Validation) Descriptor() protoreflect.EnumDescriptor { + return file_google_protobuf_descriptor_proto_enumTypes[13].Descriptor() +} + +func (FeatureSet_Utf8Validation) Type() protoreflect.EnumType { + return &file_google_protobuf_descriptor_proto_enumTypes[13] +} + +func (x FeatureSet_Utf8Validation) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Do not use. +func (x *FeatureSet_Utf8Validation) UnmarshalJSON(b []byte) error { + num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b) + if err != nil { + return err + } + *x = FeatureSet_Utf8Validation(num) + return nil +} + +// Deprecated: Use FeatureSet_Utf8Validation.Descriptor instead. +func (FeatureSet_Utf8Validation) EnumDescriptor() ([]byte, []int) { + return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{19, 3} +} + +type FeatureSet_MessageEncoding int32 + +const ( + FeatureSet_MESSAGE_ENCODING_UNKNOWN FeatureSet_MessageEncoding = 0 + FeatureSet_LENGTH_PREFIXED FeatureSet_MessageEncoding = 1 + FeatureSet_DELIMITED FeatureSet_MessageEncoding = 2 +) + +// Enum value maps for FeatureSet_MessageEncoding. +var ( + FeatureSet_MessageEncoding_name = map[int32]string{ + 0: "MESSAGE_ENCODING_UNKNOWN", + 1: "LENGTH_PREFIXED", + 2: "DELIMITED", + } + FeatureSet_MessageEncoding_value = map[string]int32{ + "MESSAGE_ENCODING_UNKNOWN": 0, + "LENGTH_PREFIXED": 1, + "DELIMITED": 2, + } +) + +func (x FeatureSet_MessageEncoding) Enum() *FeatureSet_MessageEncoding { + p := new(FeatureSet_MessageEncoding) + *p = x + return p +} + +func (x FeatureSet_MessageEncoding) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (FeatureSet_MessageEncoding) Descriptor() protoreflect.EnumDescriptor { + return file_google_protobuf_descriptor_proto_enumTypes[14].Descriptor() +} + +func (FeatureSet_MessageEncoding) Type() protoreflect.EnumType { + return &file_google_protobuf_descriptor_proto_enumTypes[14] +} + +func (x FeatureSet_MessageEncoding) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Do not use. +func (x *FeatureSet_MessageEncoding) UnmarshalJSON(b []byte) error { + num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b) + if err != nil { + return err + } + *x = FeatureSet_MessageEncoding(num) + return nil +} + +// Deprecated: Use FeatureSet_MessageEncoding.Descriptor instead. +func (FeatureSet_MessageEncoding) EnumDescriptor() ([]byte, []int) { + return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{19, 4} +} + +type FeatureSet_JsonFormat int32 + +const ( + FeatureSet_JSON_FORMAT_UNKNOWN FeatureSet_JsonFormat = 0 + FeatureSet_ALLOW FeatureSet_JsonFormat = 1 + FeatureSet_LEGACY_BEST_EFFORT FeatureSet_JsonFormat = 2 +) + +// Enum value maps for FeatureSet_JsonFormat. +var ( + FeatureSet_JsonFormat_name = map[int32]string{ + 0: "JSON_FORMAT_UNKNOWN", + 1: "ALLOW", + 2: "LEGACY_BEST_EFFORT", + } + FeatureSet_JsonFormat_value = map[string]int32{ + "JSON_FORMAT_UNKNOWN": 0, + "ALLOW": 1, + "LEGACY_BEST_EFFORT": 2, + } +) + +func (x FeatureSet_JsonFormat) Enum() *FeatureSet_JsonFormat { + p := new(FeatureSet_JsonFormat) + *p = x + return p +} + +func (x FeatureSet_JsonFormat) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (FeatureSet_JsonFormat) Descriptor() protoreflect.EnumDescriptor { + return file_google_protobuf_descriptor_proto_enumTypes[15].Descriptor() +} + +func (FeatureSet_JsonFormat) Type() protoreflect.EnumType { + return &file_google_protobuf_descriptor_proto_enumTypes[15] +} + +func (x FeatureSet_JsonFormat) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Do not use. +func (x *FeatureSet_JsonFormat) UnmarshalJSON(b []byte) error { + num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b) + if err != nil { + return err + } + *x = FeatureSet_JsonFormat(num) + return nil +} + +// Deprecated: Use FeatureSet_JsonFormat.Descriptor instead. +func (FeatureSet_JsonFormat) EnumDescriptor() ([]byte, []int) { + return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{19, 5} +} + +// Represents the identified object's effect on the element in the original +// .proto file. +type GeneratedCodeInfo_Annotation_Semantic int32 + +const ( + // There is no effect or the effect is indescribable. + GeneratedCodeInfo_Annotation_NONE GeneratedCodeInfo_Annotation_Semantic = 0 + // The element is set or otherwise mutated. + GeneratedCodeInfo_Annotation_SET GeneratedCodeInfo_Annotation_Semantic = 1 + // An alias to the element is returned. + GeneratedCodeInfo_Annotation_ALIAS GeneratedCodeInfo_Annotation_Semantic = 2 +) + +// Enum value maps for GeneratedCodeInfo_Annotation_Semantic. +var ( + GeneratedCodeInfo_Annotation_Semantic_name = map[int32]string{ + 0: "NONE", + 1: "SET", + 2: "ALIAS", + } + GeneratedCodeInfo_Annotation_Semantic_value = map[string]int32{ + "NONE": 0, + "SET": 1, + "ALIAS": 2, + } +) + +func (x GeneratedCodeInfo_Annotation_Semantic) Enum() *GeneratedCodeInfo_Annotation_Semantic { + p := new(GeneratedCodeInfo_Annotation_Semantic) + *p = x + return p +} + +func (x GeneratedCodeInfo_Annotation_Semantic) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (GeneratedCodeInfo_Annotation_Semantic) Descriptor() protoreflect.EnumDescriptor { + return file_google_protobuf_descriptor_proto_enumTypes[16].Descriptor() +} + +func (GeneratedCodeInfo_Annotation_Semantic) Type() protoreflect.EnumType { + return &file_google_protobuf_descriptor_proto_enumTypes[16] +} + +func (x GeneratedCodeInfo_Annotation_Semantic) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Do not use. +func (x *GeneratedCodeInfo_Annotation_Semantic) UnmarshalJSON(b []byte) error { + num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b) + if err != nil { + return err + } + *x = GeneratedCodeInfo_Annotation_Semantic(num) + return nil +} + +// Deprecated: Use GeneratedCodeInfo_Annotation_Semantic.Descriptor instead. +func (GeneratedCodeInfo_Annotation_Semantic) EnumDescriptor() ([]byte, []int) { + return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{22, 0, 0} +} + +// The protocol compiler can output a FileDescriptorSet containing the .proto +// files it parses. +type FileDescriptorSet struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + File []*FileDescriptorProto `protobuf:"bytes,1,rep,name=file" json:"file,omitempty"` +} + +func (x *FileDescriptorSet) Reset() { + *x = FileDescriptorSet{} + if protoimpl.UnsafeEnabled { + mi := &file_google_protobuf_descriptor_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *FileDescriptorSet) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FileDescriptorSet) ProtoMessage() {} + +func (x *FileDescriptorSet) ProtoReflect() protoreflect.Message { + mi := &file_google_protobuf_descriptor_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use FileDescriptorSet.ProtoReflect.Descriptor instead. +func (*FileDescriptorSet) Descriptor() ([]byte, []int) { + return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{0} +} + +func (x *FileDescriptorSet) GetFile() []*FileDescriptorProto { + if x != nil { + return x.File + } + return nil +} + +// Describes a complete .proto file. +type FileDescriptorProto struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` // file name, relative to root of source tree + Package *string `protobuf:"bytes,2,opt,name=package" json:"package,omitempty"` // e.g. "foo", "foo.bar", etc. + // Names of files imported by this file. + Dependency []string `protobuf:"bytes,3,rep,name=dependency" json:"dependency,omitempty"` + // Indexes of the public imported files in the dependency list above. + PublicDependency []int32 `protobuf:"varint,10,rep,name=public_dependency,json=publicDependency" json:"public_dependency,omitempty"` + // Indexes of the weak imported files in the dependency list. + // For Google-internal migration only. Do not use. + WeakDependency []int32 `protobuf:"varint,11,rep,name=weak_dependency,json=weakDependency" json:"weak_dependency,omitempty"` + // All top-level definitions in this file. + MessageType []*DescriptorProto `protobuf:"bytes,4,rep,name=message_type,json=messageType" json:"message_type,omitempty"` + EnumType []*EnumDescriptorProto `protobuf:"bytes,5,rep,name=enum_type,json=enumType" json:"enum_type,omitempty"` + Service []*ServiceDescriptorProto `protobuf:"bytes,6,rep,name=service" json:"service,omitempty"` + Extension []*FieldDescriptorProto `protobuf:"bytes,7,rep,name=extension" json:"extension,omitempty"` + Options *FileOptions `protobuf:"bytes,8,opt,name=options" json:"options,omitempty"` + // This field contains optional information about the original source code. + // You may safely remove this entire field without harming runtime + // functionality of the descriptors -- the information is needed only by + // development tools. + SourceCodeInfo *SourceCodeInfo `protobuf:"bytes,9,opt,name=source_code_info,json=sourceCodeInfo" json:"source_code_info,omitempty"` + // The syntax of the proto file. + // The supported values are "proto2", "proto3", and "editions". + // + // If `edition` is present, this value must be "editions". + Syntax *string `protobuf:"bytes,12,opt,name=syntax" json:"syntax,omitempty"` + // The edition of the proto file. + Edition *Edition `protobuf:"varint,14,opt,name=edition,enum=google.protobuf.Edition" json:"edition,omitempty"` +} + +func (x *FileDescriptorProto) Reset() { + *x = FileDescriptorProto{} + if protoimpl.UnsafeEnabled { + mi := &file_google_protobuf_descriptor_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *FileDescriptorProto) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FileDescriptorProto) ProtoMessage() {} + +func (x *FileDescriptorProto) ProtoReflect() protoreflect.Message { + mi := &file_google_protobuf_descriptor_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use FileDescriptorProto.ProtoReflect.Descriptor instead. +func (*FileDescriptorProto) Descriptor() ([]byte, []int) { + return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{1} +} + +func (x *FileDescriptorProto) GetName() string { + if x != nil && x.Name != nil { + return *x.Name + } + return "" +} + +func (x *FileDescriptorProto) GetPackage() string { + if x != nil && x.Package != nil { + return *x.Package + } + return "" +} + +func (x *FileDescriptorProto) GetDependency() []string { + if x != nil { + return x.Dependency + } + return nil +} + +func (x *FileDescriptorProto) GetPublicDependency() []int32 { + if x != nil { + return x.PublicDependency + } + return nil +} + +func (x *FileDescriptorProto) GetWeakDependency() []int32 { + if x != nil { + return x.WeakDependency + } + return nil +} + +func (x *FileDescriptorProto) GetMessageType() []*DescriptorProto { + if x != nil { + return x.MessageType + } + return nil +} + +func (x *FileDescriptorProto) GetEnumType() []*EnumDescriptorProto { + if x != nil { + return x.EnumType + } + return nil +} + +func (x *FileDescriptorProto) GetService() []*ServiceDescriptorProto { + if x != nil { + return x.Service + } + return nil +} + +func (x *FileDescriptorProto) GetExtension() []*FieldDescriptorProto { + if x != nil { + return x.Extension + } + return nil +} + +func (x *FileDescriptorProto) GetOptions() *FileOptions { + if x != nil { + return x.Options + } + return nil +} + +func (x *FileDescriptorProto) GetSourceCodeInfo() *SourceCodeInfo { + if x != nil { + return x.SourceCodeInfo + } + return nil +} + +func (x *FileDescriptorProto) GetSyntax() string { + if x != nil && x.Syntax != nil { + return *x.Syntax + } + return "" +} + +func (x *FileDescriptorProto) GetEdition() Edition { + if x != nil && x.Edition != nil { + return *x.Edition + } + return Edition_EDITION_UNKNOWN +} + +// Describes a message type. +type DescriptorProto struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + Field []*FieldDescriptorProto `protobuf:"bytes,2,rep,name=field" json:"field,omitempty"` + Extension []*FieldDescriptorProto `protobuf:"bytes,6,rep,name=extension" json:"extension,omitempty"` + NestedType []*DescriptorProto `protobuf:"bytes,3,rep,name=nested_type,json=nestedType" json:"nested_type,omitempty"` + EnumType []*EnumDescriptorProto `protobuf:"bytes,4,rep,name=enum_type,json=enumType" json:"enum_type,omitempty"` + ExtensionRange []*DescriptorProto_ExtensionRange `protobuf:"bytes,5,rep,name=extension_range,json=extensionRange" json:"extension_range,omitempty"` + OneofDecl []*OneofDescriptorProto `protobuf:"bytes,8,rep,name=oneof_decl,json=oneofDecl" json:"oneof_decl,omitempty"` + Options *MessageOptions `protobuf:"bytes,7,opt,name=options" json:"options,omitempty"` + ReservedRange []*DescriptorProto_ReservedRange `protobuf:"bytes,9,rep,name=reserved_range,json=reservedRange" json:"reserved_range,omitempty"` + // Reserved field names, which may not be used by fields in the same message. + // A given name may only be reserved once. + ReservedName []string `protobuf:"bytes,10,rep,name=reserved_name,json=reservedName" json:"reserved_name,omitempty"` +} + +func (x *DescriptorProto) Reset() { + *x = DescriptorProto{} + if protoimpl.UnsafeEnabled { + mi := &file_google_protobuf_descriptor_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DescriptorProto) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DescriptorProto) ProtoMessage() {} + +func (x *DescriptorProto) ProtoReflect() protoreflect.Message { + mi := &file_google_protobuf_descriptor_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DescriptorProto.ProtoReflect.Descriptor instead. +func (*DescriptorProto) Descriptor() ([]byte, []int) { + return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{2} +} + +func (x *DescriptorProto) GetName() string { + if x != nil && x.Name != nil { + return *x.Name + } + return "" +} + +func (x *DescriptorProto) GetField() []*FieldDescriptorProto { + if x != nil { + return x.Field + } + return nil +} + +func (x *DescriptorProto) GetExtension() []*FieldDescriptorProto { + if x != nil { + return x.Extension + } + return nil +} + +func (x *DescriptorProto) GetNestedType() []*DescriptorProto { + if x != nil { + return x.NestedType + } + return nil +} + +func (x *DescriptorProto) GetEnumType() []*EnumDescriptorProto { + if x != nil { + return x.EnumType + } + return nil +} + +func (x *DescriptorProto) GetExtensionRange() []*DescriptorProto_ExtensionRange { + if x != nil { + return x.ExtensionRange + } + return nil +} + +func (x *DescriptorProto) GetOneofDecl() []*OneofDescriptorProto { + if x != nil { + return x.OneofDecl + } + return nil +} + +func (x *DescriptorProto) GetOptions() *MessageOptions { + if x != nil { + return x.Options + } + return nil +} + +func (x *DescriptorProto) GetReservedRange() []*DescriptorProto_ReservedRange { + if x != nil { + return x.ReservedRange + } + return nil +} + +func (x *DescriptorProto) GetReservedName() []string { + if x != nil { + return x.ReservedName + } + return nil +} + +type ExtensionRangeOptions struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + extensionFields protoimpl.ExtensionFields + + // The parser stores options it doesn't recognize here. See above. + UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"` + // For external users: DO NOT USE. We are in the process of open sourcing + // extension declaration and executing internal cleanups before it can be + // used externally. + Declaration []*ExtensionRangeOptions_Declaration `protobuf:"bytes,2,rep,name=declaration" json:"declaration,omitempty"` + // Any features defined in the specific edition. + Features *FeatureSet `protobuf:"bytes,50,opt,name=features" json:"features,omitempty"` + // The verification state of the range. + // TODO: flip the default to DECLARATION once all empty ranges + // are marked as UNVERIFIED. + Verification *ExtensionRangeOptions_VerificationState `protobuf:"varint,3,opt,name=verification,enum=google.protobuf.ExtensionRangeOptions_VerificationState,def=1" json:"verification,omitempty"` +} + +// Default values for ExtensionRangeOptions fields. +const ( + Default_ExtensionRangeOptions_Verification = ExtensionRangeOptions_UNVERIFIED +) + +func (x *ExtensionRangeOptions) Reset() { + *x = ExtensionRangeOptions{} + if protoimpl.UnsafeEnabled { + mi := &file_google_protobuf_descriptor_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ExtensionRangeOptions) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ExtensionRangeOptions) ProtoMessage() {} + +func (x *ExtensionRangeOptions) ProtoReflect() protoreflect.Message { + mi := &file_google_protobuf_descriptor_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ExtensionRangeOptions.ProtoReflect.Descriptor instead. +func (*ExtensionRangeOptions) Descriptor() ([]byte, []int) { + return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{3} +} + +func (x *ExtensionRangeOptions) GetUninterpretedOption() []*UninterpretedOption { + if x != nil { + return x.UninterpretedOption + } + return nil +} + +func (x *ExtensionRangeOptions) GetDeclaration() []*ExtensionRangeOptions_Declaration { + if x != nil { + return x.Declaration + } + return nil +} + +func (x *ExtensionRangeOptions) GetFeatures() *FeatureSet { + if x != nil { + return x.Features + } + return nil +} + +func (x *ExtensionRangeOptions) GetVerification() ExtensionRangeOptions_VerificationState { + if x != nil && x.Verification != nil { + return *x.Verification + } + return Default_ExtensionRangeOptions_Verification +} + +// Describes a field within a message. +type FieldDescriptorProto struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + Number *int32 `protobuf:"varint,3,opt,name=number" json:"number,omitempty"` + Label *FieldDescriptorProto_Label `protobuf:"varint,4,opt,name=label,enum=google.protobuf.FieldDescriptorProto_Label" json:"label,omitempty"` + // If type_name is set, this need not be set. If both this and type_name + // are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP. + Type *FieldDescriptorProto_Type `protobuf:"varint,5,opt,name=type,enum=google.protobuf.FieldDescriptorProto_Type" json:"type,omitempty"` + // For message and enum types, this is the name of the type. If the name + // starts with a '.', it is fully-qualified. Otherwise, C++-like scoping + // rules are used to find the type (i.e. first the nested types within this + // message are searched, then within the parent, on up to the root + // namespace). + TypeName *string `protobuf:"bytes,6,opt,name=type_name,json=typeName" json:"type_name,omitempty"` + // For extensions, this is the name of the type being extended. It is + // resolved in the same manner as type_name. + Extendee *string `protobuf:"bytes,2,opt,name=extendee" json:"extendee,omitempty"` + // For numeric types, contains the original text representation of the value. + // For booleans, "true" or "false". + // For strings, contains the default text contents (not escaped in any way). + // For bytes, contains the C escaped value. All bytes >= 128 are escaped. + DefaultValue *string `protobuf:"bytes,7,opt,name=default_value,json=defaultValue" json:"default_value,omitempty"` + // If set, gives the index of a oneof in the containing type's oneof_decl + // list. This field is a member of that oneof. + OneofIndex *int32 `protobuf:"varint,9,opt,name=oneof_index,json=oneofIndex" json:"oneof_index,omitempty"` + // JSON name of this field. The value is set by protocol compiler. If the + // user has set a "json_name" option on this field, that option's value + // will be used. Otherwise, it's deduced from the field's name by converting + // it to camelCase. + JsonName *string `protobuf:"bytes,10,opt,name=json_name,json=jsonName" json:"json_name,omitempty"` + Options *FieldOptions `protobuf:"bytes,8,opt,name=options" json:"options,omitempty"` + // If true, this is a proto3 "optional". When a proto3 field is optional, it + // tracks presence regardless of field type. + // + // When proto3_optional is true, this field must belong to a oneof to signal + // to old proto3 clients that presence is tracked for this field. This oneof + // is known as a "synthetic" oneof, and this field must be its sole member + // (each proto3 optional field gets its own synthetic oneof). Synthetic oneofs + // exist in the descriptor only, and do not generate any API. Synthetic oneofs + // must be ordered after all "real" oneofs. + // + // For message fields, proto3_optional doesn't create any semantic change, + // since non-repeated message fields always track presence. However it still + // indicates the semantic detail of whether the user wrote "optional" or not. + // This can be useful for round-tripping the .proto file. For consistency we + // give message fields a synthetic oneof also, even though it is not required + // to track presence. This is especially important because the parser can't + // tell if a field is a message or an enum, so it must always create a + // synthetic oneof. + // + // Proto2 optional fields do not set this flag, because they already indicate + // optional with `LABEL_OPTIONAL`. + Proto3Optional *bool `protobuf:"varint,17,opt,name=proto3_optional,json=proto3Optional" json:"proto3_optional,omitempty"` +} + +func (x *FieldDescriptorProto) Reset() { + *x = FieldDescriptorProto{} + if protoimpl.UnsafeEnabled { + mi := &file_google_protobuf_descriptor_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *FieldDescriptorProto) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FieldDescriptorProto) ProtoMessage() {} + +func (x *FieldDescriptorProto) ProtoReflect() protoreflect.Message { + mi := &file_google_protobuf_descriptor_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use FieldDescriptorProto.ProtoReflect.Descriptor instead. +func (*FieldDescriptorProto) Descriptor() ([]byte, []int) { + return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{4} +} + +func (x *FieldDescriptorProto) GetName() string { + if x != nil && x.Name != nil { + return *x.Name + } + return "" +} + +func (x *FieldDescriptorProto) GetNumber() int32 { + if x != nil && x.Number != nil { + return *x.Number + } + return 0 +} + +func (x *FieldDescriptorProto) GetLabel() FieldDescriptorProto_Label { + if x != nil && x.Label != nil { + return *x.Label + } + return FieldDescriptorProto_LABEL_OPTIONAL +} + +func (x *FieldDescriptorProto) GetType() FieldDescriptorProto_Type { + if x != nil && x.Type != nil { + return *x.Type + } + return FieldDescriptorProto_TYPE_DOUBLE +} + +func (x *FieldDescriptorProto) GetTypeName() string { + if x != nil && x.TypeName != nil { + return *x.TypeName + } + return "" +} + +func (x *FieldDescriptorProto) GetExtendee() string { + if x != nil && x.Extendee != nil { + return *x.Extendee + } + return "" +} + +func (x *FieldDescriptorProto) GetDefaultValue() string { + if x != nil && x.DefaultValue != nil { + return *x.DefaultValue + } + return "" +} + +func (x *FieldDescriptorProto) GetOneofIndex() int32 { + if x != nil && x.OneofIndex != nil { + return *x.OneofIndex + } + return 0 +} + +func (x *FieldDescriptorProto) GetJsonName() string { + if x != nil && x.JsonName != nil { + return *x.JsonName + } + return "" +} + +func (x *FieldDescriptorProto) GetOptions() *FieldOptions { + if x != nil { + return x.Options + } + return nil +} + +func (x *FieldDescriptorProto) GetProto3Optional() bool { + if x != nil && x.Proto3Optional != nil { + return *x.Proto3Optional + } + return false +} + +// Describes a oneof. +type OneofDescriptorProto struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + Options *OneofOptions `protobuf:"bytes,2,opt,name=options" json:"options,omitempty"` +} + +func (x *OneofDescriptorProto) Reset() { + *x = OneofDescriptorProto{} + if protoimpl.UnsafeEnabled { + mi := &file_google_protobuf_descriptor_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *OneofDescriptorProto) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*OneofDescriptorProto) ProtoMessage() {} + +func (x *OneofDescriptorProto) ProtoReflect() protoreflect.Message { + mi := &file_google_protobuf_descriptor_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use OneofDescriptorProto.ProtoReflect.Descriptor instead. +func (*OneofDescriptorProto) Descriptor() ([]byte, []int) { + return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{5} +} + +func (x *OneofDescriptorProto) GetName() string { + if x != nil && x.Name != nil { + return *x.Name + } + return "" +} + +func (x *OneofDescriptorProto) GetOptions() *OneofOptions { + if x != nil { + return x.Options + } + return nil +} + +// Describes an enum type. +type EnumDescriptorProto struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + Value []*EnumValueDescriptorProto `protobuf:"bytes,2,rep,name=value" json:"value,omitempty"` + Options *EnumOptions `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"` + // Range of reserved numeric values. Reserved numeric values may not be used + // by enum values in the same enum declaration. Reserved ranges may not + // overlap. + ReservedRange []*EnumDescriptorProto_EnumReservedRange `protobuf:"bytes,4,rep,name=reserved_range,json=reservedRange" json:"reserved_range,omitempty"` + // Reserved enum value names, which may not be reused. A given name may only + // be reserved once. + ReservedName []string `protobuf:"bytes,5,rep,name=reserved_name,json=reservedName" json:"reserved_name,omitempty"` +} + +func (x *EnumDescriptorProto) Reset() { + *x = EnumDescriptorProto{} + if protoimpl.UnsafeEnabled { + mi := &file_google_protobuf_descriptor_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *EnumDescriptorProto) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*EnumDescriptorProto) ProtoMessage() {} + +func (x *EnumDescriptorProto) ProtoReflect() protoreflect.Message { + mi := &file_google_protobuf_descriptor_proto_msgTypes[6] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use EnumDescriptorProto.ProtoReflect.Descriptor instead. +func (*EnumDescriptorProto) Descriptor() ([]byte, []int) { + return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{6} +} + +func (x *EnumDescriptorProto) GetName() string { + if x != nil && x.Name != nil { + return *x.Name + } + return "" +} + +func (x *EnumDescriptorProto) GetValue() []*EnumValueDescriptorProto { + if x != nil { + return x.Value + } + return nil +} + +func (x *EnumDescriptorProto) GetOptions() *EnumOptions { + if x != nil { + return x.Options + } + return nil +} + +func (x *EnumDescriptorProto) GetReservedRange() []*EnumDescriptorProto_EnumReservedRange { + if x != nil { + return x.ReservedRange + } + return nil +} + +func (x *EnumDescriptorProto) GetReservedName() []string { + if x != nil { + return x.ReservedName + } + return nil +} + +// Describes a value within an enum. +type EnumValueDescriptorProto struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + Number *int32 `protobuf:"varint,2,opt,name=number" json:"number,omitempty"` + Options *EnumValueOptions `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"` +} + +func (x *EnumValueDescriptorProto) Reset() { + *x = EnumValueDescriptorProto{} + if protoimpl.UnsafeEnabled { + mi := &file_google_protobuf_descriptor_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *EnumValueDescriptorProto) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*EnumValueDescriptorProto) ProtoMessage() {} + +func (x *EnumValueDescriptorProto) ProtoReflect() protoreflect.Message { + mi := &file_google_protobuf_descriptor_proto_msgTypes[7] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use EnumValueDescriptorProto.ProtoReflect.Descriptor instead. +func (*EnumValueDescriptorProto) Descriptor() ([]byte, []int) { + return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{7} +} + +func (x *EnumValueDescriptorProto) GetName() string { + if x != nil && x.Name != nil { + return *x.Name + } + return "" +} + +func (x *EnumValueDescriptorProto) GetNumber() int32 { + if x != nil && x.Number != nil { + return *x.Number + } + return 0 +} + +func (x *EnumValueDescriptorProto) GetOptions() *EnumValueOptions { + if x != nil { + return x.Options + } + return nil +} + +// Describes a service. +type ServiceDescriptorProto struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + Method []*MethodDescriptorProto `protobuf:"bytes,2,rep,name=method" json:"method,omitempty"` + Options *ServiceOptions `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"` +} + +func (x *ServiceDescriptorProto) Reset() { + *x = ServiceDescriptorProto{} + if protoimpl.UnsafeEnabled { + mi := &file_google_protobuf_descriptor_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ServiceDescriptorProto) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ServiceDescriptorProto) ProtoMessage() {} + +func (x *ServiceDescriptorProto) ProtoReflect() protoreflect.Message { + mi := &file_google_protobuf_descriptor_proto_msgTypes[8] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ServiceDescriptorProto.ProtoReflect.Descriptor instead. +func (*ServiceDescriptorProto) Descriptor() ([]byte, []int) { + return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{8} +} + +func (x *ServiceDescriptorProto) GetName() string { + if x != nil && x.Name != nil { + return *x.Name + } + return "" +} + +func (x *ServiceDescriptorProto) GetMethod() []*MethodDescriptorProto { + if x != nil { + return x.Method + } + return nil +} + +func (x *ServiceDescriptorProto) GetOptions() *ServiceOptions { + if x != nil { + return x.Options + } + return nil +} + +// Describes a method of a service. +type MethodDescriptorProto struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + // Input and output type names. These are resolved in the same way as + // FieldDescriptorProto.type_name, but must refer to a message type. + InputType *string `protobuf:"bytes,2,opt,name=input_type,json=inputType" json:"input_type,omitempty"` + OutputType *string `protobuf:"bytes,3,opt,name=output_type,json=outputType" json:"output_type,omitempty"` + Options *MethodOptions `protobuf:"bytes,4,opt,name=options" json:"options,omitempty"` + // Identifies if client streams multiple client messages + ClientStreaming *bool `protobuf:"varint,5,opt,name=client_streaming,json=clientStreaming,def=0" json:"client_streaming,omitempty"` + // Identifies if server streams multiple server messages + ServerStreaming *bool `protobuf:"varint,6,opt,name=server_streaming,json=serverStreaming,def=0" json:"server_streaming,omitempty"` +} + +// Default values for MethodDescriptorProto fields. +const ( + Default_MethodDescriptorProto_ClientStreaming = bool(false) + Default_MethodDescriptorProto_ServerStreaming = bool(false) +) + +func (x *MethodDescriptorProto) Reset() { + *x = MethodDescriptorProto{} + if protoimpl.UnsafeEnabled { + mi := &file_google_protobuf_descriptor_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MethodDescriptorProto) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MethodDescriptorProto) ProtoMessage() {} + +func (x *MethodDescriptorProto) ProtoReflect() protoreflect.Message { + mi := &file_google_protobuf_descriptor_proto_msgTypes[9] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use MethodDescriptorProto.ProtoReflect.Descriptor instead. +func (*MethodDescriptorProto) Descriptor() ([]byte, []int) { + return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{9} +} + +func (x *MethodDescriptorProto) GetName() string { + if x != nil && x.Name != nil { + return *x.Name + } + return "" +} + +func (x *MethodDescriptorProto) GetInputType() string { + if x != nil && x.InputType != nil { + return *x.InputType + } + return "" +} + +func (x *MethodDescriptorProto) GetOutputType() string { + if x != nil && x.OutputType != nil { + return *x.OutputType + } + return "" +} + +func (x *MethodDescriptorProto) GetOptions() *MethodOptions { + if x != nil { + return x.Options + } + return nil +} + +func (x *MethodDescriptorProto) GetClientStreaming() bool { + if x != nil && x.ClientStreaming != nil { + return *x.ClientStreaming + } + return Default_MethodDescriptorProto_ClientStreaming +} + +func (x *MethodDescriptorProto) GetServerStreaming() bool { + if x != nil && x.ServerStreaming != nil { + return *x.ServerStreaming + } + return Default_MethodDescriptorProto_ServerStreaming +} + +type FileOptions struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + extensionFields protoimpl.ExtensionFields + + // Sets the Java package where classes generated from this .proto will be + // placed. By default, the proto package is used, but this is often + // inappropriate because proto packages do not normally start with backwards + // domain names. + JavaPackage *string `protobuf:"bytes,1,opt,name=java_package,json=javaPackage" json:"java_package,omitempty"` + // Controls the name of the wrapper Java class generated for the .proto file. + // That class will always contain the .proto file's getDescriptor() method as + // well as any top-level extensions defined in the .proto file. + // If java_multiple_files is disabled, then all the other classes from the + // .proto file will be nested inside the single wrapper outer class. + JavaOuterClassname *string `protobuf:"bytes,8,opt,name=java_outer_classname,json=javaOuterClassname" json:"java_outer_classname,omitempty"` + // If enabled, then the Java code generator will generate a separate .java + // file for each top-level message, enum, and service defined in the .proto + // file. Thus, these types will *not* be nested inside the wrapper class + // named by java_outer_classname. However, the wrapper class will still be + // generated to contain the file's getDescriptor() method as well as any + // top-level extensions defined in the file. + JavaMultipleFiles *bool `protobuf:"varint,10,opt,name=java_multiple_files,json=javaMultipleFiles,def=0" json:"java_multiple_files,omitempty"` + // This option does nothing. + // + // Deprecated: Marked as deprecated in google/protobuf/descriptor.proto. + JavaGenerateEqualsAndHash *bool `protobuf:"varint,20,opt,name=java_generate_equals_and_hash,json=javaGenerateEqualsAndHash" json:"java_generate_equals_and_hash,omitempty"` + // If set true, then the Java2 code generator will generate code that + // throws an exception whenever an attempt is made to assign a non-UTF-8 + // byte sequence to a string field. + // Message reflection will do the same. + // However, an extension field still accepts non-UTF-8 byte sequences. + // This option has no effect on when used with the lite runtime. + JavaStringCheckUtf8 *bool `protobuf:"varint,27,opt,name=java_string_check_utf8,json=javaStringCheckUtf8,def=0" json:"java_string_check_utf8,omitempty"` + OptimizeFor *FileOptions_OptimizeMode `protobuf:"varint,9,opt,name=optimize_for,json=optimizeFor,enum=google.protobuf.FileOptions_OptimizeMode,def=1" json:"optimize_for,omitempty"` + // Sets the Go package where structs generated from this .proto will be + // placed. If omitted, the Go package will be derived from the following: + // - The basename of the package import path, if provided. + // - Otherwise, the package statement in the .proto file, if present. + // - Otherwise, the basename of the .proto file, without extension. + GoPackage *string `protobuf:"bytes,11,opt,name=go_package,json=goPackage" json:"go_package,omitempty"` + // Should generic services be generated in each language? "Generic" services + // are not specific to any particular RPC system. They are generated by the + // main code generators in each language (without additional plugins). + // Generic services were the only kind of service generation supported by + // early versions of google.protobuf. + // + // Generic services are now considered deprecated in favor of using plugins + // that generate code specific to your particular RPC system. Therefore, + // these default to false. Old code which depends on generic services should + // explicitly set them to true. + CcGenericServices *bool `protobuf:"varint,16,opt,name=cc_generic_services,json=ccGenericServices,def=0" json:"cc_generic_services,omitempty"` + JavaGenericServices *bool `protobuf:"varint,17,opt,name=java_generic_services,json=javaGenericServices,def=0" json:"java_generic_services,omitempty"` + PyGenericServices *bool `protobuf:"varint,18,opt,name=py_generic_services,json=pyGenericServices,def=0" json:"py_generic_services,omitempty"` + // Is this file deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for everything in the file, or it will be completely ignored; in the very + // least, this is a formalization for deprecating files. + Deprecated *bool `protobuf:"varint,23,opt,name=deprecated,def=0" json:"deprecated,omitempty"` + // Enables the use of arenas for the proto messages in this file. This applies + // only to generated classes for C++. + CcEnableArenas *bool `protobuf:"varint,31,opt,name=cc_enable_arenas,json=ccEnableArenas,def=1" json:"cc_enable_arenas,omitempty"` + // Sets the objective c class prefix which is prepended to all objective c + // generated classes from this .proto. There is no default. + ObjcClassPrefix *string `protobuf:"bytes,36,opt,name=objc_class_prefix,json=objcClassPrefix" json:"objc_class_prefix,omitempty"` + // Namespace for generated classes; defaults to the package. + CsharpNamespace *string `protobuf:"bytes,37,opt,name=csharp_namespace,json=csharpNamespace" json:"csharp_namespace,omitempty"` + // By default Swift generators will take the proto package and CamelCase it + // replacing '.' with underscore and use that to prefix the types/symbols + // defined. When this options is provided, they will use this value instead + // to prefix the types/symbols defined. + SwiftPrefix *string `protobuf:"bytes,39,opt,name=swift_prefix,json=swiftPrefix" json:"swift_prefix,omitempty"` + // Sets the php class prefix which is prepended to all php generated classes + // from this .proto. Default is empty. + PhpClassPrefix *string `protobuf:"bytes,40,opt,name=php_class_prefix,json=phpClassPrefix" json:"php_class_prefix,omitempty"` + // Use this option to change the namespace of php generated classes. Default + // is empty. When this option is empty, the package name will be used for + // determining the namespace. + PhpNamespace *string `protobuf:"bytes,41,opt,name=php_namespace,json=phpNamespace" json:"php_namespace,omitempty"` + // Use this option to change the namespace of php generated metadata classes. + // Default is empty. When this option is empty, the proto file name will be + // used for determining the namespace. + PhpMetadataNamespace *string `protobuf:"bytes,44,opt,name=php_metadata_namespace,json=phpMetadataNamespace" json:"php_metadata_namespace,omitempty"` + // Use this option to change the package of ruby generated classes. Default + // is empty. When this option is not set, the package name will be used for + // determining the ruby package. + RubyPackage *string `protobuf:"bytes,45,opt,name=ruby_package,json=rubyPackage" json:"ruby_package,omitempty"` + // Any features defined in the specific edition. + Features *FeatureSet `protobuf:"bytes,50,opt,name=features" json:"features,omitempty"` + // The parser stores options it doesn't recognize here. + // See the documentation for the "Options" section above. + UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"` +} + +// Default values for FileOptions fields. +const ( + Default_FileOptions_JavaMultipleFiles = bool(false) + Default_FileOptions_JavaStringCheckUtf8 = bool(false) + Default_FileOptions_OptimizeFor = FileOptions_SPEED + Default_FileOptions_CcGenericServices = bool(false) + Default_FileOptions_JavaGenericServices = bool(false) + Default_FileOptions_PyGenericServices = bool(false) + Default_FileOptions_Deprecated = bool(false) + Default_FileOptions_CcEnableArenas = bool(true) +) + +func (x *FileOptions) Reset() { + *x = FileOptions{} + if protoimpl.UnsafeEnabled { + mi := &file_google_protobuf_descriptor_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *FileOptions) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FileOptions) ProtoMessage() {} + +func (x *FileOptions) ProtoReflect() protoreflect.Message { + mi := &file_google_protobuf_descriptor_proto_msgTypes[10] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use FileOptions.ProtoReflect.Descriptor instead. +func (*FileOptions) Descriptor() ([]byte, []int) { + return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{10} +} + +func (x *FileOptions) GetJavaPackage() string { + if x != nil && x.JavaPackage != nil { + return *x.JavaPackage + } + return "" +} + +func (x *FileOptions) GetJavaOuterClassname() string { + if x != nil && x.JavaOuterClassname != nil { + return *x.JavaOuterClassname + } + return "" +} + +func (x *FileOptions) GetJavaMultipleFiles() bool { + if x != nil && x.JavaMultipleFiles != nil { + return *x.JavaMultipleFiles + } + return Default_FileOptions_JavaMultipleFiles +} + +// Deprecated: Marked as deprecated in google/protobuf/descriptor.proto. +func (x *FileOptions) GetJavaGenerateEqualsAndHash() bool { + if x != nil && x.JavaGenerateEqualsAndHash != nil { + return *x.JavaGenerateEqualsAndHash + } + return false +} + +func (x *FileOptions) GetJavaStringCheckUtf8() bool { + if x != nil && x.JavaStringCheckUtf8 != nil { + return *x.JavaStringCheckUtf8 + } + return Default_FileOptions_JavaStringCheckUtf8 +} + +func (x *FileOptions) GetOptimizeFor() FileOptions_OptimizeMode { + if x != nil && x.OptimizeFor != nil { + return *x.OptimizeFor + } + return Default_FileOptions_OptimizeFor +} + +func (x *FileOptions) GetGoPackage() string { + if x != nil && x.GoPackage != nil { + return *x.GoPackage + } + return "" +} + +func (x *FileOptions) GetCcGenericServices() bool { + if x != nil && x.CcGenericServices != nil { + return *x.CcGenericServices + } + return Default_FileOptions_CcGenericServices +} + +func (x *FileOptions) GetJavaGenericServices() bool { + if x != nil && x.JavaGenericServices != nil { + return *x.JavaGenericServices + } + return Default_FileOptions_JavaGenericServices +} + +func (x *FileOptions) GetPyGenericServices() bool { + if x != nil && x.PyGenericServices != nil { + return *x.PyGenericServices + } + return Default_FileOptions_PyGenericServices +} + +func (x *FileOptions) GetDeprecated() bool { + if x != nil && x.Deprecated != nil { + return *x.Deprecated + } + return Default_FileOptions_Deprecated +} + +func (x *FileOptions) GetCcEnableArenas() bool { + if x != nil && x.CcEnableArenas != nil { + return *x.CcEnableArenas + } + return Default_FileOptions_CcEnableArenas +} + +func (x *FileOptions) GetObjcClassPrefix() string { + if x != nil && x.ObjcClassPrefix != nil { + return *x.ObjcClassPrefix + } + return "" +} + +func (x *FileOptions) GetCsharpNamespace() string { + if x != nil && x.CsharpNamespace != nil { + return *x.CsharpNamespace + } + return "" +} + +func (x *FileOptions) GetSwiftPrefix() string { + if x != nil && x.SwiftPrefix != nil { + return *x.SwiftPrefix + } + return "" +} + +func (x *FileOptions) GetPhpClassPrefix() string { + if x != nil && x.PhpClassPrefix != nil { + return *x.PhpClassPrefix + } + return "" +} + +func (x *FileOptions) GetPhpNamespace() string { + if x != nil && x.PhpNamespace != nil { + return *x.PhpNamespace + } + return "" +} + +func (x *FileOptions) GetPhpMetadataNamespace() string { + if x != nil && x.PhpMetadataNamespace != nil { + return *x.PhpMetadataNamespace + } + return "" +} + +func (x *FileOptions) GetRubyPackage() string { + if x != nil && x.RubyPackage != nil { + return *x.RubyPackage + } + return "" +} + +func (x *FileOptions) GetFeatures() *FeatureSet { + if x != nil { + return x.Features + } + return nil +} + +func (x *FileOptions) GetUninterpretedOption() []*UninterpretedOption { + if x != nil { + return x.UninterpretedOption + } + return nil +} + +type MessageOptions struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + extensionFields protoimpl.ExtensionFields + + // Set true to use the old proto1 MessageSet wire format for extensions. + // This is provided for backwards-compatibility with the MessageSet wire + // format. You should not use this for any other reason: It's less + // efficient, has fewer features, and is more complicated. + // + // The message must be defined exactly as follows: + // + // message Foo { + // option message_set_wire_format = true; + // extensions 4 to max; + // } + // + // Note that the message cannot have any defined fields; MessageSets only + // have extensions. + // + // All extensions of your type must be singular messages; e.g. they cannot + // be int32s, enums, or repeated messages. + // + // Because this is an option, the above two restrictions are not enforced by + // the protocol compiler. + MessageSetWireFormat *bool `protobuf:"varint,1,opt,name=message_set_wire_format,json=messageSetWireFormat,def=0" json:"message_set_wire_format,omitempty"` + // Disables the generation of the standard "descriptor()" accessor, which can + // conflict with a field of the same name. This is meant to make migration + // from proto1 easier; new code should avoid fields named "descriptor". + NoStandardDescriptorAccessor *bool `protobuf:"varint,2,opt,name=no_standard_descriptor_accessor,json=noStandardDescriptorAccessor,def=0" json:"no_standard_descriptor_accessor,omitempty"` + // Is this message deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for the message, or it will be completely ignored; in the very least, + // this is a formalization for deprecating messages. + Deprecated *bool `protobuf:"varint,3,opt,name=deprecated,def=0" json:"deprecated,omitempty"` + // Whether the message is an automatically generated map entry type for the + // maps field. + // + // For maps fields: + // + // map map_field = 1; + // + // The parsed descriptor looks like: + // + // message MapFieldEntry { + // option map_entry = true; + // optional KeyType key = 1; + // optional ValueType value = 2; + // } + // repeated MapFieldEntry map_field = 1; + // + // Implementations may choose not to generate the map_entry=true message, but + // use a native map in the target language to hold the keys and values. + // The reflection APIs in such implementations still need to work as + // if the field is a repeated message field. + // + // NOTE: Do not set the option in .proto files. Always use the maps syntax + // instead. The option should only be implicitly set by the proto compiler + // parser. + MapEntry *bool `protobuf:"varint,7,opt,name=map_entry,json=mapEntry" json:"map_entry,omitempty"` + // Enable the legacy handling of JSON field name conflicts. This lowercases + // and strips underscored from the fields before comparison in proto3 only. + // The new behavior takes `json_name` into account and applies to proto2 as + // well. + // + // This should only be used as a temporary measure against broken builds due + // to the change in behavior for JSON field name conflicts. + // + // TODO This is legacy behavior we plan to remove once downstream + // teams have had time to migrate. + // + // Deprecated: Marked as deprecated in google/protobuf/descriptor.proto. + DeprecatedLegacyJsonFieldConflicts *bool `protobuf:"varint,11,opt,name=deprecated_legacy_json_field_conflicts,json=deprecatedLegacyJsonFieldConflicts" json:"deprecated_legacy_json_field_conflicts,omitempty"` + // Any features defined in the specific edition. + Features *FeatureSet `protobuf:"bytes,12,opt,name=features" json:"features,omitempty"` + // The parser stores options it doesn't recognize here. See above. + UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"` +} + +// Default values for MessageOptions fields. +const ( + Default_MessageOptions_MessageSetWireFormat = bool(false) + Default_MessageOptions_NoStandardDescriptorAccessor = bool(false) + Default_MessageOptions_Deprecated = bool(false) +) + +func (x *MessageOptions) Reset() { + *x = MessageOptions{} + if protoimpl.UnsafeEnabled { + mi := &file_google_protobuf_descriptor_proto_msgTypes[11] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MessageOptions) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MessageOptions) ProtoMessage() {} + +func (x *MessageOptions) ProtoReflect() protoreflect.Message { + mi := &file_google_protobuf_descriptor_proto_msgTypes[11] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use MessageOptions.ProtoReflect.Descriptor instead. +func (*MessageOptions) Descriptor() ([]byte, []int) { + return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{11} +} + +func (x *MessageOptions) GetMessageSetWireFormat() bool { + if x != nil && x.MessageSetWireFormat != nil { + return *x.MessageSetWireFormat + } + return Default_MessageOptions_MessageSetWireFormat +} + +func (x *MessageOptions) GetNoStandardDescriptorAccessor() bool { + if x != nil && x.NoStandardDescriptorAccessor != nil { + return *x.NoStandardDescriptorAccessor + } + return Default_MessageOptions_NoStandardDescriptorAccessor +} + +func (x *MessageOptions) GetDeprecated() bool { + if x != nil && x.Deprecated != nil { + return *x.Deprecated + } + return Default_MessageOptions_Deprecated +} + +func (x *MessageOptions) GetMapEntry() bool { + if x != nil && x.MapEntry != nil { + return *x.MapEntry + } + return false +} + +// Deprecated: Marked as deprecated in google/protobuf/descriptor.proto. +func (x *MessageOptions) GetDeprecatedLegacyJsonFieldConflicts() bool { + if x != nil && x.DeprecatedLegacyJsonFieldConflicts != nil { + return *x.DeprecatedLegacyJsonFieldConflicts + } + return false +} + +func (x *MessageOptions) GetFeatures() *FeatureSet { + if x != nil { + return x.Features + } + return nil +} + +func (x *MessageOptions) GetUninterpretedOption() []*UninterpretedOption { + if x != nil { + return x.UninterpretedOption + } + return nil +} + +type FieldOptions struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + extensionFields protoimpl.ExtensionFields + + // The ctype option instructs the C++ code generator to use a different + // representation of the field than it normally would. See the specific + // options below. This option is only implemented to support use of + // [ctype=CORD] and [ctype=STRING] (the default) on non-repeated fields of + // type "bytes" in the open source release -- sorry, we'll try to include + // other types in a future version! + Ctype *FieldOptions_CType `protobuf:"varint,1,opt,name=ctype,enum=google.protobuf.FieldOptions_CType,def=0" json:"ctype,omitempty"` + // The packed option can be enabled for repeated primitive fields to enable + // a more efficient representation on the wire. Rather than repeatedly + // writing the tag and type for each element, the entire array is encoded as + // a single length-delimited blob. In proto3, only explicit setting it to + // false will avoid using packed encoding. This option is prohibited in + // Editions, but the `repeated_field_encoding` feature can be used to control + // the behavior. + Packed *bool `protobuf:"varint,2,opt,name=packed" json:"packed,omitempty"` + // The jstype option determines the JavaScript type used for values of the + // field. The option is permitted only for 64 bit integral and fixed types + // (int64, uint64, sint64, fixed64, sfixed64). A field with jstype JS_STRING + // is represented as JavaScript string, which avoids loss of precision that + // can happen when a large value is converted to a floating point JavaScript. + // Specifying JS_NUMBER for the jstype causes the generated JavaScript code to + // use the JavaScript "number" type. The behavior of the default option + // JS_NORMAL is implementation dependent. + // + // This option is an enum to permit additional types to be added, e.g. + // goog.math.Integer. + Jstype *FieldOptions_JSType `protobuf:"varint,6,opt,name=jstype,enum=google.protobuf.FieldOptions_JSType,def=0" json:"jstype,omitempty"` + // Should this field be parsed lazily? Lazy applies only to message-type + // fields. It means that when the outer message is initially parsed, the + // inner message's contents will not be parsed but instead stored in encoded + // form. The inner message will actually be parsed when it is first accessed. + // + // This is only a hint. Implementations are free to choose whether to use + // eager or lazy parsing regardless of the value of this option. However, + // setting this option true suggests that the protocol author believes that + // using lazy parsing on this field is worth the additional bookkeeping + // overhead typically needed to implement it. + // + // This option does not affect the public interface of any generated code; + // all method signatures remain the same. Furthermore, thread-safety of the + // interface is not affected by this option; const methods remain safe to + // call from multiple threads concurrently, while non-const methods continue + // to require exclusive access. + // + // Note that lazy message fields are still eagerly verified to check + // ill-formed wireformat or missing required fields. Calling IsInitialized() + // on the outer message would fail if the inner message has missing required + // fields. Failed verification would result in parsing failure (except when + // uninitialized messages are acceptable). + Lazy *bool `protobuf:"varint,5,opt,name=lazy,def=0" json:"lazy,omitempty"` + // unverified_lazy does no correctness checks on the byte stream. This should + // only be used where lazy with verification is prohibitive for performance + // reasons. + UnverifiedLazy *bool `protobuf:"varint,15,opt,name=unverified_lazy,json=unverifiedLazy,def=0" json:"unverified_lazy,omitempty"` + // Is this field deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for accessors, or it will be completely ignored; in the very least, this + // is a formalization for deprecating fields. + Deprecated *bool `protobuf:"varint,3,opt,name=deprecated,def=0" json:"deprecated,omitempty"` + // For Google-internal migration only. Do not use. + Weak *bool `protobuf:"varint,10,opt,name=weak,def=0" json:"weak,omitempty"` + // Indicate that the field value should not be printed out when using debug + // formats, e.g. when the field contains sensitive credentials. + DebugRedact *bool `protobuf:"varint,16,opt,name=debug_redact,json=debugRedact,def=0" json:"debug_redact,omitempty"` + Retention *FieldOptions_OptionRetention `protobuf:"varint,17,opt,name=retention,enum=google.protobuf.FieldOptions_OptionRetention" json:"retention,omitempty"` + Targets []FieldOptions_OptionTargetType `protobuf:"varint,19,rep,name=targets,enum=google.protobuf.FieldOptions_OptionTargetType" json:"targets,omitempty"` + EditionDefaults []*FieldOptions_EditionDefault `protobuf:"bytes,20,rep,name=edition_defaults,json=editionDefaults" json:"edition_defaults,omitempty"` + // Any features defined in the specific edition. + Features *FeatureSet `protobuf:"bytes,21,opt,name=features" json:"features,omitempty"` + // The parser stores options it doesn't recognize here. See above. + UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"` +} + +// Default values for FieldOptions fields. +const ( + Default_FieldOptions_Ctype = FieldOptions_STRING + Default_FieldOptions_Jstype = FieldOptions_JS_NORMAL + Default_FieldOptions_Lazy = bool(false) + Default_FieldOptions_UnverifiedLazy = bool(false) + Default_FieldOptions_Deprecated = bool(false) + Default_FieldOptions_Weak = bool(false) + Default_FieldOptions_DebugRedact = bool(false) +) + +func (x *FieldOptions) Reset() { + *x = FieldOptions{} + if protoimpl.UnsafeEnabled { + mi := &file_google_protobuf_descriptor_proto_msgTypes[12] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *FieldOptions) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FieldOptions) ProtoMessage() {} + +func (x *FieldOptions) ProtoReflect() protoreflect.Message { + mi := &file_google_protobuf_descriptor_proto_msgTypes[12] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use FieldOptions.ProtoReflect.Descriptor instead. +func (*FieldOptions) Descriptor() ([]byte, []int) { + return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{12} +} + +func (x *FieldOptions) GetCtype() FieldOptions_CType { + if x != nil && x.Ctype != nil { + return *x.Ctype + } + return Default_FieldOptions_Ctype +} + +func (x *FieldOptions) GetPacked() bool { + if x != nil && x.Packed != nil { + return *x.Packed + } + return false +} + +func (x *FieldOptions) GetJstype() FieldOptions_JSType { + if x != nil && x.Jstype != nil { + return *x.Jstype + } + return Default_FieldOptions_Jstype +} + +func (x *FieldOptions) GetLazy() bool { + if x != nil && x.Lazy != nil { + return *x.Lazy + } + return Default_FieldOptions_Lazy +} + +func (x *FieldOptions) GetUnverifiedLazy() bool { + if x != nil && x.UnverifiedLazy != nil { + return *x.UnverifiedLazy + } + return Default_FieldOptions_UnverifiedLazy +} + +func (x *FieldOptions) GetDeprecated() bool { + if x != nil && x.Deprecated != nil { + return *x.Deprecated + } + return Default_FieldOptions_Deprecated +} + +func (x *FieldOptions) GetWeak() bool { + if x != nil && x.Weak != nil { + return *x.Weak + } + return Default_FieldOptions_Weak +} + +func (x *FieldOptions) GetDebugRedact() bool { + if x != nil && x.DebugRedact != nil { + return *x.DebugRedact + } + return Default_FieldOptions_DebugRedact +} + +func (x *FieldOptions) GetRetention() FieldOptions_OptionRetention { + if x != nil && x.Retention != nil { + return *x.Retention + } + return FieldOptions_RETENTION_UNKNOWN +} + +func (x *FieldOptions) GetTargets() []FieldOptions_OptionTargetType { + if x != nil { + return x.Targets + } + return nil +} + +func (x *FieldOptions) GetEditionDefaults() []*FieldOptions_EditionDefault { + if x != nil { + return x.EditionDefaults + } + return nil +} + +func (x *FieldOptions) GetFeatures() *FeatureSet { + if x != nil { + return x.Features + } + return nil +} + +func (x *FieldOptions) GetUninterpretedOption() []*UninterpretedOption { + if x != nil { + return x.UninterpretedOption + } + return nil +} + +type OneofOptions struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + extensionFields protoimpl.ExtensionFields + + // Any features defined in the specific edition. + Features *FeatureSet `protobuf:"bytes,1,opt,name=features" json:"features,omitempty"` + // The parser stores options it doesn't recognize here. See above. + UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"` +} + +func (x *OneofOptions) Reset() { + *x = OneofOptions{} + if protoimpl.UnsafeEnabled { + mi := &file_google_protobuf_descriptor_proto_msgTypes[13] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *OneofOptions) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*OneofOptions) ProtoMessage() {} + +func (x *OneofOptions) ProtoReflect() protoreflect.Message { + mi := &file_google_protobuf_descriptor_proto_msgTypes[13] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use OneofOptions.ProtoReflect.Descriptor instead. +func (*OneofOptions) Descriptor() ([]byte, []int) { + return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{13} +} + +func (x *OneofOptions) GetFeatures() *FeatureSet { + if x != nil { + return x.Features + } + return nil +} + +func (x *OneofOptions) GetUninterpretedOption() []*UninterpretedOption { + if x != nil { + return x.UninterpretedOption + } + return nil +} + +type EnumOptions struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + extensionFields protoimpl.ExtensionFields + + // Set this option to true to allow mapping different tag names to the same + // value. + AllowAlias *bool `protobuf:"varint,2,opt,name=allow_alias,json=allowAlias" json:"allow_alias,omitempty"` + // Is this enum deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for the enum, or it will be completely ignored; in the very least, this + // is a formalization for deprecating enums. + Deprecated *bool `protobuf:"varint,3,opt,name=deprecated,def=0" json:"deprecated,omitempty"` + // Enable the legacy handling of JSON field name conflicts. This lowercases + // and strips underscored from the fields before comparison in proto3 only. + // The new behavior takes `json_name` into account and applies to proto2 as + // well. + // TODO Remove this legacy behavior once downstream teams have + // had time to migrate. + // + // Deprecated: Marked as deprecated in google/protobuf/descriptor.proto. + DeprecatedLegacyJsonFieldConflicts *bool `protobuf:"varint,6,opt,name=deprecated_legacy_json_field_conflicts,json=deprecatedLegacyJsonFieldConflicts" json:"deprecated_legacy_json_field_conflicts,omitempty"` + // Any features defined in the specific edition. + Features *FeatureSet `protobuf:"bytes,7,opt,name=features" json:"features,omitempty"` + // The parser stores options it doesn't recognize here. See above. + UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"` +} + +// Default values for EnumOptions fields. +const ( + Default_EnumOptions_Deprecated = bool(false) +) + +func (x *EnumOptions) Reset() { + *x = EnumOptions{} + if protoimpl.UnsafeEnabled { + mi := &file_google_protobuf_descriptor_proto_msgTypes[14] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *EnumOptions) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*EnumOptions) ProtoMessage() {} + +func (x *EnumOptions) ProtoReflect() protoreflect.Message { + mi := &file_google_protobuf_descriptor_proto_msgTypes[14] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use EnumOptions.ProtoReflect.Descriptor instead. +func (*EnumOptions) Descriptor() ([]byte, []int) { + return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{14} +} + +func (x *EnumOptions) GetAllowAlias() bool { + if x != nil && x.AllowAlias != nil { + return *x.AllowAlias + } + return false +} + +func (x *EnumOptions) GetDeprecated() bool { + if x != nil && x.Deprecated != nil { + return *x.Deprecated + } + return Default_EnumOptions_Deprecated +} + +// Deprecated: Marked as deprecated in google/protobuf/descriptor.proto. +func (x *EnumOptions) GetDeprecatedLegacyJsonFieldConflicts() bool { + if x != nil && x.DeprecatedLegacyJsonFieldConflicts != nil { + return *x.DeprecatedLegacyJsonFieldConflicts + } + return false +} + +func (x *EnumOptions) GetFeatures() *FeatureSet { + if x != nil { + return x.Features + } + return nil +} + +func (x *EnumOptions) GetUninterpretedOption() []*UninterpretedOption { + if x != nil { + return x.UninterpretedOption + } + return nil +} + +type EnumValueOptions struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + extensionFields protoimpl.ExtensionFields + + // Is this enum value deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for the enum value, or it will be completely ignored; in the very least, + // this is a formalization for deprecating enum values. + Deprecated *bool `protobuf:"varint,1,opt,name=deprecated,def=0" json:"deprecated,omitempty"` + // Any features defined in the specific edition. + Features *FeatureSet `protobuf:"bytes,2,opt,name=features" json:"features,omitempty"` + // Indicate that fields annotated with this enum value should not be printed + // out when using debug formats, e.g. when the field contains sensitive + // credentials. + DebugRedact *bool `protobuf:"varint,3,opt,name=debug_redact,json=debugRedact,def=0" json:"debug_redact,omitempty"` + // The parser stores options it doesn't recognize here. See above. + UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"` +} + +// Default values for EnumValueOptions fields. +const ( + Default_EnumValueOptions_Deprecated = bool(false) + Default_EnumValueOptions_DebugRedact = bool(false) +) + +func (x *EnumValueOptions) Reset() { + *x = EnumValueOptions{} + if protoimpl.UnsafeEnabled { + mi := &file_google_protobuf_descriptor_proto_msgTypes[15] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *EnumValueOptions) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*EnumValueOptions) ProtoMessage() {} + +func (x *EnumValueOptions) ProtoReflect() protoreflect.Message { + mi := &file_google_protobuf_descriptor_proto_msgTypes[15] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use EnumValueOptions.ProtoReflect.Descriptor instead. +func (*EnumValueOptions) Descriptor() ([]byte, []int) { + return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{15} +} + +func (x *EnumValueOptions) GetDeprecated() bool { + if x != nil && x.Deprecated != nil { + return *x.Deprecated + } + return Default_EnumValueOptions_Deprecated +} + +func (x *EnumValueOptions) GetFeatures() *FeatureSet { + if x != nil { + return x.Features + } + return nil +} + +func (x *EnumValueOptions) GetDebugRedact() bool { + if x != nil && x.DebugRedact != nil { + return *x.DebugRedact + } + return Default_EnumValueOptions_DebugRedact +} + +func (x *EnumValueOptions) GetUninterpretedOption() []*UninterpretedOption { + if x != nil { + return x.UninterpretedOption + } + return nil +} + +type ServiceOptions struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + extensionFields protoimpl.ExtensionFields + + // Any features defined in the specific edition. + Features *FeatureSet `protobuf:"bytes,34,opt,name=features" json:"features,omitempty"` + // Is this service deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for the service, or it will be completely ignored; in the very least, + // this is a formalization for deprecating services. + Deprecated *bool `protobuf:"varint,33,opt,name=deprecated,def=0" json:"deprecated,omitempty"` + // The parser stores options it doesn't recognize here. See above. + UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"` +} + +// Default values for ServiceOptions fields. +const ( + Default_ServiceOptions_Deprecated = bool(false) +) + +func (x *ServiceOptions) Reset() { + *x = ServiceOptions{} + if protoimpl.UnsafeEnabled { + mi := &file_google_protobuf_descriptor_proto_msgTypes[16] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ServiceOptions) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ServiceOptions) ProtoMessage() {} + +func (x *ServiceOptions) ProtoReflect() protoreflect.Message { + mi := &file_google_protobuf_descriptor_proto_msgTypes[16] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ServiceOptions.ProtoReflect.Descriptor instead. +func (*ServiceOptions) Descriptor() ([]byte, []int) { + return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{16} +} + +func (x *ServiceOptions) GetFeatures() *FeatureSet { + if x != nil { + return x.Features + } + return nil +} + +func (x *ServiceOptions) GetDeprecated() bool { + if x != nil && x.Deprecated != nil { + return *x.Deprecated + } + return Default_ServiceOptions_Deprecated +} + +func (x *ServiceOptions) GetUninterpretedOption() []*UninterpretedOption { + if x != nil { + return x.UninterpretedOption + } + return nil +} + +type MethodOptions struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + extensionFields protoimpl.ExtensionFields + + // Is this method deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for the method, or it will be completely ignored; in the very least, + // this is a formalization for deprecating methods. + Deprecated *bool `protobuf:"varint,33,opt,name=deprecated,def=0" json:"deprecated,omitempty"` + IdempotencyLevel *MethodOptions_IdempotencyLevel `protobuf:"varint,34,opt,name=idempotency_level,json=idempotencyLevel,enum=google.protobuf.MethodOptions_IdempotencyLevel,def=0" json:"idempotency_level,omitempty"` + // Any features defined in the specific edition. + Features *FeatureSet `protobuf:"bytes,35,opt,name=features" json:"features,omitempty"` + // The parser stores options it doesn't recognize here. See above. + UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"` +} + +// Default values for MethodOptions fields. +const ( + Default_MethodOptions_Deprecated = bool(false) + Default_MethodOptions_IdempotencyLevel = MethodOptions_IDEMPOTENCY_UNKNOWN +) + +func (x *MethodOptions) Reset() { + *x = MethodOptions{} + if protoimpl.UnsafeEnabled { + mi := &file_google_protobuf_descriptor_proto_msgTypes[17] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MethodOptions) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MethodOptions) ProtoMessage() {} + +func (x *MethodOptions) ProtoReflect() protoreflect.Message { + mi := &file_google_protobuf_descriptor_proto_msgTypes[17] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use MethodOptions.ProtoReflect.Descriptor instead. +func (*MethodOptions) Descriptor() ([]byte, []int) { + return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{17} +} + +func (x *MethodOptions) GetDeprecated() bool { + if x != nil && x.Deprecated != nil { + return *x.Deprecated + } + return Default_MethodOptions_Deprecated +} + +func (x *MethodOptions) GetIdempotencyLevel() MethodOptions_IdempotencyLevel { + if x != nil && x.IdempotencyLevel != nil { + return *x.IdempotencyLevel + } + return Default_MethodOptions_IdempotencyLevel +} + +func (x *MethodOptions) GetFeatures() *FeatureSet { + if x != nil { + return x.Features + } + return nil +} + +func (x *MethodOptions) GetUninterpretedOption() []*UninterpretedOption { + if x != nil { + return x.UninterpretedOption + } + return nil +} + +// A message representing a option the parser does not recognize. This only +// appears in options protos created by the compiler::Parser class. +// DescriptorPool resolves these when building Descriptor objects. Therefore, +// options protos in descriptor objects (e.g. returned by Descriptor::options(), +// or produced by Descriptor::CopyTo()) will never have UninterpretedOptions +// in them. +type UninterpretedOption struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Name []*UninterpretedOption_NamePart `protobuf:"bytes,2,rep,name=name" json:"name,omitempty"` + // The value of the uninterpreted option, in whatever type the tokenizer + // identified it as during parsing. Exactly one of these should be set. + IdentifierValue *string `protobuf:"bytes,3,opt,name=identifier_value,json=identifierValue" json:"identifier_value,omitempty"` + PositiveIntValue *uint64 `protobuf:"varint,4,opt,name=positive_int_value,json=positiveIntValue" json:"positive_int_value,omitempty"` + NegativeIntValue *int64 `protobuf:"varint,5,opt,name=negative_int_value,json=negativeIntValue" json:"negative_int_value,omitempty"` + DoubleValue *float64 `protobuf:"fixed64,6,opt,name=double_value,json=doubleValue" json:"double_value,omitempty"` + StringValue []byte `protobuf:"bytes,7,opt,name=string_value,json=stringValue" json:"string_value,omitempty"` + AggregateValue *string `protobuf:"bytes,8,opt,name=aggregate_value,json=aggregateValue" json:"aggregate_value,omitempty"` +} + +func (x *UninterpretedOption) Reset() { + *x = UninterpretedOption{} + if protoimpl.UnsafeEnabled { + mi := &file_google_protobuf_descriptor_proto_msgTypes[18] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *UninterpretedOption) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UninterpretedOption) ProtoMessage() {} + +func (x *UninterpretedOption) ProtoReflect() protoreflect.Message { + mi := &file_google_protobuf_descriptor_proto_msgTypes[18] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use UninterpretedOption.ProtoReflect.Descriptor instead. +func (*UninterpretedOption) Descriptor() ([]byte, []int) { + return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{18} +} + +func (x *UninterpretedOption) GetName() []*UninterpretedOption_NamePart { + if x != nil { + return x.Name + } + return nil +} + +func (x *UninterpretedOption) GetIdentifierValue() string { + if x != nil && x.IdentifierValue != nil { + return *x.IdentifierValue + } + return "" +} + +func (x *UninterpretedOption) GetPositiveIntValue() uint64 { + if x != nil && x.PositiveIntValue != nil { + return *x.PositiveIntValue + } + return 0 +} + +func (x *UninterpretedOption) GetNegativeIntValue() int64 { + if x != nil && x.NegativeIntValue != nil { + return *x.NegativeIntValue + } + return 0 +} + +func (x *UninterpretedOption) GetDoubleValue() float64 { + if x != nil && x.DoubleValue != nil { + return *x.DoubleValue + } + return 0 +} + +func (x *UninterpretedOption) GetStringValue() []byte { + if x != nil { + return x.StringValue + } + return nil +} + +func (x *UninterpretedOption) GetAggregateValue() string { + if x != nil && x.AggregateValue != nil { + return *x.AggregateValue + } + return "" +} + +// TODO Enums in C++ gencode (and potentially other languages) are +// not well scoped. This means that each of the feature enums below can clash +// with each other. The short names we've chosen maximize call-site +// readability, but leave us very open to this scenario. A future feature will +// be designed and implemented to handle this, hopefully before we ever hit a +// conflict here. +type FeatureSet struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + extensionFields protoimpl.ExtensionFields + + FieldPresence *FeatureSet_FieldPresence `protobuf:"varint,1,opt,name=field_presence,json=fieldPresence,enum=google.protobuf.FeatureSet_FieldPresence" json:"field_presence,omitempty"` + EnumType *FeatureSet_EnumType `protobuf:"varint,2,opt,name=enum_type,json=enumType,enum=google.protobuf.FeatureSet_EnumType" json:"enum_type,omitempty"` + RepeatedFieldEncoding *FeatureSet_RepeatedFieldEncoding `protobuf:"varint,3,opt,name=repeated_field_encoding,json=repeatedFieldEncoding,enum=google.protobuf.FeatureSet_RepeatedFieldEncoding" json:"repeated_field_encoding,omitempty"` + Utf8Validation *FeatureSet_Utf8Validation `protobuf:"varint,4,opt,name=utf8_validation,json=utf8Validation,enum=google.protobuf.FeatureSet_Utf8Validation" json:"utf8_validation,omitempty"` + MessageEncoding *FeatureSet_MessageEncoding `protobuf:"varint,5,opt,name=message_encoding,json=messageEncoding,enum=google.protobuf.FeatureSet_MessageEncoding" json:"message_encoding,omitempty"` + JsonFormat *FeatureSet_JsonFormat `protobuf:"varint,6,opt,name=json_format,json=jsonFormat,enum=google.protobuf.FeatureSet_JsonFormat" json:"json_format,omitempty"` +} + +func (x *FeatureSet) Reset() { + *x = FeatureSet{} + if protoimpl.UnsafeEnabled { + mi := &file_google_protobuf_descriptor_proto_msgTypes[19] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *FeatureSet) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FeatureSet) ProtoMessage() {} + +func (x *FeatureSet) ProtoReflect() protoreflect.Message { + mi := &file_google_protobuf_descriptor_proto_msgTypes[19] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use FeatureSet.ProtoReflect.Descriptor instead. +func (*FeatureSet) Descriptor() ([]byte, []int) { + return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{19} +} + +func (x *FeatureSet) GetFieldPresence() FeatureSet_FieldPresence { + if x != nil && x.FieldPresence != nil { + return *x.FieldPresence + } + return FeatureSet_FIELD_PRESENCE_UNKNOWN +} + +func (x *FeatureSet) GetEnumType() FeatureSet_EnumType { + if x != nil && x.EnumType != nil { + return *x.EnumType + } + return FeatureSet_ENUM_TYPE_UNKNOWN +} + +func (x *FeatureSet) GetRepeatedFieldEncoding() FeatureSet_RepeatedFieldEncoding { + if x != nil && x.RepeatedFieldEncoding != nil { + return *x.RepeatedFieldEncoding + } + return FeatureSet_REPEATED_FIELD_ENCODING_UNKNOWN +} + +func (x *FeatureSet) GetUtf8Validation() FeatureSet_Utf8Validation { + if x != nil && x.Utf8Validation != nil { + return *x.Utf8Validation + } + return FeatureSet_UTF8_VALIDATION_UNKNOWN +} + +func (x *FeatureSet) GetMessageEncoding() FeatureSet_MessageEncoding { + if x != nil && x.MessageEncoding != nil { + return *x.MessageEncoding + } + return FeatureSet_MESSAGE_ENCODING_UNKNOWN +} + +func (x *FeatureSet) GetJsonFormat() FeatureSet_JsonFormat { + if x != nil && x.JsonFormat != nil { + return *x.JsonFormat + } + return FeatureSet_JSON_FORMAT_UNKNOWN +} + +// A compiled specification for the defaults of a set of features. These +// messages are generated from FeatureSet extensions and can be used to seed +// feature resolution. The resolution with this object becomes a simple search +// for the closest matching edition, followed by proto merges. +type FeatureSetDefaults struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Defaults []*FeatureSetDefaults_FeatureSetEditionDefault `protobuf:"bytes,1,rep,name=defaults" json:"defaults,omitempty"` + // The minimum supported edition (inclusive) when this was constructed. + // Editions before this will not have defaults. + MinimumEdition *Edition `protobuf:"varint,4,opt,name=minimum_edition,json=minimumEdition,enum=google.protobuf.Edition" json:"minimum_edition,omitempty"` + // The maximum known edition (inclusive) when this was constructed. Editions + // after this will not have reliable defaults. + MaximumEdition *Edition `protobuf:"varint,5,opt,name=maximum_edition,json=maximumEdition,enum=google.protobuf.Edition" json:"maximum_edition,omitempty"` +} + +func (x *FeatureSetDefaults) Reset() { + *x = FeatureSetDefaults{} + if protoimpl.UnsafeEnabled { + mi := &file_google_protobuf_descriptor_proto_msgTypes[20] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *FeatureSetDefaults) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FeatureSetDefaults) ProtoMessage() {} + +func (x *FeatureSetDefaults) ProtoReflect() protoreflect.Message { + mi := &file_google_protobuf_descriptor_proto_msgTypes[20] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use FeatureSetDefaults.ProtoReflect.Descriptor instead. +func (*FeatureSetDefaults) Descriptor() ([]byte, []int) { + return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{20} +} + +func (x *FeatureSetDefaults) GetDefaults() []*FeatureSetDefaults_FeatureSetEditionDefault { + if x != nil { + return x.Defaults + } + return nil +} + +func (x *FeatureSetDefaults) GetMinimumEdition() Edition { + if x != nil && x.MinimumEdition != nil { + return *x.MinimumEdition + } + return Edition_EDITION_UNKNOWN +} + +func (x *FeatureSetDefaults) GetMaximumEdition() Edition { + if x != nil && x.MaximumEdition != nil { + return *x.MaximumEdition + } + return Edition_EDITION_UNKNOWN +} + +// Encapsulates information about the original source file from which a +// FileDescriptorProto was generated. +type SourceCodeInfo struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // A Location identifies a piece of source code in a .proto file which + // corresponds to a particular definition. This information is intended + // to be useful to IDEs, code indexers, documentation generators, and similar + // tools. + // + // For example, say we have a file like: + // + // message Foo { + // optional string foo = 1; + // } + // + // Let's look at just the field definition: + // + // optional string foo = 1; + // ^ ^^ ^^ ^ ^^^ + // a bc de f ghi + // + // We have the following locations: + // + // span path represents + // [a,i) [ 4, 0, 2, 0 ] The whole field definition. + // [a,b) [ 4, 0, 2, 0, 4 ] The label (optional). + // [c,d) [ 4, 0, 2, 0, 5 ] The type (string). + // [e,f) [ 4, 0, 2, 0, 1 ] The name (foo). + // [g,h) [ 4, 0, 2, 0, 3 ] The number (1). + // + // Notes: + // - A location may refer to a repeated field itself (i.e. not to any + // particular index within it). This is used whenever a set of elements are + // logically enclosed in a single code segment. For example, an entire + // extend block (possibly containing multiple extension definitions) will + // have an outer location whose path refers to the "extensions" repeated + // field without an index. + // - Multiple locations may have the same path. This happens when a single + // logical declaration is spread out across multiple places. The most + // obvious example is the "extend" block again -- there may be multiple + // extend blocks in the same scope, each of which will have the same path. + // - A location's span is not always a subset of its parent's span. For + // example, the "extendee" of an extension declaration appears at the + // beginning of the "extend" block and is shared by all extensions within + // the block. + // - Just because a location's span is a subset of some other location's span + // does not mean that it is a descendant. For example, a "group" defines + // both a type and a field in a single declaration. Thus, the locations + // corresponding to the type and field and their components will overlap. + // - Code which tries to interpret locations should probably be designed to + // ignore those that it doesn't understand, as more types of locations could + // be recorded in the future. + Location []*SourceCodeInfo_Location `protobuf:"bytes,1,rep,name=location" json:"location,omitempty"` +} + +func (x *SourceCodeInfo) Reset() { + *x = SourceCodeInfo{} + if protoimpl.UnsafeEnabled { + mi := &file_google_protobuf_descriptor_proto_msgTypes[21] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SourceCodeInfo) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SourceCodeInfo) ProtoMessage() {} + +func (x *SourceCodeInfo) ProtoReflect() protoreflect.Message { + mi := &file_google_protobuf_descriptor_proto_msgTypes[21] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SourceCodeInfo.ProtoReflect.Descriptor instead. +func (*SourceCodeInfo) Descriptor() ([]byte, []int) { + return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{21} +} + +func (x *SourceCodeInfo) GetLocation() []*SourceCodeInfo_Location { + if x != nil { + return x.Location + } + return nil +} + +// Describes the relationship between generated code and its original source +// file. A GeneratedCodeInfo message is associated with only one generated +// source file, but may contain references to different source .proto files. +type GeneratedCodeInfo struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // An Annotation connects some span of text in generated code to an element + // of its generating .proto file. + Annotation []*GeneratedCodeInfo_Annotation `protobuf:"bytes,1,rep,name=annotation" json:"annotation,omitempty"` +} + +func (x *GeneratedCodeInfo) Reset() { + *x = GeneratedCodeInfo{} + if protoimpl.UnsafeEnabled { + mi := &file_google_protobuf_descriptor_proto_msgTypes[22] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GeneratedCodeInfo) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GeneratedCodeInfo) ProtoMessage() {} + +func (x *GeneratedCodeInfo) ProtoReflect() protoreflect.Message { + mi := &file_google_protobuf_descriptor_proto_msgTypes[22] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GeneratedCodeInfo.ProtoReflect.Descriptor instead. +func (*GeneratedCodeInfo) Descriptor() ([]byte, []int) { + return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{22} +} + +func (x *GeneratedCodeInfo) GetAnnotation() []*GeneratedCodeInfo_Annotation { + if x != nil { + return x.Annotation + } + return nil +} + +type DescriptorProto_ExtensionRange struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Start *int32 `protobuf:"varint,1,opt,name=start" json:"start,omitempty"` // Inclusive. + End *int32 `protobuf:"varint,2,opt,name=end" json:"end,omitempty"` // Exclusive. + Options *ExtensionRangeOptions `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"` +} + +func (x *DescriptorProto_ExtensionRange) Reset() { + *x = DescriptorProto_ExtensionRange{} + if protoimpl.UnsafeEnabled { + mi := &file_google_protobuf_descriptor_proto_msgTypes[23] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DescriptorProto_ExtensionRange) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DescriptorProto_ExtensionRange) ProtoMessage() {} + +func (x *DescriptorProto_ExtensionRange) ProtoReflect() protoreflect.Message { + mi := &file_google_protobuf_descriptor_proto_msgTypes[23] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DescriptorProto_ExtensionRange.ProtoReflect.Descriptor instead. +func (*DescriptorProto_ExtensionRange) Descriptor() ([]byte, []int) { + return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{2, 0} +} + +func (x *DescriptorProto_ExtensionRange) GetStart() int32 { + if x != nil && x.Start != nil { + return *x.Start + } + return 0 +} + +func (x *DescriptorProto_ExtensionRange) GetEnd() int32 { + if x != nil && x.End != nil { + return *x.End + } + return 0 +} + +func (x *DescriptorProto_ExtensionRange) GetOptions() *ExtensionRangeOptions { + if x != nil { + return x.Options + } + return nil +} + +// Range of reserved tag numbers. Reserved tag numbers may not be used by +// fields or extension ranges in the same message. Reserved ranges may +// not overlap. +type DescriptorProto_ReservedRange struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Start *int32 `protobuf:"varint,1,opt,name=start" json:"start,omitempty"` // Inclusive. + End *int32 `protobuf:"varint,2,opt,name=end" json:"end,omitempty"` // Exclusive. +} + +func (x *DescriptorProto_ReservedRange) Reset() { + *x = DescriptorProto_ReservedRange{} + if protoimpl.UnsafeEnabled { + mi := &file_google_protobuf_descriptor_proto_msgTypes[24] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DescriptorProto_ReservedRange) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DescriptorProto_ReservedRange) ProtoMessage() {} + +func (x *DescriptorProto_ReservedRange) ProtoReflect() protoreflect.Message { + mi := &file_google_protobuf_descriptor_proto_msgTypes[24] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DescriptorProto_ReservedRange.ProtoReflect.Descriptor instead. +func (*DescriptorProto_ReservedRange) Descriptor() ([]byte, []int) { + return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{2, 1} +} + +func (x *DescriptorProto_ReservedRange) GetStart() int32 { + if x != nil && x.Start != nil { + return *x.Start + } + return 0 +} + +func (x *DescriptorProto_ReservedRange) GetEnd() int32 { + if x != nil && x.End != nil { + return *x.End + } + return 0 +} + +type ExtensionRangeOptions_Declaration struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The extension number declared within the extension range. + Number *int32 `protobuf:"varint,1,opt,name=number" json:"number,omitempty"` + // The fully-qualified name of the extension field. There must be a leading + // dot in front of the full name. + FullName *string `protobuf:"bytes,2,opt,name=full_name,json=fullName" json:"full_name,omitempty"` + // The fully-qualified type name of the extension field. Unlike + // Metadata.type, Declaration.type must have a leading dot for messages + // and enums. + Type *string `protobuf:"bytes,3,opt,name=type" json:"type,omitempty"` + // If true, indicates that the number is reserved in the extension range, + // and any extension field with the number will fail to compile. Set this + // when a declared extension field is deleted. + Reserved *bool `protobuf:"varint,5,opt,name=reserved" json:"reserved,omitempty"` + // If true, indicates that the extension must be defined as repeated. + // Otherwise the extension must be defined as optional. + Repeated *bool `protobuf:"varint,6,opt,name=repeated" json:"repeated,omitempty"` +} + +func (x *ExtensionRangeOptions_Declaration) Reset() { + *x = ExtensionRangeOptions_Declaration{} + if protoimpl.UnsafeEnabled { + mi := &file_google_protobuf_descriptor_proto_msgTypes[25] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ExtensionRangeOptions_Declaration) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ExtensionRangeOptions_Declaration) ProtoMessage() {} + +func (x *ExtensionRangeOptions_Declaration) ProtoReflect() protoreflect.Message { + mi := &file_google_protobuf_descriptor_proto_msgTypes[25] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ExtensionRangeOptions_Declaration.ProtoReflect.Descriptor instead. +func (*ExtensionRangeOptions_Declaration) Descriptor() ([]byte, []int) { + return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{3, 0} +} + +func (x *ExtensionRangeOptions_Declaration) GetNumber() int32 { + if x != nil && x.Number != nil { + return *x.Number + } + return 0 +} + +func (x *ExtensionRangeOptions_Declaration) GetFullName() string { + if x != nil && x.FullName != nil { + return *x.FullName + } + return "" +} + +func (x *ExtensionRangeOptions_Declaration) GetType() string { + if x != nil && x.Type != nil { + return *x.Type + } + return "" +} + +func (x *ExtensionRangeOptions_Declaration) GetReserved() bool { + if x != nil && x.Reserved != nil { + return *x.Reserved + } + return false +} + +func (x *ExtensionRangeOptions_Declaration) GetRepeated() bool { + if x != nil && x.Repeated != nil { + return *x.Repeated + } + return false +} + +// Range of reserved numeric values. Reserved values may not be used by +// entries in the same enum. Reserved ranges may not overlap. +// +// Note that this is distinct from DescriptorProto.ReservedRange in that it +// is inclusive such that it can appropriately represent the entire int32 +// domain. +type EnumDescriptorProto_EnumReservedRange struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Start *int32 `protobuf:"varint,1,opt,name=start" json:"start,omitempty"` // Inclusive. + End *int32 `protobuf:"varint,2,opt,name=end" json:"end,omitempty"` // Inclusive. +} + +func (x *EnumDescriptorProto_EnumReservedRange) Reset() { + *x = EnumDescriptorProto_EnumReservedRange{} + if protoimpl.UnsafeEnabled { + mi := &file_google_protobuf_descriptor_proto_msgTypes[26] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *EnumDescriptorProto_EnumReservedRange) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*EnumDescriptorProto_EnumReservedRange) ProtoMessage() {} + +func (x *EnumDescriptorProto_EnumReservedRange) ProtoReflect() protoreflect.Message { + mi := &file_google_protobuf_descriptor_proto_msgTypes[26] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use EnumDescriptorProto_EnumReservedRange.ProtoReflect.Descriptor instead. +func (*EnumDescriptorProto_EnumReservedRange) Descriptor() ([]byte, []int) { + return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{6, 0} +} + +func (x *EnumDescriptorProto_EnumReservedRange) GetStart() int32 { + if x != nil && x.Start != nil { + return *x.Start + } + return 0 +} + +func (x *EnumDescriptorProto_EnumReservedRange) GetEnd() int32 { + if x != nil && x.End != nil { + return *x.End + } + return 0 +} + +type FieldOptions_EditionDefault struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Edition *Edition `protobuf:"varint,3,opt,name=edition,enum=google.protobuf.Edition" json:"edition,omitempty"` + Value *string `protobuf:"bytes,2,opt,name=value" json:"value,omitempty"` // Textproto value. +} + +func (x *FieldOptions_EditionDefault) Reset() { + *x = FieldOptions_EditionDefault{} + if protoimpl.UnsafeEnabled { + mi := &file_google_protobuf_descriptor_proto_msgTypes[27] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *FieldOptions_EditionDefault) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FieldOptions_EditionDefault) ProtoMessage() {} + +func (x *FieldOptions_EditionDefault) ProtoReflect() protoreflect.Message { + mi := &file_google_protobuf_descriptor_proto_msgTypes[27] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use FieldOptions_EditionDefault.ProtoReflect.Descriptor instead. +func (*FieldOptions_EditionDefault) Descriptor() ([]byte, []int) { + return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{12, 0} +} + +func (x *FieldOptions_EditionDefault) GetEdition() Edition { + if x != nil && x.Edition != nil { + return *x.Edition + } + return Edition_EDITION_UNKNOWN +} + +func (x *FieldOptions_EditionDefault) GetValue() string { + if x != nil && x.Value != nil { + return *x.Value + } + return "" +} + +// The name of the uninterpreted option. Each string represents a segment in +// a dot-separated name. is_extension is true iff a segment represents an +// extension (denoted with parentheses in options specs in .proto files). +// E.g.,{ ["foo", false], ["bar.baz", true], ["moo", false] } represents +// "foo.(bar.baz).moo". +type UninterpretedOption_NamePart struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + NamePart *string `protobuf:"bytes,1,req,name=name_part,json=namePart" json:"name_part,omitempty"` + IsExtension *bool `protobuf:"varint,2,req,name=is_extension,json=isExtension" json:"is_extension,omitempty"` +} + +func (x *UninterpretedOption_NamePart) Reset() { + *x = UninterpretedOption_NamePart{} + if protoimpl.UnsafeEnabled { + mi := &file_google_protobuf_descriptor_proto_msgTypes[28] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *UninterpretedOption_NamePart) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UninterpretedOption_NamePart) ProtoMessage() {} + +func (x *UninterpretedOption_NamePart) ProtoReflect() protoreflect.Message { + mi := &file_google_protobuf_descriptor_proto_msgTypes[28] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use UninterpretedOption_NamePart.ProtoReflect.Descriptor instead. +func (*UninterpretedOption_NamePart) Descriptor() ([]byte, []int) { + return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{18, 0} +} + +func (x *UninterpretedOption_NamePart) GetNamePart() string { + if x != nil && x.NamePart != nil { + return *x.NamePart + } + return "" +} + +func (x *UninterpretedOption_NamePart) GetIsExtension() bool { + if x != nil && x.IsExtension != nil { + return *x.IsExtension + } + return false +} + +// A map from every known edition with a unique set of defaults to its +// defaults. Not all editions may be contained here. For a given edition, +// the defaults at the closest matching edition ordered at or before it should +// be used. This field must be in strict ascending order by edition. +type FeatureSetDefaults_FeatureSetEditionDefault struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Edition *Edition `protobuf:"varint,3,opt,name=edition,enum=google.protobuf.Edition" json:"edition,omitempty"` + Features *FeatureSet `protobuf:"bytes,2,opt,name=features" json:"features,omitempty"` +} + +func (x *FeatureSetDefaults_FeatureSetEditionDefault) Reset() { + *x = FeatureSetDefaults_FeatureSetEditionDefault{} + if protoimpl.UnsafeEnabled { + mi := &file_google_protobuf_descriptor_proto_msgTypes[29] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *FeatureSetDefaults_FeatureSetEditionDefault) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FeatureSetDefaults_FeatureSetEditionDefault) ProtoMessage() {} + +func (x *FeatureSetDefaults_FeatureSetEditionDefault) ProtoReflect() protoreflect.Message { + mi := &file_google_protobuf_descriptor_proto_msgTypes[29] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use FeatureSetDefaults_FeatureSetEditionDefault.ProtoReflect.Descriptor instead. +func (*FeatureSetDefaults_FeatureSetEditionDefault) Descriptor() ([]byte, []int) { + return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{20, 0} +} + +func (x *FeatureSetDefaults_FeatureSetEditionDefault) GetEdition() Edition { + if x != nil && x.Edition != nil { + return *x.Edition + } + return Edition_EDITION_UNKNOWN +} + +func (x *FeatureSetDefaults_FeatureSetEditionDefault) GetFeatures() *FeatureSet { + if x != nil { + return x.Features + } + return nil +} + +type SourceCodeInfo_Location struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Identifies which part of the FileDescriptorProto was defined at this + // location. + // + // Each element is a field number or an index. They form a path from + // the root FileDescriptorProto to the place where the definition appears. + // For example, this path: + // + // [ 4, 3, 2, 7, 1 ] + // + // refers to: + // + // file.message_type(3) // 4, 3 + // .field(7) // 2, 7 + // .name() // 1 + // + // This is because FileDescriptorProto.message_type has field number 4: + // + // repeated DescriptorProto message_type = 4; + // + // and DescriptorProto.field has field number 2: + // + // repeated FieldDescriptorProto field = 2; + // + // and FieldDescriptorProto.name has field number 1: + // + // optional string name = 1; + // + // Thus, the above path gives the location of a field name. If we removed + // the last element: + // + // [ 4, 3, 2, 7 ] + // + // this path refers to the whole field declaration (from the beginning + // of the label to the terminating semicolon). + Path []int32 `protobuf:"varint,1,rep,packed,name=path" json:"path,omitempty"` + // Always has exactly three or four elements: start line, start column, + // end line (optional, otherwise assumed same as start line), end column. + // These are packed into a single field for efficiency. Note that line + // and column numbers are zero-based -- typically you will want to add + // 1 to each before displaying to a user. + Span []int32 `protobuf:"varint,2,rep,packed,name=span" json:"span,omitempty"` + // If this SourceCodeInfo represents a complete declaration, these are any + // comments appearing before and after the declaration which appear to be + // attached to the declaration. + // + // A series of line comments appearing on consecutive lines, with no other + // tokens appearing on those lines, will be treated as a single comment. + // + // leading_detached_comments will keep paragraphs of comments that appear + // before (but not connected to) the current element. Each paragraph, + // separated by empty lines, will be one comment element in the repeated + // field. + // + // Only the comment content is provided; comment markers (e.g. //) are + // stripped out. For block comments, leading whitespace and an asterisk + // will be stripped from the beginning of each line other than the first. + // Newlines are included in the output. + // + // Examples: + // + // optional int32 foo = 1; // Comment attached to foo. + // // Comment attached to bar. + // optional int32 bar = 2; + // + // optional string baz = 3; + // // Comment attached to baz. + // // Another line attached to baz. + // + // // Comment attached to moo. + // // + // // Another line attached to moo. + // optional double moo = 4; + // + // // Detached comment for corge. This is not leading or trailing comments + // // to moo or corge because there are blank lines separating it from + // // both. + // + // // Detached comment for corge paragraph 2. + // + // optional string corge = 5; + // /* Block comment attached + // * to corge. Leading asterisks + // * will be removed. */ + // /* Block comment attached to + // * grault. */ + // optional int32 grault = 6; + // + // // ignored detached comments. + LeadingComments *string `protobuf:"bytes,3,opt,name=leading_comments,json=leadingComments" json:"leading_comments,omitempty"` + TrailingComments *string `protobuf:"bytes,4,opt,name=trailing_comments,json=trailingComments" json:"trailing_comments,omitempty"` + LeadingDetachedComments []string `protobuf:"bytes,6,rep,name=leading_detached_comments,json=leadingDetachedComments" json:"leading_detached_comments,omitempty"` +} + +func (x *SourceCodeInfo_Location) Reset() { + *x = SourceCodeInfo_Location{} + if protoimpl.UnsafeEnabled { + mi := &file_google_protobuf_descriptor_proto_msgTypes[30] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SourceCodeInfo_Location) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SourceCodeInfo_Location) ProtoMessage() {} + +func (x *SourceCodeInfo_Location) ProtoReflect() protoreflect.Message { + mi := &file_google_protobuf_descriptor_proto_msgTypes[30] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SourceCodeInfo_Location.ProtoReflect.Descriptor instead. +func (*SourceCodeInfo_Location) Descriptor() ([]byte, []int) { + return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{21, 0} +} + +func (x *SourceCodeInfo_Location) GetPath() []int32 { + if x != nil { + return x.Path + } + return nil +} + +func (x *SourceCodeInfo_Location) GetSpan() []int32 { + if x != nil { + return x.Span + } + return nil +} + +func (x *SourceCodeInfo_Location) GetLeadingComments() string { + if x != nil && x.LeadingComments != nil { + return *x.LeadingComments + } + return "" +} + +func (x *SourceCodeInfo_Location) GetTrailingComments() string { + if x != nil && x.TrailingComments != nil { + return *x.TrailingComments + } + return "" +} + +func (x *SourceCodeInfo_Location) GetLeadingDetachedComments() []string { + if x != nil { + return x.LeadingDetachedComments + } + return nil +} + +type GeneratedCodeInfo_Annotation struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Identifies the element in the original source .proto file. This field + // is formatted the same as SourceCodeInfo.Location.path. + Path []int32 `protobuf:"varint,1,rep,packed,name=path" json:"path,omitempty"` + // Identifies the filesystem path to the original source .proto. + SourceFile *string `protobuf:"bytes,2,opt,name=source_file,json=sourceFile" json:"source_file,omitempty"` + // Identifies the starting offset in bytes in the generated code + // that relates to the identified object. + Begin *int32 `protobuf:"varint,3,opt,name=begin" json:"begin,omitempty"` + // Identifies the ending offset in bytes in the generated code that + // relates to the identified object. The end offset should be one past + // the last relevant byte (so the length of the text = end - begin). + End *int32 `protobuf:"varint,4,opt,name=end" json:"end,omitempty"` + Semantic *GeneratedCodeInfo_Annotation_Semantic `protobuf:"varint,5,opt,name=semantic,enum=google.protobuf.GeneratedCodeInfo_Annotation_Semantic" json:"semantic,omitempty"` +} + +func (x *GeneratedCodeInfo_Annotation) Reset() { + *x = GeneratedCodeInfo_Annotation{} + if protoimpl.UnsafeEnabled { + mi := &file_google_protobuf_descriptor_proto_msgTypes[31] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GeneratedCodeInfo_Annotation) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GeneratedCodeInfo_Annotation) ProtoMessage() {} + +func (x *GeneratedCodeInfo_Annotation) ProtoReflect() protoreflect.Message { + mi := &file_google_protobuf_descriptor_proto_msgTypes[31] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GeneratedCodeInfo_Annotation.ProtoReflect.Descriptor instead. +func (*GeneratedCodeInfo_Annotation) Descriptor() ([]byte, []int) { + return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{22, 0} +} + +func (x *GeneratedCodeInfo_Annotation) GetPath() []int32 { + if x != nil { + return x.Path + } + return nil +} + +func (x *GeneratedCodeInfo_Annotation) GetSourceFile() string { + if x != nil && x.SourceFile != nil { + return *x.SourceFile + } + return "" +} + +func (x *GeneratedCodeInfo_Annotation) GetBegin() int32 { + if x != nil && x.Begin != nil { + return *x.Begin + } + return 0 +} + +func (x *GeneratedCodeInfo_Annotation) GetEnd() int32 { + if x != nil && x.End != nil { + return *x.End + } + return 0 +} + +func (x *GeneratedCodeInfo_Annotation) GetSemantic() GeneratedCodeInfo_Annotation_Semantic { + if x != nil && x.Semantic != nil { + return *x.Semantic + } + return GeneratedCodeInfo_Annotation_NONE +} + +var File_google_protobuf_descriptor_proto protoreflect.FileDescriptor + +var file_google_protobuf_descriptor_proto_rawDesc = []byte{ + 0x0a, 0x20, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, + 0x66, 0x2f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x12, 0x0f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x62, 0x75, 0x66, 0x22, 0x4d, 0x0a, 0x11, 0x46, 0x69, 0x6c, 0x65, 0x44, 0x65, 0x73, 0x63, 0x72, + 0x69, 0x70, 0x74, 0x6f, 0x72, 0x53, 0x65, 0x74, 0x12, 0x38, 0x0a, 0x04, 0x66, 0x69, 0x6c, 0x65, + 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x6c, 0x65, 0x44, 0x65, 0x73, + 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x52, 0x04, 0x66, 0x69, + 0x6c, 0x65, 0x22, 0x98, 0x05, 0x0a, 0x13, 0x46, 0x69, 0x6c, 0x65, 0x44, 0x65, 0x73, 0x63, 0x72, + 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, + 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x18, + 0x0a, 0x07, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x07, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x12, 0x1e, 0x0a, 0x0a, 0x64, 0x65, 0x70, 0x65, + 0x6e, 0x64, 0x65, 0x6e, 0x63, 0x79, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x64, 0x65, + 0x70, 0x65, 0x6e, 0x64, 0x65, 0x6e, 0x63, 0x79, 0x12, 0x2b, 0x0a, 0x11, 0x70, 0x75, 0x62, 0x6c, + 0x69, 0x63, 0x5f, 0x64, 0x65, 0x70, 0x65, 0x6e, 0x64, 0x65, 0x6e, 0x63, 0x79, 0x18, 0x0a, 0x20, + 0x03, 0x28, 0x05, 0x52, 0x10, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x44, 0x65, 0x70, 0x65, 0x6e, + 0x64, 0x65, 0x6e, 0x63, 0x79, 0x12, 0x27, 0x0a, 0x0f, 0x77, 0x65, 0x61, 0x6b, 0x5f, 0x64, 0x65, + 0x70, 0x65, 0x6e, 0x64, 0x65, 0x6e, 0x63, 0x79, 0x18, 0x0b, 0x20, 0x03, 0x28, 0x05, 0x52, 0x0e, + 0x77, 0x65, 0x61, 0x6b, 0x44, 0x65, 0x70, 0x65, 0x6e, 0x64, 0x65, 0x6e, 0x63, 0x79, 0x12, 0x43, + 0x0a, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x04, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, + 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x52, 0x0b, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, + 0x79, 0x70, 0x65, 0x12, 0x41, 0x0a, 0x09, 0x65, 0x6e, 0x75, 0x6d, 0x5f, 0x74, 0x79, 0x70, 0x65, + 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x44, 0x65, 0x73, + 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x52, 0x08, 0x65, 0x6e, + 0x75, 0x6d, 0x54, 0x79, 0x70, 0x65, 0x12, 0x41, 0x0a, 0x07, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, + 0x65, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, + 0x65, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, + 0x52, 0x07, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x43, 0x0a, 0x09, 0x65, 0x78, 0x74, + 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x67, + 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, + 0x69, 0x65, 0x6c, 0x64, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, + 0x6f, 0x74, 0x6f, 0x52, 0x09, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x36, + 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1c, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, + 0x66, 0x2e, 0x46, 0x69, 0x6c, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x07, 0x6f, + 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x49, 0x0a, 0x10, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x5f, 0x63, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, + 0x75, 0x66, 0x2e, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x43, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, + 0x6f, 0x52, 0x0e, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x43, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, + 0x6f, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x18, 0x0c, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x06, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x12, 0x32, 0x0a, 0x07, 0x65, 0x64, 0x69, + 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x18, 0x2e, 0x67, 0x6f, 0x6f, + 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x64, 0x69, + 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x07, 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xb9, 0x06, + 0x0a, 0x0f, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, + 0x6f, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x3b, 0x0a, 0x05, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x02, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44, 0x65, 0x73, 0x63, + 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x52, 0x05, 0x66, 0x69, 0x65, + 0x6c, 0x64, 0x12, 0x43, 0x0a, 0x09, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x18, + 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44, 0x65, 0x73, + 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x52, 0x09, 0x65, 0x78, + 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x41, 0x0a, 0x0b, 0x6e, 0x65, 0x73, 0x74, 0x65, + 0x64, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x67, + 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, + 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x52, 0x0a, + 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x54, 0x79, 0x70, 0x65, 0x12, 0x41, 0x0a, 0x09, 0x65, 0x6e, + 0x75, 0x6d, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, + 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, + 0x45, 0x6e, 0x75, 0x6d, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, + 0x6f, 0x74, 0x6f, 0x52, 0x08, 0x65, 0x6e, 0x75, 0x6d, 0x54, 0x79, 0x70, 0x65, 0x12, 0x58, 0x0a, + 0x0f, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x72, 0x61, 0x6e, 0x67, 0x65, + 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, + 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, + 0x6f, 0x6e, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x52, 0x0e, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, + 0x6f, 0x6e, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x44, 0x0a, 0x0a, 0x6f, 0x6e, 0x65, 0x6f, 0x66, + 0x5f, 0x64, 0x65, 0x63, 0x6c, 0x18, 0x08, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x67, 0x6f, + 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4f, 0x6e, + 0x65, 0x6f, 0x66, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, + 0x74, 0x6f, 0x52, 0x09, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x44, 0x65, 0x63, 0x6c, 0x12, 0x39, 0x0a, + 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, + 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, + 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, + 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x55, 0x0a, 0x0e, 0x72, 0x65, 0x73, 0x65, + 0x72, 0x76, 0x65, 0x64, 0x5f, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x09, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x2e, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, + 0x75, 0x66, 0x2e, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, + 0x74, 0x6f, 0x2e, 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x52, 0x61, 0x6e, 0x67, 0x65, + 0x52, 0x0d, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x12, + 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x5f, 0x6e, 0x61, 0x6d, 0x65, + 0x18, 0x0a, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0c, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, + 0x4e, 0x61, 0x6d, 0x65, 0x1a, 0x7a, 0x0a, 0x0e, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, + 0x6e, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0x12, 0x10, 0x0a, 0x03, + 0x65, 0x6e, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x65, 0x6e, 0x64, 0x12, 0x40, + 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x26, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, + 0x66, 0x2e, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x61, 0x6e, 0x67, 0x65, + 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, + 0x1a, 0x37, 0x0a, 0x0d, 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x52, 0x61, 0x6e, 0x67, + 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, + 0x52, 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x65, 0x6e, 0x64, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x65, 0x6e, 0x64, 0x22, 0xcc, 0x04, 0x0a, 0x15, 0x45, 0x78, + 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, + 0x6f, 0x6e, 0x73, 0x12, 0x58, 0x0a, 0x14, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, + 0x65, 0x74, 0x65, 0x64, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0xe7, 0x07, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x55, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, + 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x13, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, + 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x59, 0x0a, + 0x0b, 0x64, 0x65, 0x63, 0x6c, 0x61, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x32, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x61, + 0x6e, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x44, 0x65, 0x63, 0x6c, 0x61, + 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x03, 0x88, 0x01, 0x02, 0x52, 0x0b, 0x64, 0x65, 0x63, + 0x6c, 0x61, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x37, 0x0a, 0x08, 0x66, 0x65, 0x61, 0x74, + 0x75, 0x72, 0x65, 0x73, 0x18, 0x32, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x67, 0x6f, 0x6f, + 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x65, 0x61, + 0x74, 0x75, 0x72, 0x65, 0x53, 0x65, 0x74, 0x52, 0x08, 0x66, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, + 0x73, 0x12, 0x6d, 0x0a, 0x0c, 0x76, 0x65, 0x72, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x38, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, + 0x69, 0x6f, 0x6e, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, + 0x56, 0x65, 0x72, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, + 0x65, 0x3a, 0x0a, 0x55, 0x4e, 0x56, 0x45, 0x52, 0x49, 0x46, 0x49, 0x45, 0x44, 0x42, 0x03, 0x88, + 0x01, 0x02, 0x52, 0x0c, 0x76, 0x65, 0x72, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x1a, 0x94, 0x01, 0x0a, 0x0b, 0x44, 0x65, 0x63, 0x6c, 0x61, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x12, 0x16, 0x0a, 0x06, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, + 0x52, 0x06, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x12, 0x1b, 0x0a, 0x09, 0x66, 0x75, 0x6c, 0x6c, + 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x66, 0x75, 0x6c, + 0x6c, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x72, 0x65, 0x73, + 0x65, 0x72, 0x76, 0x65, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x72, 0x65, 0x73, + 0x65, 0x72, 0x76, 0x65, 0x64, 0x12, 0x1a, 0x0a, 0x08, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, + 0x64, 0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, + 0x64, 0x4a, 0x04, 0x08, 0x04, 0x10, 0x05, 0x22, 0x34, 0x0a, 0x11, 0x56, 0x65, 0x72, 0x69, 0x66, + 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x0f, 0x0a, 0x0b, + 0x44, 0x45, 0x43, 0x4c, 0x41, 0x52, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x10, 0x00, 0x12, 0x0e, 0x0a, + 0x0a, 0x55, 0x4e, 0x56, 0x45, 0x52, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x01, 0x2a, 0x09, 0x08, + 0xe8, 0x07, 0x10, 0x80, 0x80, 0x80, 0x80, 0x02, 0x22, 0xc1, 0x06, 0x0a, 0x14, 0x46, 0x69, 0x65, + 0x6c, 0x64, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, + 0x6f, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x12, 0x41, 0x0a, + 0x05, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2b, 0x2e, 0x67, + 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, + 0x69, 0x65, 0x6c, 0x64, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, + 0x6f, 0x74, 0x6f, 0x2e, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x52, 0x05, 0x6c, 0x61, 0x62, 0x65, 0x6c, + 0x12, 0x3e, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2a, + 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, + 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, + 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, + 0x12, 0x1b, 0x0a, 0x09, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x06, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x08, 0x74, 0x79, 0x70, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1a, 0x0a, + 0x08, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x65, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x08, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x65, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x64, 0x65, 0x66, + 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x0c, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x1f, + 0x0a, 0x0b, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x09, 0x20, + 0x01, 0x28, 0x05, 0x52, 0x0a, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x12, + 0x1b, 0x0a, 0x09, 0x6a, 0x73, 0x6f, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x0a, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x08, 0x6a, 0x73, 0x6f, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x37, 0x0a, 0x07, + 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, + 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, + 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x07, 0x6f, 0x70, + 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x27, 0x0a, 0x0f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x5f, + 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x18, 0x11, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x22, 0xb6, + 0x02, 0x0a, 0x04, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0f, 0x0a, 0x0b, 0x54, 0x59, 0x50, 0x45, 0x5f, + 0x44, 0x4f, 0x55, 0x42, 0x4c, 0x45, 0x10, 0x01, 0x12, 0x0e, 0x0a, 0x0a, 0x54, 0x59, 0x50, 0x45, + 0x5f, 0x46, 0x4c, 0x4f, 0x41, 0x54, 0x10, 0x02, 0x12, 0x0e, 0x0a, 0x0a, 0x54, 0x59, 0x50, 0x45, + 0x5f, 0x49, 0x4e, 0x54, 0x36, 0x34, 0x10, 0x03, 0x12, 0x0f, 0x0a, 0x0b, 0x54, 0x59, 0x50, 0x45, + 0x5f, 0x55, 0x49, 0x4e, 0x54, 0x36, 0x34, 0x10, 0x04, 0x12, 0x0e, 0x0a, 0x0a, 0x54, 0x59, 0x50, + 0x45, 0x5f, 0x49, 0x4e, 0x54, 0x33, 0x32, 0x10, 0x05, 0x12, 0x10, 0x0a, 0x0c, 0x54, 0x59, 0x50, + 0x45, 0x5f, 0x46, 0x49, 0x58, 0x45, 0x44, 0x36, 0x34, 0x10, 0x06, 0x12, 0x10, 0x0a, 0x0c, 0x54, + 0x59, 0x50, 0x45, 0x5f, 0x46, 0x49, 0x58, 0x45, 0x44, 0x33, 0x32, 0x10, 0x07, 0x12, 0x0d, 0x0a, + 0x09, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x42, 0x4f, 0x4f, 0x4c, 0x10, 0x08, 0x12, 0x0f, 0x0a, 0x0b, + 0x54, 0x59, 0x50, 0x45, 0x5f, 0x53, 0x54, 0x52, 0x49, 0x4e, 0x47, 0x10, 0x09, 0x12, 0x0e, 0x0a, + 0x0a, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x47, 0x52, 0x4f, 0x55, 0x50, 0x10, 0x0a, 0x12, 0x10, 0x0a, + 0x0c, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x4d, 0x45, 0x53, 0x53, 0x41, 0x47, 0x45, 0x10, 0x0b, 0x12, + 0x0e, 0x0a, 0x0a, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x42, 0x59, 0x54, 0x45, 0x53, 0x10, 0x0c, 0x12, + 0x0f, 0x0a, 0x0b, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x55, 0x49, 0x4e, 0x54, 0x33, 0x32, 0x10, 0x0d, + 0x12, 0x0d, 0x0a, 0x09, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x45, 0x4e, 0x55, 0x4d, 0x10, 0x0e, 0x12, + 0x11, 0x0a, 0x0d, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x53, 0x46, 0x49, 0x58, 0x45, 0x44, 0x33, 0x32, + 0x10, 0x0f, 0x12, 0x11, 0x0a, 0x0d, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x53, 0x46, 0x49, 0x58, 0x45, + 0x44, 0x36, 0x34, 0x10, 0x10, 0x12, 0x0f, 0x0a, 0x0b, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x53, 0x49, + 0x4e, 0x54, 0x33, 0x32, 0x10, 0x11, 0x12, 0x0f, 0x0a, 0x0b, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x53, + 0x49, 0x4e, 0x54, 0x36, 0x34, 0x10, 0x12, 0x22, 0x43, 0x0a, 0x05, 0x4c, 0x61, 0x62, 0x65, 0x6c, + 0x12, 0x12, 0x0a, 0x0e, 0x4c, 0x41, 0x42, 0x45, 0x4c, 0x5f, 0x4f, 0x50, 0x54, 0x49, 0x4f, 0x4e, + 0x41, 0x4c, 0x10, 0x01, 0x12, 0x12, 0x0a, 0x0e, 0x4c, 0x41, 0x42, 0x45, 0x4c, 0x5f, 0x52, 0x45, + 0x50, 0x45, 0x41, 0x54, 0x45, 0x44, 0x10, 0x03, 0x12, 0x12, 0x0a, 0x0e, 0x4c, 0x41, 0x42, 0x45, + 0x4c, 0x5f, 0x52, 0x45, 0x51, 0x55, 0x49, 0x52, 0x45, 0x44, 0x10, 0x02, 0x22, 0x63, 0x0a, 0x14, + 0x4f, 0x6e, 0x65, 0x6f, 0x66, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, + 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x37, 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, + 0x6f, 0x6e, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, + 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4f, 0x6e, 0x65, 0x6f, + 0x66, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, + 0x73, 0x22, 0xe3, 0x02, 0x0a, 0x13, 0x45, 0x6e, 0x75, 0x6d, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, + 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, + 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x3f, 0x0a, + 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x67, + 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, + 0x6e, 0x75, 0x6d, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, + 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x36, + 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1c, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, + 0x66, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x07, 0x6f, + 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x5d, 0x0a, 0x0e, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, + 0x65, 0x64, 0x5f, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x36, + 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, + 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, + 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, + 0x64, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x52, 0x0d, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, + 0x52, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, + 0x64, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x05, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0c, 0x72, 0x65, + 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x1a, 0x3b, 0x0a, 0x11, 0x45, 0x6e, + 0x75, 0x6d, 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x12, + 0x14, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x65, 0x6e, 0x64, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x05, 0x52, 0x03, 0x65, 0x6e, 0x64, 0x22, 0x83, 0x01, 0x0a, 0x18, 0x45, 0x6e, 0x75, 0x6d, + 0x56, 0x61, 0x6c, 0x75, 0x65, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, + 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x6e, 0x75, 0x6d, 0x62, + 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, + 0x12, 0x3b, 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x21, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4f, 0x70, 0x74, + 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0xa7, 0x01, + 0x0a, 0x16, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, + 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x3e, 0x0a, 0x06, + 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x67, + 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, + 0x65, 0x74, 0x68, 0x6f, 0x64, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, + 0x72, 0x6f, 0x74, 0x6f, 0x52, 0x06, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x12, 0x39, 0x0a, 0x07, + 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, + 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, + 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x07, + 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x89, 0x02, 0x0a, 0x15, 0x4d, 0x65, 0x74, 0x68, + 0x6f, 0x64, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, + 0x6f, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x5f, 0x74, + 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x69, 0x6e, 0x70, 0x75, 0x74, + 0x54, 0x79, 0x70, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x5f, 0x74, + 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x6f, 0x75, 0x74, 0x70, 0x75, + 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x38, 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, + 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x4f, + 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, + 0x30, 0x0a, 0x10, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x5f, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, + 0x69, 0x6e, 0x67, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, + 0x52, 0x0f, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x69, 0x6e, + 0x67, 0x12, 0x30, 0x0a, 0x10, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x5f, 0x73, 0x74, 0x72, 0x65, + 0x61, 0x6d, 0x69, 0x6e, 0x67, 0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, + 0x73, 0x65, 0x52, 0x0f, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, + 0x69, 0x6e, 0x67, 0x22, 0x97, 0x09, 0x0a, 0x0b, 0x46, 0x69, 0x6c, 0x65, 0x4f, 0x70, 0x74, 0x69, + 0x6f, 0x6e, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x6a, 0x61, 0x76, 0x61, 0x5f, 0x70, 0x61, 0x63, 0x6b, + 0x61, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x6a, 0x61, 0x76, 0x61, 0x50, + 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x12, 0x30, 0x0a, 0x14, 0x6a, 0x61, 0x76, 0x61, 0x5f, 0x6f, + 0x75, 0x74, 0x65, 0x72, 0x5f, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x08, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x12, 0x6a, 0x61, 0x76, 0x61, 0x4f, 0x75, 0x74, 0x65, 0x72, 0x43, + 0x6c, 0x61, 0x73, 0x73, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x35, 0x0a, 0x13, 0x6a, 0x61, 0x76, 0x61, + 0x5f, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x65, 0x5f, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x18, + 0x0a, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x11, 0x6a, 0x61, + 0x76, 0x61, 0x4d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x65, 0x46, 0x69, 0x6c, 0x65, 0x73, 0x12, + 0x44, 0x0a, 0x1d, 0x6a, 0x61, 0x76, 0x61, 0x5f, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, + 0x5f, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x73, 0x5f, 0x61, 0x6e, 0x64, 0x5f, 0x68, 0x61, 0x73, 0x68, + 0x18, 0x14, 0x20, 0x01, 0x28, 0x08, 0x42, 0x02, 0x18, 0x01, 0x52, 0x19, 0x6a, 0x61, 0x76, 0x61, + 0x47, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x45, 0x71, 0x75, 0x61, 0x6c, 0x73, 0x41, 0x6e, + 0x64, 0x48, 0x61, 0x73, 0x68, 0x12, 0x3a, 0x0a, 0x16, 0x6a, 0x61, 0x76, 0x61, 0x5f, 0x73, 0x74, + 0x72, 0x69, 0x6e, 0x67, 0x5f, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x5f, 0x75, 0x74, 0x66, 0x38, 0x18, + 0x1b, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x13, 0x6a, 0x61, + 0x76, 0x61, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x55, 0x74, 0x66, + 0x38, 0x12, 0x53, 0x0a, 0x0c, 0x6f, 0x70, 0x74, 0x69, 0x6d, 0x69, 0x7a, 0x65, 0x5f, 0x66, 0x6f, + 0x72, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x29, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x6c, 0x65, 0x4f, 0x70, + 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x4f, 0x70, 0x74, 0x69, 0x6d, 0x69, 0x7a, 0x65, 0x4d, 0x6f, + 0x64, 0x65, 0x3a, 0x05, 0x53, 0x50, 0x45, 0x45, 0x44, 0x52, 0x0b, 0x6f, 0x70, 0x74, 0x69, 0x6d, + 0x69, 0x7a, 0x65, 0x46, 0x6f, 0x72, 0x12, 0x1d, 0x0a, 0x0a, 0x67, 0x6f, 0x5f, 0x70, 0x61, 0x63, + 0x6b, 0x61, 0x67, 0x65, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x67, 0x6f, 0x50, 0x61, + 0x63, 0x6b, 0x61, 0x67, 0x65, 0x12, 0x35, 0x0a, 0x13, 0x63, 0x63, 0x5f, 0x67, 0x65, 0x6e, 0x65, + 0x72, 0x69, 0x63, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x18, 0x10, 0x20, 0x01, + 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x11, 0x63, 0x63, 0x47, 0x65, 0x6e, + 0x65, 0x72, 0x69, 0x63, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x12, 0x39, 0x0a, 0x15, + 0x6a, 0x61, 0x76, 0x61, 0x5f, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x5f, 0x73, 0x65, 0x72, + 0x76, 0x69, 0x63, 0x65, 0x73, 0x18, 0x11, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, + 0x73, 0x65, 0x52, 0x13, 0x6a, 0x61, 0x76, 0x61, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x53, + 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x12, 0x35, 0x0a, 0x13, 0x70, 0x79, 0x5f, 0x67, 0x65, + 0x6e, 0x65, 0x72, 0x69, 0x63, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x18, 0x12, + 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x11, 0x70, 0x79, 0x47, + 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x12, 0x25, + 0x0a, 0x0a, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x18, 0x17, 0x20, 0x01, + 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x0a, 0x64, 0x65, 0x70, 0x72, 0x65, + 0x63, 0x61, 0x74, 0x65, 0x64, 0x12, 0x2e, 0x0a, 0x10, 0x63, 0x63, 0x5f, 0x65, 0x6e, 0x61, 0x62, + 0x6c, 0x65, 0x5f, 0x61, 0x72, 0x65, 0x6e, 0x61, 0x73, 0x18, 0x1f, 0x20, 0x01, 0x28, 0x08, 0x3a, + 0x04, 0x74, 0x72, 0x75, 0x65, 0x52, 0x0e, 0x63, 0x63, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x41, + 0x72, 0x65, 0x6e, 0x61, 0x73, 0x12, 0x2a, 0x0a, 0x11, 0x6f, 0x62, 0x6a, 0x63, 0x5f, 0x63, 0x6c, + 0x61, 0x73, 0x73, 0x5f, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x18, 0x24, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x0f, 0x6f, 0x62, 0x6a, 0x63, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x50, 0x72, 0x65, 0x66, 0x69, + 0x78, 0x12, 0x29, 0x0a, 0x10, 0x63, 0x73, 0x68, 0x61, 0x72, 0x70, 0x5f, 0x6e, 0x61, 0x6d, 0x65, + 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x25, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x63, 0x73, 0x68, + 0x61, 0x72, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x21, 0x0a, 0x0c, + 0x73, 0x77, 0x69, 0x66, 0x74, 0x5f, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x18, 0x27, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x0b, 0x73, 0x77, 0x69, 0x66, 0x74, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0x12, + 0x28, 0x0a, 0x10, 0x70, 0x68, 0x70, 0x5f, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x5f, 0x70, 0x72, 0x65, + 0x66, 0x69, 0x78, 0x18, 0x28, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x70, 0x68, 0x70, 0x43, 0x6c, + 0x61, 0x73, 0x73, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0x12, 0x23, 0x0a, 0x0d, 0x70, 0x68, 0x70, + 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x29, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x0c, 0x70, 0x68, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x34, + 0x0a, 0x16, 0x70, 0x68, 0x70, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x5f, 0x6e, + 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x2c, 0x20, 0x01, 0x28, 0x09, 0x52, 0x14, + 0x70, 0x68, 0x70, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x4e, 0x61, 0x6d, 0x65, 0x73, + 0x70, 0x61, 0x63, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x72, 0x75, 0x62, 0x79, 0x5f, 0x70, 0x61, 0x63, + 0x6b, 0x61, 0x67, 0x65, 0x18, 0x2d, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x72, 0x75, 0x62, 0x79, + 0x50, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x12, 0x37, 0x0a, 0x08, 0x66, 0x65, 0x61, 0x74, 0x75, + 0x72, 0x65, 0x73, 0x18, 0x32, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x67, 0x6f, 0x6f, 0x67, + 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x65, 0x61, 0x74, + 0x75, 0x72, 0x65, 0x53, 0x65, 0x74, 0x52, 0x08, 0x66, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, + 0x12, 0x58, 0x0a, 0x14, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, + 0x64, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0xe7, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x24, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, + 0x66, 0x2e, 0x55, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, + 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x13, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, + 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x0a, 0x0c, 0x4f, 0x70, + 0x74, 0x69, 0x6d, 0x69, 0x7a, 0x65, 0x4d, 0x6f, 0x64, 0x65, 0x12, 0x09, 0x0a, 0x05, 0x53, 0x50, + 0x45, 0x45, 0x44, 0x10, 0x01, 0x12, 0x0d, 0x0a, 0x09, 0x43, 0x4f, 0x44, 0x45, 0x5f, 0x53, 0x49, + 0x5a, 0x45, 0x10, 0x02, 0x12, 0x10, 0x0a, 0x0c, 0x4c, 0x49, 0x54, 0x45, 0x5f, 0x52, 0x55, 0x4e, + 0x54, 0x49, 0x4d, 0x45, 0x10, 0x03, 0x2a, 0x09, 0x08, 0xe8, 0x07, 0x10, 0x80, 0x80, 0x80, 0x80, + 0x02, 0x4a, 0x04, 0x08, 0x2a, 0x10, 0x2b, 0x4a, 0x04, 0x08, 0x26, 0x10, 0x27, 0x22, 0xf4, 0x03, + 0x0a, 0x0e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, + 0x12, 0x3c, 0x0a, 0x17, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x73, 0x65, 0x74, 0x5f, + 0x77, 0x69, 0x72, 0x65, 0x5f, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x14, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, + 0x65, 0x53, 0x65, 0x74, 0x57, 0x69, 0x72, 0x65, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x12, 0x4c, + 0x0a, 0x1f, 0x6e, 0x6f, 0x5f, 0x73, 0x74, 0x61, 0x6e, 0x64, 0x61, 0x72, 0x64, 0x5f, 0x64, 0x65, + 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x6f, + 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x1c, + 0x6e, 0x6f, 0x53, 0x74, 0x61, 0x6e, 0x64, 0x61, 0x72, 0x64, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, + 0x70, 0x74, 0x6f, 0x72, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x6f, 0x72, 0x12, 0x25, 0x0a, 0x0a, + 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, + 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x0a, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, + 0x74, 0x65, 0x64, 0x12, 0x1b, 0x0a, 0x09, 0x6d, 0x61, 0x70, 0x5f, 0x65, 0x6e, 0x74, 0x72, 0x79, + 0x18, 0x07, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x6d, 0x61, 0x70, 0x45, 0x6e, 0x74, 0x72, 0x79, + 0x12, 0x56, 0x0a, 0x26, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x6c, + 0x65, 0x67, 0x61, 0x63, 0x79, 0x5f, 0x6a, 0x73, 0x6f, 0x6e, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, + 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x6c, 0x69, 0x63, 0x74, 0x73, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x08, + 0x42, 0x02, 0x18, 0x01, 0x52, 0x22, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, + 0x4c, 0x65, 0x67, 0x61, 0x63, 0x79, 0x4a, 0x73, 0x6f, 0x6e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43, + 0x6f, 0x6e, 0x66, 0x6c, 0x69, 0x63, 0x74, 0x73, 0x12, 0x37, 0x0a, 0x08, 0x66, 0x65, 0x61, 0x74, + 0x75, 0x72, 0x65, 0x73, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x67, 0x6f, 0x6f, + 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x65, 0x61, + 0x74, 0x75, 0x72, 0x65, 0x53, 0x65, 0x74, 0x52, 0x08, 0x66, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, + 0x73, 0x12, 0x58, 0x0a, 0x14, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, + 0x65, 0x64, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0xe7, 0x07, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, + 0x75, 0x66, 0x2e, 0x55, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, + 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x13, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, + 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x2a, 0x09, 0x08, 0xe8, 0x07, + 0x10, 0x80, 0x80, 0x80, 0x80, 0x02, 0x4a, 0x04, 0x08, 0x04, 0x10, 0x05, 0x4a, 0x04, 0x08, 0x05, + 0x10, 0x06, 0x4a, 0x04, 0x08, 0x06, 0x10, 0x07, 0x4a, 0x04, 0x08, 0x08, 0x10, 0x09, 0x4a, 0x04, + 0x08, 0x09, 0x10, 0x0a, 0x22, 0xad, 0x0a, 0x0a, 0x0c, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f, 0x70, + 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x41, 0x0a, 0x05, 0x63, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0e, 0x32, 0x23, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f, 0x70, 0x74, 0x69, + 0x6f, 0x6e, 0x73, 0x2e, 0x43, 0x54, 0x79, 0x70, 0x65, 0x3a, 0x06, 0x53, 0x54, 0x52, 0x49, 0x4e, + 0x47, 0x52, 0x05, 0x63, 0x74, 0x79, 0x70, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x70, 0x61, 0x63, 0x6b, + 0x65, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, + 0x12, 0x47, 0x0a, 0x06, 0x6a, 0x73, 0x74, 0x79, 0x70, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0e, + 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, + 0x75, 0x66, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, + 0x4a, 0x53, 0x54, 0x79, 0x70, 0x65, 0x3a, 0x09, 0x4a, 0x53, 0x5f, 0x4e, 0x4f, 0x52, 0x4d, 0x41, + 0x4c, 0x52, 0x06, 0x6a, 0x73, 0x74, 0x79, 0x70, 0x65, 0x12, 0x19, 0x0a, 0x04, 0x6c, 0x61, 0x7a, + 0x79, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x04, + 0x6c, 0x61, 0x7a, 0x79, 0x12, 0x2e, 0x0a, 0x0f, 0x75, 0x6e, 0x76, 0x65, 0x72, 0x69, 0x66, 0x69, + 0x65, 0x64, 0x5f, 0x6c, 0x61, 0x7a, 0x79, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, + 0x61, 0x6c, 0x73, 0x65, 0x52, 0x0e, 0x75, 0x6e, 0x76, 0x65, 0x72, 0x69, 0x66, 0x69, 0x65, 0x64, + 0x4c, 0x61, 0x7a, 0x79, 0x12, 0x25, 0x0a, 0x0a, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, + 0x65, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, + 0x0a, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x12, 0x19, 0x0a, 0x04, 0x77, + 0x65, 0x61, 0x6b, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, + 0x52, 0x04, 0x77, 0x65, 0x61, 0x6b, 0x12, 0x28, 0x0a, 0x0c, 0x64, 0x65, 0x62, 0x75, 0x67, 0x5f, + 0x72, 0x65, 0x64, 0x61, 0x63, 0x74, 0x18, 0x10, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, + 0x6c, 0x73, 0x65, 0x52, 0x0b, 0x64, 0x65, 0x62, 0x75, 0x67, 0x52, 0x65, 0x64, 0x61, 0x63, 0x74, + 0x12, 0x4b, 0x0a, 0x09, 0x72, 0x65, 0x74, 0x65, 0x6e, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x11, 0x20, + 0x01, 0x28, 0x0e, 0x32, 0x2d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, + 0x6e, 0x73, 0x2e, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x74, 0x65, 0x6e, 0x74, 0x69, + 0x6f, 0x6e, 0x52, 0x09, 0x72, 0x65, 0x74, 0x65, 0x6e, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x48, 0x0a, + 0x07, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x73, 0x18, 0x13, 0x20, 0x03, 0x28, 0x0e, 0x32, 0x2e, + 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, + 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x4f, 0x70, + 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x52, 0x07, + 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x73, 0x12, 0x57, 0x0a, 0x10, 0x65, 0x64, 0x69, 0x74, 0x69, + 0x6f, 0x6e, 0x5f, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x73, 0x18, 0x14, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x2c, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, + 0x2e, 0x45, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x52, + 0x0f, 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x73, + 0x12, 0x37, 0x0a, 0x08, 0x66, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x18, 0x15, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x53, 0x65, 0x74, 0x52, + 0x08, 0x66, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x12, 0x58, 0x0a, 0x14, 0x75, 0x6e, 0x69, + 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, + 0x6e, 0x18, 0xe7, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, + 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x55, 0x6e, 0x69, 0x6e, 0x74, + 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x13, + 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, + 0x69, 0x6f, 0x6e, 0x1a, 0x5a, 0x0a, 0x0e, 0x45, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, + 0x66, 0x61, 0x75, 0x6c, 0x74, 0x12, 0x32, 0x0a, 0x07, 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x18, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, + 0x52, 0x07, 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, + 0x2f, 0x0a, 0x05, 0x43, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0a, 0x0a, 0x06, 0x53, 0x54, 0x52, 0x49, + 0x4e, 0x47, 0x10, 0x00, 0x12, 0x08, 0x0a, 0x04, 0x43, 0x4f, 0x52, 0x44, 0x10, 0x01, 0x12, 0x10, + 0x0a, 0x0c, 0x53, 0x54, 0x52, 0x49, 0x4e, 0x47, 0x5f, 0x50, 0x49, 0x45, 0x43, 0x45, 0x10, 0x02, + 0x22, 0x35, 0x0a, 0x06, 0x4a, 0x53, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0d, 0x0a, 0x09, 0x4a, 0x53, + 0x5f, 0x4e, 0x4f, 0x52, 0x4d, 0x41, 0x4c, 0x10, 0x00, 0x12, 0x0d, 0x0a, 0x09, 0x4a, 0x53, 0x5f, + 0x53, 0x54, 0x52, 0x49, 0x4e, 0x47, 0x10, 0x01, 0x12, 0x0d, 0x0a, 0x09, 0x4a, 0x53, 0x5f, 0x4e, + 0x55, 0x4d, 0x42, 0x45, 0x52, 0x10, 0x02, 0x22, 0x55, 0x0a, 0x0f, 0x4f, 0x70, 0x74, 0x69, 0x6f, + 0x6e, 0x52, 0x65, 0x74, 0x65, 0x6e, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x15, 0x0a, 0x11, 0x52, 0x45, + 0x54, 0x45, 0x4e, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10, + 0x00, 0x12, 0x15, 0x0a, 0x11, 0x52, 0x45, 0x54, 0x45, 0x4e, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, + 0x55, 0x4e, 0x54, 0x49, 0x4d, 0x45, 0x10, 0x01, 0x12, 0x14, 0x0a, 0x10, 0x52, 0x45, 0x54, 0x45, + 0x4e, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x53, 0x4f, 0x55, 0x52, 0x43, 0x45, 0x10, 0x02, 0x22, 0x8c, + 0x02, 0x0a, 0x10, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x54, + 0x79, 0x70, 0x65, 0x12, 0x17, 0x0a, 0x13, 0x54, 0x41, 0x52, 0x47, 0x45, 0x54, 0x5f, 0x54, 0x59, + 0x50, 0x45, 0x5f, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x14, 0x0a, 0x10, + 0x54, 0x41, 0x52, 0x47, 0x45, 0x54, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x46, 0x49, 0x4c, 0x45, + 0x10, 0x01, 0x12, 0x1f, 0x0a, 0x1b, 0x54, 0x41, 0x52, 0x47, 0x45, 0x54, 0x5f, 0x54, 0x59, 0x50, + 0x45, 0x5f, 0x45, 0x58, 0x54, 0x45, 0x4e, 0x53, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x41, 0x4e, 0x47, + 0x45, 0x10, 0x02, 0x12, 0x17, 0x0a, 0x13, 0x54, 0x41, 0x52, 0x47, 0x45, 0x54, 0x5f, 0x54, 0x59, + 0x50, 0x45, 0x5f, 0x4d, 0x45, 0x53, 0x53, 0x41, 0x47, 0x45, 0x10, 0x03, 0x12, 0x15, 0x0a, 0x11, + 0x54, 0x41, 0x52, 0x47, 0x45, 0x54, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x46, 0x49, 0x45, 0x4c, + 0x44, 0x10, 0x04, 0x12, 0x15, 0x0a, 0x11, 0x54, 0x41, 0x52, 0x47, 0x45, 0x54, 0x5f, 0x54, 0x59, + 0x50, 0x45, 0x5f, 0x4f, 0x4e, 0x45, 0x4f, 0x46, 0x10, 0x05, 0x12, 0x14, 0x0a, 0x10, 0x54, 0x41, + 0x52, 0x47, 0x45, 0x54, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x45, 0x4e, 0x55, 0x4d, 0x10, 0x06, + 0x12, 0x1a, 0x0a, 0x16, 0x54, 0x41, 0x52, 0x47, 0x45, 0x54, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, + 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x45, 0x4e, 0x54, 0x52, 0x59, 0x10, 0x07, 0x12, 0x17, 0x0a, 0x13, + 0x54, 0x41, 0x52, 0x47, 0x45, 0x54, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x53, 0x45, 0x52, 0x56, + 0x49, 0x43, 0x45, 0x10, 0x08, 0x12, 0x16, 0x0a, 0x12, 0x54, 0x41, 0x52, 0x47, 0x45, 0x54, 0x5f, + 0x54, 0x59, 0x50, 0x45, 0x5f, 0x4d, 0x45, 0x54, 0x48, 0x4f, 0x44, 0x10, 0x09, 0x2a, 0x09, 0x08, + 0xe8, 0x07, 0x10, 0x80, 0x80, 0x80, 0x80, 0x02, 0x4a, 0x04, 0x08, 0x04, 0x10, 0x05, 0x4a, 0x04, + 0x08, 0x12, 0x10, 0x13, 0x22, 0xac, 0x01, 0x0a, 0x0c, 0x4f, 0x6e, 0x65, 0x6f, 0x66, 0x4f, 0x70, + 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x37, 0x0a, 0x08, 0x66, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, + 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, + 0x65, 0x53, 0x65, 0x74, 0x52, 0x08, 0x66, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x12, 0x58, + 0x0a, 0x14, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x5f, + 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0xe7, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, + 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, + 0x55, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, + 0x69, 0x6f, 0x6e, 0x52, 0x13, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, + 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x2a, 0x09, 0x08, 0xe8, 0x07, 0x10, 0x80, 0x80, + 0x80, 0x80, 0x02, 0x22, 0xd1, 0x02, 0x0a, 0x0b, 0x45, 0x6e, 0x75, 0x6d, 0x4f, 0x70, 0x74, 0x69, + 0x6f, 0x6e, 0x73, 0x12, 0x1f, 0x0a, 0x0b, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x5f, 0x61, 0x6c, 0x69, + 0x61, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x41, + 0x6c, 0x69, 0x61, 0x73, 0x12, 0x25, 0x0a, 0x0a, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, + 0x65, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, + 0x0a, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x12, 0x56, 0x0a, 0x26, 0x64, + 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x6c, 0x65, 0x67, 0x61, 0x63, 0x79, + 0x5f, 0x6a, 0x73, 0x6f, 0x6e, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x5f, 0x63, 0x6f, 0x6e, 0x66, + 0x6c, 0x69, 0x63, 0x74, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x42, 0x02, 0x18, 0x01, 0x52, + 0x22, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x4c, 0x65, 0x67, 0x61, 0x63, + 0x79, 0x4a, 0x73, 0x6f, 0x6e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43, 0x6f, 0x6e, 0x66, 0x6c, 0x69, + 0x63, 0x74, 0x73, 0x12, 0x37, 0x0a, 0x08, 0x66, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x18, + 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x53, + 0x65, 0x74, 0x52, 0x08, 0x66, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x12, 0x58, 0x0a, 0x14, + 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x5f, 0x6f, 0x70, + 0x74, 0x69, 0x6f, 0x6e, 0x18, 0xe7, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x67, 0x6f, + 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x55, 0x6e, + 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, + 0x6e, 0x52, 0x13, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, + 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x2a, 0x09, 0x08, 0xe8, 0x07, 0x10, 0x80, 0x80, 0x80, 0x80, + 0x02, 0x4a, 0x04, 0x08, 0x05, 0x10, 0x06, 0x22, 0x81, 0x02, 0x0a, 0x10, 0x45, 0x6e, 0x75, 0x6d, + 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x25, 0x0a, 0x0a, + 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, + 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x0a, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, + 0x74, 0x65, 0x64, 0x12, 0x37, 0x0a, 0x08, 0x66, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x53, + 0x65, 0x74, 0x52, 0x08, 0x66, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x12, 0x28, 0x0a, 0x0c, + 0x64, 0x65, 0x62, 0x75, 0x67, 0x5f, 0x72, 0x65, 0x64, 0x61, 0x63, 0x74, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x0b, 0x64, 0x65, 0x62, 0x75, 0x67, + 0x52, 0x65, 0x64, 0x61, 0x63, 0x74, 0x12, 0x58, 0x0a, 0x14, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, + 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0xe7, + 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x55, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, + 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x13, 0x75, 0x6e, 0x69, + 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, + 0x2a, 0x09, 0x08, 0xe8, 0x07, 0x10, 0x80, 0x80, 0x80, 0x80, 0x02, 0x22, 0xd5, 0x01, 0x0a, 0x0e, + 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x37, + 0x0a, 0x08, 0x66, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x18, 0x22, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x1b, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, + 0x75, 0x66, 0x2e, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x53, 0x65, 0x74, 0x52, 0x08, 0x66, + 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x12, 0x25, 0x0a, 0x0a, 0x64, 0x65, 0x70, 0x72, 0x65, + 0x63, 0x61, 0x74, 0x65, 0x64, 0x18, 0x21, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, + 0x73, 0x65, 0x52, 0x0a, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x12, 0x58, + 0x0a, 0x14, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x5f, + 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0xe7, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, + 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, + 0x55, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, + 0x69, 0x6f, 0x6e, 0x52, 0x13, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, + 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x2a, 0x09, 0x08, 0xe8, 0x07, 0x10, 0x80, 0x80, + 0x80, 0x80, 0x02, 0x22, 0x99, 0x03, 0x0a, 0x0d, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x4f, 0x70, + 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x25, 0x0a, 0x0a, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, + 0x74, 0x65, 0x64, 0x18, 0x21, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, + 0x52, 0x0a, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x12, 0x71, 0x0a, 0x11, + 0x69, 0x64, 0x65, 0x6d, 0x70, 0x6f, 0x74, 0x65, 0x6e, 0x63, 0x79, 0x5f, 0x6c, 0x65, 0x76, 0x65, + 0x6c, 0x18, 0x22, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, + 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x49, 0x64, 0x65, 0x6d, 0x70, 0x6f, 0x74, 0x65, + 0x6e, 0x63, 0x79, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x3a, 0x13, 0x49, 0x44, 0x45, 0x4d, 0x50, 0x4f, + 0x54, 0x45, 0x4e, 0x43, 0x59, 0x5f, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x52, 0x10, 0x69, + 0x64, 0x65, 0x6d, 0x70, 0x6f, 0x74, 0x65, 0x6e, 0x63, 0x79, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x12, + 0x37, 0x0a, 0x08, 0x66, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x18, 0x23, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x1b, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x62, 0x75, 0x66, 0x2e, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x53, 0x65, 0x74, 0x52, 0x08, + 0x66, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x12, 0x58, 0x0a, 0x14, 0x75, 0x6e, 0x69, 0x6e, + 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, + 0x18, 0xe7, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x55, 0x6e, 0x69, 0x6e, 0x74, 0x65, + 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x13, 0x75, + 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, + 0x6f, 0x6e, 0x22, 0x50, 0x0a, 0x10, 0x49, 0x64, 0x65, 0x6d, 0x70, 0x6f, 0x74, 0x65, 0x6e, 0x63, + 0x79, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x12, 0x17, 0x0a, 0x13, 0x49, 0x44, 0x45, 0x4d, 0x50, 0x4f, + 0x54, 0x45, 0x4e, 0x43, 0x59, 0x5f, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, + 0x13, 0x0a, 0x0f, 0x4e, 0x4f, 0x5f, 0x53, 0x49, 0x44, 0x45, 0x5f, 0x45, 0x46, 0x46, 0x45, 0x43, + 0x54, 0x53, 0x10, 0x01, 0x12, 0x0e, 0x0a, 0x0a, 0x49, 0x44, 0x45, 0x4d, 0x50, 0x4f, 0x54, 0x45, + 0x4e, 0x54, 0x10, 0x02, 0x2a, 0x09, 0x08, 0xe8, 0x07, 0x10, 0x80, 0x80, 0x80, 0x80, 0x02, 0x22, + 0x9a, 0x03, 0x0a, 0x13, 0x55, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, + 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x41, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, + 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x55, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, + 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x4e, 0x61, 0x6d, 0x65, + 0x50, 0x61, 0x72, 0x74, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x29, 0x0a, 0x10, 0x69, 0x64, + 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, + 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x2c, 0x0a, 0x12, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x76, + 0x65, 0x5f, 0x69, 0x6e, 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, + 0x04, 0x52, 0x10, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x76, 0x65, 0x49, 0x6e, 0x74, 0x56, 0x61, + 0x6c, 0x75, 0x65, 0x12, 0x2c, 0x0a, 0x12, 0x6e, 0x65, 0x67, 0x61, 0x74, 0x69, 0x76, 0x65, 0x5f, + 0x69, 0x6e, 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, + 0x10, 0x6e, 0x65, 0x67, 0x61, 0x74, 0x69, 0x76, 0x65, 0x49, 0x6e, 0x74, 0x56, 0x61, 0x6c, 0x75, + 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x5f, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0b, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x56, + 0x61, 0x6c, 0x75, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x73, 0x74, 0x72, 0x69, + 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x27, 0x0a, 0x0f, 0x61, 0x67, 0x67, 0x72, 0x65, + 0x67, 0x61, 0x74, 0x65, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x0e, 0x61, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, + 0x1a, 0x4a, 0x0a, 0x08, 0x4e, 0x61, 0x6d, 0x65, 0x50, 0x61, 0x72, 0x74, 0x12, 0x1b, 0x0a, 0x09, + 0x6e, 0x61, 0x6d, 0x65, 0x5f, 0x70, 0x61, 0x72, 0x74, 0x18, 0x01, 0x20, 0x02, 0x28, 0x09, 0x52, + 0x08, 0x6e, 0x61, 0x6d, 0x65, 0x50, 0x61, 0x72, 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x69, 0x73, 0x5f, + 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x02, 0x28, 0x08, 0x52, + 0x0b, 0x69, 0x73, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x22, 0x8c, 0x0a, 0x0a, + 0x0a, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x53, 0x65, 0x74, 0x12, 0x8b, 0x01, 0x0a, 0x0e, + 0x66, 0x69, 0x65, 0x6c, 0x64, 0x5f, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x63, 0x65, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0e, 0x32, 0x29, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x53, 0x65, + 0x74, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x50, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x63, 0x65, 0x42, + 0x39, 0x88, 0x01, 0x01, 0x98, 0x01, 0x04, 0x98, 0x01, 0x01, 0xa2, 0x01, 0x0d, 0x12, 0x08, 0x45, + 0x58, 0x50, 0x4c, 0x49, 0x43, 0x49, 0x54, 0x18, 0xe6, 0x07, 0xa2, 0x01, 0x0d, 0x12, 0x08, 0x49, + 0x4d, 0x50, 0x4c, 0x49, 0x43, 0x49, 0x54, 0x18, 0xe7, 0x07, 0xa2, 0x01, 0x0d, 0x12, 0x08, 0x45, + 0x58, 0x50, 0x4c, 0x49, 0x43, 0x49, 0x54, 0x18, 0xe8, 0x07, 0x52, 0x0d, 0x66, 0x69, 0x65, 0x6c, + 0x64, 0x50, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x63, 0x65, 0x12, 0x66, 0x0a, 0x09, 0x65, 0x6e, 0x75, + 0x6d, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x67, + 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, + 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x53, 0x65, 0x74, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x54, 0x79, + 0x70, 0x65, 0x42, 0x23, 0x88, 0x01, 0x01, 0x98, 0x01, 0x06, 0x98, 0x01, 0x01, 0xa2, 0x01, 0x0b, + 0x12, 0x06, 0x43, 0x4c, 0x4f, 0x53, 0x45, 0x44, 0x18, 0xe6, 0x07, 0xa2, 0x01, 0x09, 0x12, 0x04, + 0x4f, 0x50, 0x45, 0x4e, 0x18, 0xe7, 0x07, 0x52, 0x08, 0x65, 0x6e, 0x75, 0x6d, 0x54, 0x79, 0x70, + 0x65, 0x12, 0x92, 0x01, 0x0a, 0x17, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x66, + 0x69, 0x65, 0x6c, 0x64, 0x5f, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x69, 0x6e, 0x67, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x0e, 0x32, 0x31, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x53, 0x65, 0x74, + 0x2e, 0x52, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45, 0x6e, + 0x63, 0x6f, 0x64, 0x69, 0x6e, 0x67, 0x42, 0x27, 0x88, 0x01, 0x01, 0x98, 0x01, 0x04, 0x98, 0x01, + 0x01, 0xa2, 0x01, 0x0d, 0x12, 0x08, 0x45, 0x58, 0x50, 0x41, 0x4e, 0x44, 0x45, 0x44, 0x18, 0xe6, + 0x07, 0xa2, 0x01, 0x0b, 0x12, 0x06, 0x50, 0x41, 0x43, 0x4b, 0x45, 0x44, 0x18, 0xe7, 0x07, 0x52, + 0x15, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45, 0x6e, + 0x63, 0x6f, 0x64, 0x69, 0x6e, 0x67, 0x12, 0x78, 0x0a, 0x0f, 0x75, 0x74, 0x66, 0x38, 0x5f, 0x76, + 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, + 0x2a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, + 0x66, 0x2e, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x53, 0x65, 0x74, 0x2e, 0x55, 0x74, 0x66, + 0x38, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x23, 0x88, 0x01, 0x01, + 0x98, 0x01, 0x04, 0x98, 0x01, 0x01, 0xa2, 0x01, 0x09, 0x12, 0x04, 0x4e, 0x4f, 0x4e, 0x45, 0x18, + 0xe6, 0x07, 0xa2, 0x01, 0x0b, 0x12, 0x06, 0x56, 0x45, 0x52, 0x49, 0x46, 0x59, 0x18, 0xe7, 0x07, + 0x52, 0x0e, 0x75, 0x74, 0x66, 0x38, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x12, 0x78, 0x0a, 0x10, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x65, 0x6e, 0x63, 0x6f, + 0x64, 0x69, 0x6e, 0x67, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2b, 0x2e, 0x67, 0x6f, 0x6f, + 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x65, 0x61, + 0x74, 0x75, 0x72, 0x65, 0x53, 0x65, 0x74, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x45, + 0x6e, 0x63, 0x6f, 0x64, 0x69, 0x6e, 0x67, 0x42, 0x20, 0x88, 0x01, 0x01, 0x98, 0x01, 0x04, 0x98, + 0x01, 0x01, 0xa2, 0x01, 0x14, 0x12, 0x0f, 0x4c, 0x45, 0x4e, 0x47, 0x54, 0x48, 0x5f, 0x50, 0x52, + 0x45, 0x46, 0x49, 0x58, 0x45, 0x44, 0x18, 0xe6, 0x07, 0x52, 0x0f, 0x6d, 0x65, 0x73, 0x73, 0x61, + 0x67, 0x65, 0x45, 0x6e, 0x63, 0x6f, 0x64, 0x69, 0x6e, 0x67, 0x12, 0x7c, 0x0a, 0x0b, 0x6a, 0x73, + 0x6f, 0x6e, 0x5f, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0e, 0x32, + 0x26, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, + 0x66, 0x2e, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x53, 0x65, 0x74, 0x2e, 0x4a, 0x73, 0x6f, + 0x6e, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x42, 0x33, 0x88, 0x01, 0x01, 0x98, 0x01, 0x03, 0x98, + 0x01, 0x06, 0x98, 0x01, 0x01, 0xa2, 0x01, 0x17, 0x12, 0x12, 0x4c, 0x45, 0x47, 0x41, 0x43, 0x59, + 0x5f, 0x42, 0x45, 0x53, 0x54, 0x5f, 0x45, 0x46, 0x46, 0x4f, 0x52, 0x54, 0x18, 0xe6, 0x07, 0xa2, + 0x01, 0x0a, 0x12, 0x05, 0x41, 0x4c, 0x4c, 0x4f, 0x57, 0x18, 0xe7, 0x07, 0x52, 0x0a, 0x6a, 0x73, + 0x6f, 0x6e, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x22, 0x5c, 0x0a, 0x0d, 0x46, 0x69, 0x65, 0x6c, + 0x64, 0x50, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x63, 0x65, 0x12, 0x1a, 0x0a, 0x16, 0x46, 0x49, 0x45, + 0x4c, 0x44, 0x5f, 0x50, 0x52, 0x45, 0x53, 0x45, 0x4e, 0x43, 0x45, 0x5f, 0x55, 0x4e, 0x4b, 0x4e, + 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x0c, 0x0a, 0x08, 0x45, 0x58, 0x50, 0x4c, 0x49, 0x43, 0x49, + 0x54, 0x10, 0x01, 0x12, 0x0c, 0x0a, 0x08, 0x49, 0x4d, 0x50, 0x4c, 0x49, 0x43, 0x49, 0x54, 0x10, + 0x02, 0x12, 0x13, 0x0a, 0x0f, 0x4c, 0x45, 0x47, 0x41, 0x43, 0x59, 0x5f, 0x52, 0x45, 0x51, 0x55, + 0x49, 0x52, 0x45, 0x44, 0x10, 0x03, 0x22, 0x37, 0x0a, 0x08, 0x45, 0x6e, 0x75, 0x6d, 0x54, 0x79, + 0x70, 0x65, 0x12, 0x15, 0x0a, 0x11, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, + 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x08, 0x0a, 0x04, 0x4f, 0x50, 0x45, + 0x4e, 0x10, 0x01, 0x12, 0x0a, 0x0a, 0x06, 0x43, 0x4c, 0x4f, 0x53, 0x45, 0x44, 0x10, 0x02, 0x22, + 0x56, 0x0a, 0x15, 0x52, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x46, 0x69, 0x65, 0x6c, 0x64, + 0x45, 0x6e, 0x63, 0x6f, 0x64, 0x69, 0x6e, 0x67, 0x12, 0x23, 0x0a, 0x1f, 0x52, 0x45, 0x50, 0x45, + 0x41, 0x54, 0x45, 0x44, 0x5f, 0x46, 0x49, 0x45, 0x4c, 0x44, 0x5f, 0x45, 0x4e, 0x43, 0x4f, 0x44, + 0x49, 0x4e, 0x47, 0x5f, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x0a, 0x0a, + 0x06, 0x50, 0x41, 0x43, 0x4b, 0x45, 0x44, 0x10, 0x01, 0x12, 0x0c, 0x0a, 0x08, 0x45, 0x58, 0x50, + 0x41, 0x4e, 0x44, 0x45, 0x44, 0x10, 0x02, 0x22, 0x43, 0x0a, 0x0e, 0x55, 0x74, 0x66, 0x38, 0x56, + 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1b, 0x0a, 0x17, 0x55, 0x54, 0x46, + 0x38, 0x5f, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x55, 0x4e, 0x4b, + 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x0a, 0x0a, 0x06, 0x56, 0x45, 0x52, 0x49, 0x46, 0x59, + 0x10, 0x02, 0x12, 0x08, 0x0a, 0x04, 0x4e, 0x4f, 0x4e, 0x45, 0x10, 0x03, 0x22, 0x53, 0x0a, 0x0f, + 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x45, 0x6e, 0x63, 0x6f, 0x64, 0x69, 0x6e, 0x67, 0x12, + 0x1c, 0x0a, 0x18, 0x4d, 0x45, 0x53, 0x53, 0x41, 0x47, 0x45, 0x5f, 0x45, 0x4e, 0x43, 0x4f, 0x44, + 0x49, 0x4e, 0x47, 0x5f, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x13, 0x0a, + 0x0f, 0x4c, 0x45, 0x4e, 0x47, 0x54, 0x48, 0x5f, 0x50, 0x52, 0x45, 0x46, 0x49, 0x58, 0x45, 0x44, + 0x10, 0x01, 0x12, 0x0d, 0x0a, 0x09, 0x44, 0x45, 0x4c, 0x49, 0x4d, 0x49, 0x54, 0x45, 0x44, 0x10, + 0x02, 0x22, 0x48, 0x0a, 0x0a, 0x4a, 0x73, 0x6f, 0x6e, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x12, + 0x17, 0x0a, 0x13, 0x4a, 0x53, 0x4f, 0x4e, 0x5f, 0x46, 0x4f, 0x52, 0x4d, 0x41, 0x54, 0x5f, 0x55, + 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x09, 0x0a, 0x05, 0x41, 0x4c, 0x4c, 0x4f, + 0x57, 0x10, 0x01, 0x12, 0x16, 0x0a, 0x12, 0x4c, 0x45, 0x47, 0x41, 0x43, 0x59, 0x5f, 0x42, 0x45, + 0x53, 0x54, 0x5f, 0x45, 0x46, 0x46, 0x4f, 0x52, 0x54, 0x10, 0x02, 0x2a, 0x06, 0x08, 0xe8, 0x07, + 0x10, 0xe9, 0x07, 0x2a, 0x06, 0x08, 0xe9, 0x07, 0x10, 0xea, 0x07, 0x2a, 0x06, 0x08, 0xea, 0x07, + 0x10, 0xeb, 0x07, 0x2a, 0x06, 0x08, 0x8b, 0x4e, 0x10, 0x90, 0x4e, 0x2a, 0x06, 0x08, 0x90, 0x4e, + 0x10, 0x91, 0x4e, 0x4a, 0x06, 0x08, 0xe7, 0x07, 0x10, 0xe8, 0x07, 0x22, 0xfe, 0x02, 0x0a, 0x12, + 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x53, 0x65, 0x74, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6c, + 0x74, 0x73, 0x12, 0x58, 0x0a, 0x08, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x73, 0x18, 0x01, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3c, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x53, 0x65, + 0x74, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x73, 0x2e, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, + 0x65, 0x53, 0x65, 0x74, 0x45, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x66, 0x61, 0x75, + 0x6c, 0x74, 0x52, 0x08, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x73, 0x12, 0x41, 0x0a, 0x0f, + 0x6d, 0x69, 0x6e, 0x69, 0x6d, 0x75, 0x6d, 0x5f, 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, + 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x18, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, + 0x0e, 0x6d, 0x69, 0x6e, 0x69, 0x6d, 0x75, 0x6d, 0x45, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, + 0x41, 0x0a, 0x0f, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x5f, 0x65, 0x64, 0x69, 0x74, 0x69, + 0x6f, 0x6e, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x18, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, + 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x64, 0x69, 0x74, 0x69, + 0x6f, 0x6e, 0x52, 0x0e, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x45, 0x64, 0x69, 0x74, 0x69, + 0x6f, 0x6e, 0x1a, 0x87, 0x01, 0x0a, 0x18, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x53, 0x65, + 0x74, 0x45, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x12, + 0x32, 0x0a, 0x07, 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, + 0x32, 0x18, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, + 0x75, 0x66, 0x2e, 0x45, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x07, 0x65, 0x64, 0x69, 0x74, + 0x69, 0x6f, 0x6e, 0x12, 0x37, 0x0a, 0x08, 0x66, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x53, + 0x65, 0x74, 0x52, 0x08, 0x66, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x22, 0xa7, 0x02, 0x0a, + 0x0e, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x43, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x12, + 0x44, 0x0a, 0x08, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x28, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x62, 0x75, 0x66, 0x2e, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x43, 0x6f, 0x64, 0x65, 0x49, 0x6e, + 0x66, 0x6f, 0x2e, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x08, 0x6c, 0x6f, 0x63, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x1a, 0xce, 0x01, 0x0a, 0x08, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x12, 0x16, 0x0a, 0x04, 0x70, 0x61, 0x74, 0x68, 0x18, 0x01, 0x20, 0x03, 0x28, 0x05, + 0x42, 0x02, 0x10, 0x01, 0x52, 0x04, 0x70, 0x61, 0x74, 0x68, 0x12, 0x16, 0x0a, 0x04, 0x73, 0x70, + 0x61, 0x6e, 0x18, 0x02, 0x20, 0x03, 0x28, 0x05, 0x42, 0x02, 0x10, 0x01, 0x52, 0x04, 0x73, 0x70, + 0x61, 0x6e, 0x12, 0x29, 0x0a, 0x10, 0x6c, 0x65, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x63, 0x6f, + 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x6c, 0x65, + 0x61, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x2b, 0x0a, + 0x11, 0x74, 0x72, 0x61, 0x69, 0x6c, 0x69, 0x6e, 0x67, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, + 0x74, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x74, 0x72, 0x61, 0x69, 0x6c, 0x69, + 0x6e, 0x67, 0x43, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x3a, 0x0a, 0x19, 0x6c, 0x65, + 0x61, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x63, 0x68, 0x65, 0x64, 0x5f, 0x63, + 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x09, 0x52, 0x17, 0x6c, + 0x65, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x65, 0x74, 0x61, 0x63, 0x68, 0x65, 0x64, 0x43, 0x6f, + 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x22, 0xd0, 0x02, 0x0a, 0x11, 0x47, 0x65, 0x6e, 0x65, 0x72, + 0x61, 0x74, 0x65, 0x64, 0x43, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x4d, 0x0a, 0x0a, + 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x2d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, + 0x75, 0x66, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x43, 0x6f, 0x64, 0x65, + 0x49, 0x6e, 0x66, 0x6f, 0x2e, 0x41, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, + 0x0a, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x1a, 0xeb, 0x01, 0x0a, 0x0a, + 0x41, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x16, 0x0a, 0x04, 0x70, 0x61, + 0x74, 0x68, 0x18, 0x01, 0x20, 0x03, 0x28, 0x05, 0x42, 0x02, 0x10, 0x01, 0x52, 0x04, 0x70, 0x61, + 0x74, 0x68, 0x12, 0x1f, 0x0a, 0x0b, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x66, 0x69, 0x6c, + 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x46, + 0x69, 0x6c, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x62, 0x65, 0x67, 0x69, 0x6e, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x05, 0x52, 0x05, 0x62, 0x65, 0x67, 0x69, 0x6e, 0x12, 0x10, 0x0a, 0x03, 0x65, 0x6e, 0x64, + 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x65, 0x6e, 0x64, 0x12, 0x52, 0x0a, 0x08, 0x73, + 0x65, 0x6d, 0x61, 0x6e, 0x74, 0x69, 0x63, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x36, 0x2e, + 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, + 0x47, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x43, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, + 0x6f, 0x2e, 0x41, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x53, 0x65, 0x6d, + 0x61, 0x6e, 0x74, 0x69, 0x63, 0x52, 0x08, 0x73, 0x65, 0x6d, 0x61, 0x6e, 0x74, 0x69, 0x63, 0x22, + 0x28, 0x0a, 0x08, 0x53, 0x65, 0x6d, 0x61, 0x6e, 0x74, 0x69, 0x63, 0x12, 0x08, 0x0a, 0x04, 0x4e, + 0x4f, 0x4e, 0x45, 0x10, 0x00, 0x12, 0x07, 0x0a, 0x03, 0x53, 0x45, 0x54, 0x10, 0x01, 0x12, 0x09, + 0x0a, 0x05, 0x41, 0x4c, 0x49, 0x41, 0x53, 0x10, 0x02, 0x2a, 0x92, 0x02, 0x0a, 0x07, 0x45, 0x64, + 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x44, 0x49, 0x54, 0x49, 0x4f, 0x4e, + 0x5f, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x13, 0x0a, 0x0e, 0x45, 0x44, + 0x49, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, 0x52, 0x4f, 0x54, 0x4f, 0x32, 0x10, 0xe6, 0x07, 0x12, + 0x13, 0x0a, 0x0e, 0x45, 0x44, 0x49, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, 0x52, 0x4f, 0x54, 0x4f, + 0x33, 0x10, 0xe7, 0x07, 0x12, 0x11, 0x0a, 0x0c, 0x45, 0x44, 0x49, 0x54, 0x49, 0x4f, 0x4e, 0x5f, + 0x32, 0x30, 0x32, 0x33, 0x10, 0xe8, 0x07, 0x12, 0x11, 0x0a, 0x0c, 0x45, 0x44, 0x49, 0x54, 0x49, + 0x4f, 0x4e, 0x5f, 0x32, 0x30, 0x32, 0x34, 0x10, 0xe9, 0x07, 0x12, 0x17, 0x0a, 0x13, 0x45, 0x44, + 0x49, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x31, 0x5f, 0x54, 0x45, 0x53, 0x54, 0x5f, 0x4f, 0x4e, 0x4c, + 0x59, 0x10, 0x01, 0x12, 0x17, 0x0a, 0x13, 0x45, 0x44, 0x49, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x32, + 0x5f, 0x54, 0x45, 0x53, 0x54, 0x5f, 0x4f, 0x4e, 0x4c, 0x59, 0x10, 0x02, 0x12, 0x1d, 0x0a, 0x17, + 0x45, 0x44, 0x49, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x39, 0x39, 0x39, 0x39, 0x37, 0x5f, 0x54, 0x45, + 0x53, 0x54, 0x5f, 0x4f, 0x4e, 0x4c, 0x59, 0x10, 0x9d, 0x8d, 0x06, 0x12, 0x1d, 0x0a, 0x17, 0x45, + 0x44, 0x49, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x39, 0x39, 0x39, 0x39, 0x38, 0x5f, 0x54, 0x45, 0x53, + 0x54, 0x5f, 0x4f, 0x4e, 0x4c, 0x59, 0x10, 0x9e, 0x8d, 0x06, 0x12, 0x1d, 0x0a, 0x17, 0x45, 0x44, + 0x49, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x39, 0x39, 0x39, 0x39, 0x39, 0x5f, 0x54, 0x45, 0x53, 0x54, + 0x5f, 0x4f, 0x4e, 0x4c, 0x59, 0x10, 0x9f, 0x8d, 0x06, 0x12, 0x13, 0x0a, 0x0b, 0x45, 0x44, 0x49, + 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x4d, 0x41, 0x58, 0x10, 0xff, 0xff, 0xff, 0xff, 0x07, 0x42, 0x7e, + 0x0a, 0x13, 0x63, 0x6f, 0x6d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x62, 0x75, 0x66, 0x42, 0x10, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, + 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0x48, 0x01, 0x5a, 0x2d, 0x67, 0x6f, 0x6f, 0x67, 0x6c, + 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2f, 0x64, 0x65, 0x73, 0x63, + 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x70, 0x62, 0xf8, 0x01, 0x01, 0xa2, 0x02, 0x03, 0x47, 0x50, + 0x42, 0xaa, 0x02, 0x1a, 0x47, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x50, 0x72, 0x6f, 0x74, 0x6f, + 0x62, 0x75, 0x66, 0x2e, 0x52, 0x65, 0x66, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, +} + +var ( + file_google_protobuf_descriptor_proto_rawDescOnce sync.Once + file_google_protobuf_descriptor_proto_rawDescData = file_google_protobuf_descriptor_proto_rawDesc +) + +func file_google_protobuf_descriptor_proto_rawDescGZIP() []byte { + file_google_protobuf_descriptor_proto_rawDescOnce.Do(func() { + file_google_protobuf_descriptor_proto_rawDescData = protoimpl.X.CompressGZIP(file_google_protobuf_descriptor_proto_rawDescData) + }) + return file_google_protobuf_descriptor_proto_rawDescData +} + +var file_google_protobuf_descriptor_proto_enumTypes = make([]protoimpl.EnumInfo, 17) +var file_google_protobuf_descriptor_proto_msgTypes = make([]protoimpl.MessageInfo, 32) +var file_google_protobuf_descriptor_proto_goTypes = []interface{}{ + (Edition)(0), // 0: google.protobuf.Edition + (ExtensionRangeOptions_VerificationState)(0), // 1: google.protobuf.ExtensionRangeOptions.VerificationState + (FieldDescriptorProto_Type)(0), // 2: google.protobuf.FieldDescriptorProto.Type + (FieldDescriptorProto_Label)(0), // 3: google.protobuf.FieldDescriptorProto.Label + (FileOptions_OptimizeMode)(0), // 4: google.protobuf.FileOptions.OptimizeMode + (FieldOptions_CType)(0), // 5: google.protobuf.FieldOptions.CType + (FieldOptions_JSType)(0), // 6: google.protobuf.FieldOptions.JSType + (FieldOptions_OptionRetention)(0), // 7: google.protobuf.FieldOptions.OptionRetention + (FieldOptions_OptionTargetType)(0), // 8: google.protobuf.FieldOptions.OptionTargetType + (MethodOptions_IdempotencyLevel)(0), // 9: google.protobuf.MethodOptions.IdempotencyLevel + (FeatureSet_FieldPresence)(0), // 10: google.protobuf.FeatureSet.FieldPresence + (FeatureSet_EnumType)(0), // 11: google.protobuf.FeatureSet.EnumType + (FeatureSet_RepeatedFieldEncoding)(0), // 12: google.protobuf.FeatureSet.RepeatedFieldEncoding + (FeatureSet_Utf8Validation)(0), // 13: google.protobuf.FeatureSet.Utf8Validation + (FeatureSet_MessageEncoding)(0), // 14: google.protobuf.FeatureSet.MessageEncoding + (FeatureSet_JsonFormat)(0), // 15: google.protobuf.FeatureSet.JsonFormat + (GeneratedCodeInfo_Annotation_Semantic)(0), // 16: google.protobuf.GeneratedCodeInfo.Annotation.Semantic + (*FileDescriptorSet)(nil), // 17: google.protobuf.FileDescriptorSet + (*FileDescriptorProto)(nil), // 18: google.protobuf.FileDescriptorProto + (*DescriptorProto)(nil), // 19: google.protobuf.DescriptorProto + (*ExtensionRangeOptions)(nil), // 20: google.protobuf.ExtensionRangeOptions + (*FieldDescriptorProto)(nil), // 21: google.protobuf.FieldDescriptorProto + (*OneofDescriptorProto)(nil), // 22: google.protobuf.OneofDescriptorProto + (*EnumDescriptorProto)(nil), // 23: google.protobuf.EnumDescriptorProto + (*EnumValueDescriptorProto)(nil), // 24: google.protobuf.EnumValueDescriptorProto + (*ServiceDescriptorProto)(nil), // 25: google.protobuf.ServiceDescriptorProto + (*MethodDescriptorProto)(nil), // 26: google.protobuf.MethodDescriptorProto + (*FileOptions)(nil), // 27: google.protobuf.FileOptions + (*MessageOptions)(nil), // 28: google.protobuf.MessageOptions + (*FieldOptions)(nil), // 29: google.protobuf.FieldOptions + (*OneofOptions)(nil), // 30: google.protobuf.OneofOptions + (*EnumOptions)(nil), // 31: google.protobuf.EnumOptions + (*EnumValueOptions)(nil), // 32: google.protobuf.EnumValueOptions + (*ServiceOptions)(nil), // 33: google.protobuf.ServiceOptions + (*MethodOptions)(nil), // 34: google.protobuf.MethodOptions + (*UninterpretedOption)(nil), // 35: google.protobuf.UninterpretedOption + (*FeatureSet)(nil), // 36: google.protobuf.FeatureSet + (*FeatureSetDefaults)(nil), // 37: google.protobuf.FeatureSetDefaults + (*SourceCodeInfo)(nil), // 38: google.protobuf.SourceCodeInfo + (*GeneratedCodeInfo)(nil), // 39: google.protobuf.GeneratedCodeInfo + (*DescriptorProto_ExtensionRange)(nil), // 40: google.protobuf.DescriptorProto.ExtensionRange + (*DescriptorProto_ReservedRange)(nil), // 41: google.protobuf.DescriptorProto.ReservedRange + (*ExtensionRangeOptions_Declaration)(nil), // 42: google.protobuf.ExtensionRangeOptions.Declaration + (*EnumDescriptorProto_EnumReservedRange)(nil), // 43: google.protobuf.EnumDescriptorProto.EnumReservedRange + (*FieldOptions_EditionDefault)(nil), // 44: google.protobuf.FieldOptions.EditionDefault + (*UninterpretedOption_NamePart)(nil), // 45: google.protobuf.UninterpretedOption.NamePart + (*FeatureSetDefaults_FeatureSetEditionDefault)(nil), // 46: google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault + (*SourceCodeInfo_Location)(nil), // 47: google.protobuf.SourceCodeInfo.Location + (*GeneratedCodeInfo_Annotation)(nil), // 48: google.protobuf.GeneratedCodeInfo.Annotation +} +var file_google_protobuf_descriptor_proto_depIdxs = []int32{ + 18, // 0: google.protobuf.FileDescriptorSet.file:type_name -> google.protobuf.FileDescriptorProto + 19, // 1: google.protobuf.FileDescriptorProto.message_type:type_name -> google.protobuf.DescriptorProto + 23, // 2: google.protobuf.FileDescriptorProto.enum_type:type_name -> google.protobuf.EnumDescriptorProto + 25, // 3: google.protobuf.FileDescriptorProto.service:type_name -> google.protobuf.ServiceDescriptorProto + 21, // 4: google.protobuf.FileDescriptorProto.extension:type_name -> google.protobuf.FieldDescriptorProto + 27, // 5: google.protobuf.FileDescriptorProto.options:type_name -> google.protobuf.FileOptions + 38, // 6: google.protobuf.FileDescriptorProto.source_code_info:type_name -> google.protobuf.SourceCodeInfo + 0, // 7: google.protobuf.FileDescriptorProto.edition:type_name -> google.protobuf.Edition + 21, // 8: google.protobuf.DescriptorProto.field:type_name -> google.protobuf.FieldDescriptorProto + 21, // 9: google.protobuf.DescriptorProto.extension:type_name -> google.protobuf.FieldDescriptorProto + 19, // 10: google.protobuf.DescriptorProto.nested_type:type_name -> google.protobuf.DescriptorProto + 23, // 11: google.protobuf.DescriptorProto.enum_type:type_name -> google.protobuf.EnumDescriptorProto + 40, // 12: google.protobuf.DescriptorProto.extension_range:type_name -> google.protobuf.DescriptorProto.ExtensionRange + 22, // 13: google.protobuf.DescriptorProto.oneof_decl:type_name -> google.protobuf.OneofDescriptorProto + 28, // 14: google.protobuf.DescriptorProto.options:type_name -> google.protobuf.MessageOptions + 41, // 15: google.protobuf.DescriptorProto.reserved_range:type_name -> google.protobuf.DescriptorProto.ReservedRange + 35, // 16: google.protobuf.ExtensionRangeOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption + 42, // 17: google.protobuf.ExtensionRangeOptions.declaration:type_name -> google.protobuf.ExtensionRangeOptions.Declaration + 36, // 18: google.protobuf.ExtensionRangeOptions.features:type_name -> google.protobuf.FeatureSet + 1, // 19: google.protobuf.ExtensionRangeOptions.verification:type_name -> google.protobuf.ExtensionRangeOptions.VerificationState + 3, // 20: google.protobuf.FieldDescriptorProto.label:type_name -> google.protobuf.FieldDescriptorProto.Label + 2, // 21: google.protobuf.FieldDescriptorProto.type:type_name -> google.protobuf.FieldDescriptorProto.Type + 29, // 22: google.protobuf.FieldDescriptorProto.options:type_name -> google.protobuf.FieldOptions + 30, // 23: google.protobuf.OneofDescriptorProto.options:type_name -> google.protobuf.OneofOptions + 24, // 24: google.protobuf.EnumDescriptorProto.value:type_name -> google.protobuf.EnumValueDescriptorProto + 31, // 25: google.protobuf.EnumDescriptorProto.options:type_name -> google.protobuf.EnumOptions + 43, // 26: google.protobuf.EnumDescriptorProto.reserved_range:type_name -> google.protobuf.EnumDescriptorProto.EnumReservedRange + 32, // 27: google.protobuf.EnumValueDescriptorProto.options:type_name -> google.protobuf.EnumValueOptions + 26, // 28: google.protobuf.ServiceDescriptorProto.method:type_name -> google.protobuf.MethodDescriptorProto + 33, // 29: google.protobuf.ServiceDescriptorProto.options:type_name -> google.protobuf.ServiceOptions + 34, // 30: google.protobuf.MethodDescriptorProto.options:type_name -> google.protobuf.MethodOptions + 4, // 31: google.protobuf.FileOptions.optimize_for:type_name -> google.protobuf.FileOptions.OptimizeMode + 36, // 32: google.protobuf.FileOptions.features:type_name -> google.protobuf.FeatureSet + 35, // 33: google.protobuf.FileOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption + 36, // 34: google.protobuf.MessageOptions.features:type_name -> google.protobuf.FeatureSet + 35, // 35: google.protobuf.MessageOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption + 5, // 36: google.protobuf.FieldOptions.ctype:type_name -> google.protobuf.FieldOptions.CType + 6, // 37: google.protobuf.FieldOptions.jstype:type_name -> google.protobuf.FieldOptions.JSType + 7, // 38: google.protobuf.FieldOptions.retention:type_name -> google.protobuf.FieldOptions.OptionRetention + 8, // 39: google.protobuf.FieldOptions.targets:type_name -> google.protobuf.FieldOptions.OptionTargetType + 44, // 40: google.protobuf.FieldOptions.edition_defaults:type_name -> google.protobuf.FieldOptions.EditionDefault + 36, // 41: google.protobuf.FieldOptions.features:type_name -> google.protobuf.FeatureSet + 35, // 42: google.protobuf.FieldOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption + 36, // 43: google.protobuf.OneofOptions.features:type_name -> google.protobuf.FeatureSet + 35, // 44: google.protobuf.OneofOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption + 36, // 45: google.protobuf.EnumOptions.features:type_name -> google.protobuf.FeatureSet + 35, // 46: google.protobuf.EnumOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption + 36, // 47: google.protobuf.EnumValueOptions.features:type_name -> google.protobuf.FeatureSet + 35, // 48: google.protobuf.EnumValueOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption + 36, // 49: google.protobuf.ServiceOptions.features:type_name -> google.protobuf.FeatureSet + 35, // 50: google.protobuf.ServiceOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption + 9, // 51: google.protobuf.MethodOptions.idempotency_level:type_name -> google.protobuf.MethodOptions.IdempotencyLevel + 36, // 52: google.protobuf.MethodOptions.features:type_name -> google.protobuf.FeatureSet + 35, // 53: google.protobuf.MethodOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption + 45, // 54: google.protobuf.UninterpretedOption.name:type_name -> google.protobuf.UninterpretedOption.NamePart + 10, // 55: google.protobuf.FeatureSet.field_presence:type_name -> google.protobuf.FeatureSet.FieldPresence + 11, // 56: google.protobuf.FeatureSet.enum_type:type_name -> google.protobuf.FeatureSet.EnumType + 12, // 57: google.protobuf.FeatureSet.repeated_field_encoding:type_name -> google.protobuf.FeatureSet.RepeatedFieldEncoding + 13, // 58: google.protobuf.FeatureSet.utf8_validation:type_name -> google.protobuf.FeatureSet.Utf8Validation + 14, // 59: google.protobuf.FeatureSet.message_encoding:type_name -> google.protobuf.FeatureSet.MessageEncoding + 15, // 60: google.protobuf.FeatureSet.json_format:type_name -> google.protobuf.FeatureSet.JsonFormat + 46, // 61: google.protobuf.FeatureSetDefaults.defaults:type_name -> google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault + 0, // 62: google.protobuf.FeatureSetDefaults.minimum_edition:type_name -> google.protobuf.Edition + 0, // 63: google.protobuf.FeatureSetDefaults.maximum_edition:type_name -> google.protobuf.Edition + 47, // 64: google.protobuf.SourceCodeInfo.location:type_name -> google.protobuf.SourceCodeInfo.Location + 48, // 65: google.protobuf.GeneratedCodeInfo.annotation:type_name -> google.protobuf.GeneratedCodeInfo.Annotation + 20, // 66: google.protobuf.DescriptorProto.ExtensionRange.options:type_name -> google.protobuf.ExtensionRangeOptions + 0, // 67: google.protobuf.FieldOptions.EditionDefault.edition:type_name -> google.protobuf.Edition + 0, // 68: google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault.edition:type_name -> google.protobuf.Edition + 36, // 69: google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault.features:type_name -> google.protobuf.FeatureSet + 16, // 70: google.protobuf.GeneratedCodeInfo.Annotation.semantic:type_name -> google.protobuf.GeneratedCodeInfo.Annotation.Semantic + 71, // [71:71] is the sub-list for method output_type + 71, // [71:71] is the sub-list for method input_type + 71, // [71:71] is the sub-list for extension type_name + 71, // [71:71] is the sub-list for extension extendee + 0, // [0:71] is the sub-list for field type_name +} + +func init() { file_google_protobuf_descriptor_proto_init() } +func file_google_protobuf_descriptor_proto_init() { + if File_google_protobuf_descriptor_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_google_protobuf_descriptor_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*FileDescriptorSet); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_google_protobuf_descriptor_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*FileDescriptorProto); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_google_protobuf_descriptor_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DescriptorProto); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_google_protobuf_descriptor_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ExtensionRangeOptions); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + case 3: + return &v.extensionFields + default: + return nil + } + } + file_google_protobuf_descriptor_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*FieldDescriptorProto); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_google_protobuf_descriptor_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*OneofDescriptorProto); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_google_protobuf_descriptor_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*EnumDescriptorProto); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_google_protobuf_descriptor_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*EnumValueDescriptorProto); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_google_protobuf_descriptor_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ServiceDescriptorProto); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_google_protobuf_descriptor_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MethodDescriptorProto); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_google_protobuf_descriptor_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*FileOptions); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + case 3: + return &v.extensionFields + default: + return nil + } + } + file_google_protobuf_descriptor_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MessageOptions); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + case 3: + return &v.extensionFields + default: + return nil + } + } + file_google_protobuf_descriptor_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*FieldOptions); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + case 3: + return &v.extensionFields + default: + return nil + } + } + file_google_protobuf_descriptor_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*OneofOptions); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + case 3: + return &v.extensionFields + default: + return nil + } + } + file_google_protobuf_descriptor_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*EnumOptions); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + case 3: + return &v.extensionFields + default: + return nil + } + } + file_google_protobuf_descriptor_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*EnumValueOptions); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + case 3: + return &v.extensionFields + default: + return nil + } + } + file_google_protobuf_descriptor_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ServiceOptions); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + case 3: + return &v.extensionFields + default: + return nil + } + } + file_google_protobuf_descriptor_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MethodOptions); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + case 3: + return &v.extensionFields + default: + return nil + } + } + file_google_protobuf_descriptor_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*UninterpretedOption); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_google_protobuf_descriptor_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*FeatureSet); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + case 3: + return &v.extensionFields + default: + return nil + } + } + file_google_protobuf_descriptor_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*FeatureSetDefaults); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_google_protobuf_descriptor_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SourceCodeInfo); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_google_protobuf_descriptor_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GeneratedCodeInfo); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_google_protobuf_descriptor_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DescriptorProto_ExtensionRange); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_google_protobuf_descriptor_proto_msgTypes[24].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DescriptorProto_ReservedRange); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_google_protobuf_descriptor_proto_msgTypes[25].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ExtensionRangeOptions_Declaration); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_google_protobuf_descriptor_proto_msgTypes[26].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*EnumDescriptorProto_EnumReservedRange); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_google_protobuf_descriptor_proto_msgTypes[27].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*FieldOptions_EditionDefault); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_google_protobuf_descriptor_proto_msgTypes[28].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*UninterpretedOption_NamePart); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_google_protobuf_descriptor_proto_msgTypes[29].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*FeatureSetDefaults_FeatureSetEditionDefault); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_google_protobuf_descriptor_proto_msgTypes[30].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SourceCodeInfo_Location); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_google_protobuf_descriptor_proto_msgTypes[31].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GeneratedCodeInfo_Annotation); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_google_protobuf_descriptor_proto_rawDesc, + NumEnums: 17, + NumMessages: 32, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_google_protobuf_descriptor_proto_goTypes, + DependencyIndexes: file_google_protobuf_descriptor_proto_depIdxs, + EnumInfos: file_google_protobuf_descriptor_proto_enumTypes, + MessageInfos: file_google_protobuf_descriptor_proto_msgTypes, + }.Build() + File_google_protobuf_descriptor_proto = out.File + file_google_protobuf_descriptor_proto_rawDesc = nil + file_google_protobuf_descriptor_proto_goTypes = nil + file_google_protobuf_descriptor_proto_depIdxs = nil +} diff --git a/services/vendor/google.golang.org/protobuf/types/gofeaturespb/go_features.pb.go b/services/vendor/google.golang.org/protobuf/types/gofeaturespb/go_features.pb.go new file mode 100644 index 00000000..25de5ae0 --- /dev/null +++ b/services/vendor/google.golang.org/protobuf/types/gofeaturespb/go_features.pb.go @@ -0,0 +1,177 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2023 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +// Code generated by protoc-gen-go. DO NOT EDIT. +// source: reflect/protodesc/proto/go_features.proto + +package proto + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + descriptorpb "google.golang.org/protobuf/types/descriptorpb" + reflect "reflect" + sync "sync" +) + +type GoFeatures struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Whether or not to generate the deprecated UnmarshalJSON method for enums. + LegacyUnmarshalJsonEnum *bool `protobuf:"varint,1,opt,name=legacy_unmarshal_json_enum,json=legacyUnmarshalJsonEnum" json:"legacy_unmarshal_json_enum,omitempty"` +} + +func (x *GoFeatures) Reset() { + *x = GoFeatures{} + if protoimpl.UnsafeEnabled { + mi := &file_reflect_protodesc_proto_go_features_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GoFeatures) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GoFeatures) ProtoMessage() {} + +func (x *GoFeatures) ProtoReflect() protoreflect.Message { + mi := &file_reflect_protodesc_proto_go_features_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GoFeatures.ProtoReflect.Descriptor instead. +func (*GoFeatures) Descriptor() ([]byte, []int) { + return file_reflect_protodesc_proto_go_features_proto_rawDescGZIP(), []int{0} +} + +func (x *GoFeatures) GetLegacyUnmarshalJsonEnum() bool { + if x != nil && x.LegacyUnmarshalJsonEnum != nil { + return *x.LegacyUnmarshalJsonEnum + } + return false +} + +var file_reflect_protodesc_proto_go_features_proto_extTypes = []protoimpl.ExtensionInfo{ + { + ExtendedType: (*descriptorpb.FeatureSet)(nil), + ExtensionType: (*GoFeatures)(nil), + Field: 1002, + Name: "google.protobuf.go", + Tag: "bytes,1002,opt,name=go", + Filename: "reflect/protodesc/proto/go_features.proto", + }, +} + +// Extension fields to descriptorpb.FeatureSet. +var ( + // optional google.protobuf.GoFeatures go = 1002; + E_Go = &file_reflect_protodesc_proto_go_features_proto_extTypes[0] +) + +var File_reflect_protodesc_proto_go_features_proto protoreflect.FileDescriptor + +var file_reflect_protodesc_proto_go_features_proto_rawDesc = []byte{ + 0x0a, 0x29, 0x72, 0x65, 0x66, 0x6c, 0x65, 0x63, 0x74, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x64, + 0x65, 0x73, 0x63, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x67, 0x6f, 0x5f, 0x66, 0x65, 0x61, + 0x74, 0x75, 0x72, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0f, 0x67, 0x6f, 0x6f, + 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x1a, 0x20, 0x67, 0x6f, + 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x64, 0x65, + 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x6a, + 0x0a, 0x0a, 0x47, 0x6f, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x12, 0x5c, 0x0a, 0x1a, + 0x6c, 0x65, 0x67, 0x61, 0x63, 0x79, 0x5f, 0x75, 0x6e, 0x6d, 0x61, 0x72, 0x73, 0x68, 0x61, 0x6c, + 0x5f, 0x6a, 0x73, 0x6f, 0x6e, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, + 0x42, 0x1f, 0x88, 0x01, 0x01, 0x98, 0x01, 0x06, 0xa2, 0x01, 0x09, 0x12, 0x04, 0x74, 0x72, 0x75, + 0x65, 0x18, 0xe6, 0x07, 0xa2, 0x01, 0x0a, 0x12, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x18, 0xe7, + 0x07, 0x52, 0x17, 0x6c, 0x65, 0x67, 0x61, 0x63, 0x79, 0x55, 0x6e, 0x6d, 0x61, 0x72, 0x73, 0x68, + 0x61, 0x6c, 0x4a, 0x73, 0x6f, 0x6e, 0x45, 0x6e, 0x75, 0x6d, 0x3a, 0x49, 0x0a, 0x02, 0x67, 0x6f, + 0x12, 0x1b, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, + 0x75, 0x66, 0x2e, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x53, 0x65, 0x74, 0x18, 0xea, 0x07, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x47, 0x6f, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, + 0x73, 0x52, 0x02, 0x67, 0x6f, 0x42, 0x34, 0x5a, 0x32, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, + 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x62, 0x75, 0x66, 0x2f, 0x72, 0x65, 0x66, 0x6c, 0x65, 0x63, 0x74, 0x2f, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x64, 0x65, 0x73, 0x63, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, +} + +var ( + file_reflect_protodesc_proto_go_features_proto_rawDescOnce sync.Once + file_reflect_protodesc_proto_go_features_proto_rawDescData = file_reflect_protodesc_proto_go_features_proto_rawDesc +) + +func file_reflect_protodesc_proto_go_features_proto_rawDescGZIP() []byte { + file_reflect_protodesc_proto_go_features_proto_rawDescOnce.Do(func() { + file_reflect_protodesc_proto_go_features_proto_rawDescData = protoimpl.X.CompressGZIP(file_reflect_protodesc_proto_go_features_proto_rawDescData) + }) + return file_reflect_protodesc_proto_go_features_proto_rawDescData +} + +var file_reflect_protodesc_proto_go_features_proto_msgTypes = make([]protoimpl.MessageInfo, 1) +var file_reflect_protodesc_proto_go_features_proto_goTypes = []interface{}{ + (*GoFeatures)(nil), // 0: google.protobuf.GoFeatures + (*descriptorpb.FeatureSet)(nil), // 1: google.protobuf.FeatureSet +} +var file_reflect_protodesc_proto_go_features_proto_depIdxs = []int32{ + 1, // 0: google.protobuf.go:extendee -> google.protobuf.FeatureSet + 0, // 1: google.protobuf.go:type_name -> google.protobuf.GoFeatures + 2, // [2:2] is the sub-list for method output_type + 2, // [2:2] is the sub-list for method input_type + 1, // [1:2] is the sub-list for extension type_name + 0, // [0:1] is the sub-list for extension extendee + 0, // [0:0] is the sub-list for field type_name +} + +func init() { file_reflect_protodesc_proto_go_features_proto_init() } +func file_reflect_protodesc_proto_go_features_proto_init() { + if File_reflect_protodesc_proto_go_features_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_reflect_protodesc_proto_go_features_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GoFeatures); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_reflect_protodesc_proto_go_features_proto_rawDesc, + NumEnums: 0, + NumMessages: 1, + NumExtensions: 1, + NumServices: 0, + }, + GoTypes: file_reflect_protodesc_proto_go_features_proto_goTypes, + DependencyIndexes: file_reflect_protodesc_proto_go_features_proto_depIdxs, + MessageInfos: file_reflect_protodesc_proto_go_features_proto_msgTypes, + ExtensionInfos: file_reflect_protodesc_proto_go_features_proto_extTypes, + }.Build() + File_reflect_protodesc_proto_go_features_proto = out.File + file_reflect_protodesc_proto_go_features_proto_rawDesc = nil + file_reflect_protodesc_proto_go_features_proto_goTypes = nil + file_reflect_protodesc_proto_go_features_proto_depIdxs = nil +} diff --git a/services/vendor/google.golang.org/protobuf/types/gofeaturespb/go_features.proto b/services/vendor/google.golang.org/protobuf/types/gofeaturespb/go_features.proto new file mode 100644 index 00000000..d2465712 --- /dev/null +++ b/services/vendor/google.golang.org/protobuf/types/gofeaturespb/go_features.proto @@ -0,0 +1,28 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2023 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +syntax = "proto2"; + +package google.protobuf; + +import "google/protobuf/descriptor.proto"; + +option go_package = "google.golang.org/protobuf/types/gofeaturespb"; + +extend google.protobuf.FeatureSet { + optional GoFeatures go = 1002; +} + +message GoFeatures { + // Whether or not to generate the deprecated UnmarshalJSON method for enums. + optional bool legacy_unmarshal_json_enum = 1 [ + retention = RETENTION_RUNTIME, + targets = TARGET_TYPE_ENUM, + edition_defaults = { edition: EDITION_PROTO2, value: "true" }, + edition_defaults = { edition: EDITION_PROTO3, value: "false" } + ]; +} diff --git a/services/vendor/google.golang.org/protobuf/types/known/timestamppb/timestamp.pb.go b/services/vendor/google.golang.org/protobuf/types/known/timestamppb/timestamp.pb.go index 83a5a645..81511a33 100644 --- a/services/vendor/google.golang.org/protobuf/types/known/timestamppb/timestamp.pb.go +++ b/services/vendor/google.golang.org/protobuf/types/known/timestamppb/timestamp.pb.go @@ -332,7 +332,7 @@ func file_google_protobuf_timestamp_proto_rawDescGZIP() []byte { } var file_google_protobuf_timestamp_proto_msgTypes = make([]protoimpl.MessageInfo, 1) -var file_google_protobuf_timestamp_proto_goTypes = []any{ +var file_google_protobuf_timestamp_proto_goTypes = []interface{}{ (*Timestamp)(nil), // 0: google.protobuf.Timestamp } var file_google_protobuf_timestamp_proto_depIdxs = []int32{ @@ -349,7 +349,7 @@ func file_google_protobuf_timestamp_proto_init() { return } if !protoimpl.UnsafeEnabled { - file_google_protobuf_timestamp_proto_msgTypes[0].Exporter = func(v any, i int) any { + file_google_protobuf_timestamp_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*Timestamp); i { case 0: return &v.state diff --git a/services/vendor/modules.txt b/services/vendor/modules.txt index eb669e7a..d2bce70b 100644 --- a/services/vendor/modules.txt +++ b/services/vendor/modules.txt @@ -1,35 +1,41 @@ # github.com/beorn7/perks v1.0.1 ## explicit; go 1.11 github.com/beorn7/perks/quantile -# github.com/cespare/xxhash/v2 v2.3.0 +# github.com/cespare/xxhash/v2 v2.2.0 ## explicit; go 1.11 github.com/cespare/xxhash/v2 -# github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 -## explicit -github.com/munnerz/goautoneg +# github.com/golang/protobuf v1.5.3 +## explicit; go 1.9 +github.com/golang/protobuf/proto +# github.com/monzo/terrors v0.0.0-20240312165114-073654f2beb9 +## explicit; go 1.17 +github.com/monzo/terrors +github.com/monzo/terrors/proto +github.com/monzo/terrors/stack # github.com/prometheus/client_golang v1.19.1 ## explicit; go 1.20 github.com/prometheus/client_golang/prometheus github.com/prometheus/client_golang/prometheus/internal github.com/prometheus/client_golang/prometheus/promhttp -# github.com/prometheus/client_model v0.6.1 +# github.com/prometheus/client_model v0.5.0 ## explicit; go 1.19 github.com/prometheus/client_model/go -# github.com/prometheus/common v0.55.0 +# github.com/prometheus/common v0.48.0 ## explicit; go 1.20 github.com/prometheus/common/expfmt +github.com/prometheus/common/internal/bitbucket.org/ww/goautoneg github.com/prometheus/common/model -# github.com/prometheus/procfs v0.15.1 -## explicit; go 1.20 +# github.com/prometheus/procfs v0.12.0 +## explicit; go 1.19 github.com/prometheus/procfs github.com/prometheus/procfs/internal/fs github.com/prometheus/procfs/internal/util -# golang.org/x/sys v0.24.0 +# golang.org/x/sys v0.17.0 ## explicit; go 1.18 golang.org/x/sys/unix golang.org/x/sys/windows -# google.golang.org/protobuf v1.34.2 -## explicit; go 1.20 +# google.golang.org/protobuf v1.33.0 +## explicit; go 1.17 google.golang.org/protobuf/encoding/protodelim google.golang.org/protobuf/encoding/prototext google.golang.org/protobuf/encoding/protowire @@ -53,8 +59,11 @@ google.golang.org/protobuf/internal/set google.golang.org/protobuf/internal/strs google.golang.org/protobuf/internal/version google.golang.org/protobuf/proto +google.golang.org/protobuf/reflect/protodesc google.golang.org/protobuf/reflect/protoreflect google.golang.org/protobuf/reflect/protoregistry google.golang.org/protobuf/runtime/protoiface google.golang.org/protobuf/runtime/protoimpl +google.golang.org/protobuf/types/descriptorpb +google.golang.org/protobuf/types/gofeaturespb google.golang.org/protobuf/types/known/timestamppb