+ # See https://github.com/containers/libpod/blob/master/contrib/cirrus/README.md#test_build_cache_images_task-task

+ _BUILT_IMAGE_SUFFIX: "libpod-6224667180531712"

+ FEDORA_CACHE_IMAGE_NAME: "fedora-32-${_BUILT_IMAGE_SUFFIX}"

+ PRIOR_FEDORA_CACHE_IMAGE_NAME: "fedora-31-${_BUILT_IMAGE_SUFFIX}"

+ UBUNTU_CACHE_IMAGE_NAME: "ubuntu-19-${_BUILT_IMAGE_SUFFIX}"

+ PRIOR_UBUNTU_CACHE_IMAGE_NAME: "ubuntu-18-${_BUILT_IMAGE_SUFFIX}"

+

+ image_name: "${PRIOR_FEDORA_CACHE_IMAGE_NAME}"

+ image_name: "${UBUNTU_CACHE_IMAGE_NAME}"

+ image: "quay.io/libpod/fedora-minimal:latest"

+ # Don't exceed number of threads available when running under CI

+ concurrency: 4

+ # Broken? Unpredictably dies w/o any error well before deadline/timeout expires

+ # - gosimple

+## Security and Disclosure Information Policy for the Buildah Project

+

+The Buildah Project follows the [Security and Disclosure Information Policy](https://github.com/containers/common/blob/master/SECURITY.md) for the Containers Projects.

+ encconfig "github.com/containers/ocicrypt/config"

+ // OciDecryptConfig contains the config that can be used to decrypt an image if it is

+ // encrypted if non-nil. If nil, it does not attempt to decrypt an image.

+ OciDecryptConfig *encconfig.DecryptConfig

+ encconfig "github.com/containers/ocicrypt/config"

+ // OciEncryptConfig when non-nil indicates that an image should be encrypted.

+ // The encryption options is derived from the construction of EncryptConfig object.

+ OciEncryptConfig *encconfig.EncryptConfig

+ // OciEncryptLayers represents the list of layers to encrypt.

+ // If nil, don't encrypt any layers.

+ // If non-nil and len==0, denotes encrypt all layers.

+ // integers in the slice represent 0-indexed layer indices, with support for negative

+ // indexing. i.e. 0 is the first layer, -1 is the last (top-most) layer.

+ OciEncryptLayers *[]int

+ // OciEncryptConfig when non-nil indicates that an image should be encrypted.

+ // The encryption options is derived from the construction of EncryptConfig object.

+ OciEncryptConfig *encconfig.EncryptConfig

+ // OciEncryptLayers represents the list of layers to encrypt.

+ // If nil, don't encrypt any layers.

+ // If non-nil and len==0, denotes encrypt all layers.

+ // integers in the slice represent 0-indexed layer indices, with support for negative

+ // indexing. i.e. 0 is the first layer, -1 is the last (top-most) layer.

+ OciEncryptLayers *[]int

+ // Use local struct instead of github.com/openshift/api/config/v1 RegistrySources

+ var sources struct {

+ InsecureRegistries []string `json:"insecureRegistries,omitempty"`

+ BlockedRegistries []string `json:"blockedRegistries,omitempty"`

+ AllowedRegistries []string `json:"allowedRegistries,omitempty"`

+ }

+ if transport, destIsStorage := dest.Transport().(is.StoreTransport); destIsStorage && options.OciEncryptConfig != nil {

+ return imgID, nil, "", errors.New("unable to use local storage with image encryption")

+ } else if destIsStorage && b.FromImageID != "" {

+ if manifestBytes, err = retryCopyImage(ctx, policyContext, maybeCachedDest, maybeCachedSrc, dest, "push", getCopyOptions(b.store, options.ReportWriter, nil, systemContext, "", false, options.SignBy, options.OciEncryptLayers, options.OciEncryptConfig, nil), options.MaxRetries, options.RetryDelay); err != nil {

+ if manifestBytes, err = retryCopyImage(ctx, policyContext, dest, maybeCachedSrc, dest, "push", getCopyOptions(options.Store, options.ReportWriter, nil, systemContext, options.ManifestType, options.RemoveSignatures, options.SignBy, options.OciEncryptLayers, options.OciEncryptConfig, nil), options.MaxRetries, options.RetryDelay); err != nil {

+ encconfig "github.com/containers/ocicrypt/config"

+func getCopyOptions(store storage.Store, reportWriter io.Writer, sourceSystemContext *types.SystemContext, destinationSystemContext *types.SystemContext, manifestType string, removeSignatures bool, addSigner string, ociEncryptLayers *[]int, ociEncryptConfig *encconfig.EncryptConfig, ociDecryptConfig *encconfig.DecryptConfig) *cp.Options {

+ OciEncryptConfig: ociEncryptConfig,

+ OciDecryptConfig: ociDecryptConfig,

+ OciEncryptLayers: ociEncryptLayers,

+ github.com/containers/common v0.11.2

+ github.com/containers/image/v5 v5.4.4

+ github.com/containers/ocicrypt v1.0.2

+ github.com/containers/storage v1.19.2

+ github.com/onsi/ginkgo v1.12.1

+ github.com/onsi/gomega v1.10.0

+ github.com/opencontainers/go-digest v1.0.0

+ github.com/opencontainers/runtime-spec v1.0.3-0.20200520003142-237cc4f519e2

+ github.com/seccomp/containers-golang v0.4.1

+ github.com/sirupsen/logrus v1.6.0

+ golang.org/x/crypto v0.0.0-20200423211502-4bdfaf469ed5

+ golang.org/x/sys v0.0.0-20200420163511-1957bb5e6d1f

+github.com/Microsoft/hcsshim v0.8.9 h1:VrfodqvztU8YSOvygU+DN1BGaSGxmrNfqOv5oOuX2Bk=

+github.com/Microsoft/hcsshim v0.8.9/go.mod h1:5692vkUqntj1idxauYlpoINNKeqCiG6Sg38RRsjT5y8=

+github.com/blang/semver v3.5.1+incompatible h1:cQNTCjp13qL8KC3Nbxr/y2Bqb63oX6wdnnjpJbkM4JQ=

+github.com/blang/semver v3.5.1+incompatible/go.mod h1:kRBLl5iJ+tD4TcOOxsy/0fnwebNt5EWlYSAyrTnjyyk=

+github.com/containerd/containerd v1.3.2 h1:ForxmXkA6tPIvffbrDAcPUIB32QgXkt2XFj+F0UxetA=

+github.com/containerd/containerd v1.3.2/go.mod h1:bC6axHOhabU15QhwfG7w5PipXdVtMXFTttgp+kVtyUA=

+github.com/containers/common v0.11.2 h1:e4477fCE3qSA+Z2vT+uUMUTn8s8CyIM++qNm3PCSl68=

+github.com/containers/common v0.11.2/go.mod h1:2w3QE6VUmhltGYW4wV00h4okq1Crs7hNI1ZD2I0QRUY=

+github.com/containers/image/v5 v5.4.4 h1:JSanNn3v/BMd3o0MEvO4R4OKNuoJUSzVGQAI1+0FMXE=

+github.com/containers/image/v5 v5.4.4/go.mod h1:g7cxNXitiLi6pEr9/L9n/0wfazRuhDKXU15kV86N8h8=

+github.com/containers/storage v1.19.1 h1:YKIzOO12iaD5Ra0PKFS6emcygbHLmwmQOCQRU/19YAQ=

+github.com/containers/storage v1.19.1/go.mod h1:KbXjSwKnx17ejOsjFcCXSf78mCgZkQSLPBNTMRc3XrQ=

+github.com/containers/storage v1.19.2 h1:vhcUwEjDZiPJxaLPFsjvyavnEjFw6qQi9HAkVz1amfI=

+github.com/containers/storage v1.19.2/go.mod h1:gYCp3jzgXkvubO0rI14QAjz5Mxm/qKJgLmHFyqayDnw=

+github.com/klauspost/compress v1.10.5 h1:7q6vHIqubShURwQz8cQK6yIe/xC3IF0Vm7TGfqjewrc=

+github.com/klauspost/compress v1.10.5/go.mod h1:aoV0uJVorq1K+umq18yTdKaF57EivdYsUV+/s2qKfXs=

+github.com/konsorten/go-windows-terminal-sequences v1.0.1 h1:mweAR1A6xJ3oS2pRaGiHgQ4OO8tzTaLawm8vnODuwDk=

+github.com/nxadm/tail v1.4.4 h1:DQuhQpB1tVlglWS2hLQ5OV6B5r8aGxSrPc5Qo6uTN78=

+github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A=

+github.com/onsi/ginkgo v1.12.1 h1:mFwc4LvZ0xpSvDZ3E+k8Yte0hLOMxXUlP+yXtJqkYfQ=

+github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk=

+github.com/onsi/gomega v1.10.0 h1:Gwkk+PTu/nfOwNMtUB/mRUv0X7ewW5dO4AERT1ThVKo=

+github.com/onsi/gomega v1.10.0/go.mod h1:Ho0h+IUsWyvy1OpqCwxlQ/21gkhVunqlU8fDGcoTdcA=

+github.com/opencontainers/go-digest v1.0.0 h1:apOUWs51W5PlhuyGyz9FCeeBIOUDA/6nW8Oi/yOhh5U=

+github.com/opencontainers/go-digest v1.0.0/go.mod h1:0JzlMkj0TRzQZfJkVvzbP0HBR3IKzErnv2BNG4W4MAM=

+github.com/opencontainers/runtime-spec v1.0.3-0.20200520003142-237cc4f519e2 h1:9mv9SC7GWmRWE0J/+oD8w3GsN2KYGKtg6uwLN7hfP5E=

+github.com/opencontainers/runtime-spec v1.0.3-0.20200520003142-237cc4f519e2/go.mod h1:jwyrGlmzljRJv/Fgzds9SsS/C5hL+LL3ko9hs6T5lQ0=

+github.com/opencontainers/selinux v1.3.0/go.mod h1:+BLncwf63G4dgOzykXAxcmnFlUaOlkDdmw/CqsW6pjs=

+github.com/prometheus/procfs v0.0.0-20180125133057-cb4147076ac7/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=

+github.com/russross/blackfriday/v2 v2.0.1 h1:lPqVAte+HuHNfhJ/0LC98ESWRz8afy9tM/0RK8m9o+Q=

+github.com/seccomp/containers-golang v0.4.1 h1:6hsmsP8Y9T6PWKJELqAkRWkc6Te60+zK64avkjInd44=

+github.com/seccomp/containers-golang v0.4.1/go.mod h1:5fP9lgyYyklJ8fg8Geq193G1QLe0ikf34z+hZKIjmnE=

+github.com/shurcooL/sanitized_anchor_name v1.0.0 h1:PdmoCO6wvbs+7yrJyMORt4/BmY5IYyJwS/kOiWx8mHo=

+github.com/vbauerster/mpb/v5 v5.0.4 h1:w7l/tJfHmtIOKZkU+bhbDZOUxj1kln9jy4DUOp3Tl14=

+github.com/vbauerster/mpb/v5 v5.0.4/go.mod h1:fvzasBUyuo35UyuA6sSOlVhpLoNQsp2nBdHw7OiSUU8=

+golang.org/x/crypto v0.0.0-20200423211502-4bdfaf469ed5 h1:Q7tZBpemrlsc2I7IyODzhtallWRSm4Q0d09pL6XbQtU=

+golang.org/x/crypto v0.0.0-20200423211502-4bdfaf469ed5/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=

+golang.org/x/sys v0.0.0-20190904154756-749cb33beabd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=

+golang.org/x/sys v0.0.0-20190921190940-14da1ac737cc/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=

+golang.org/x/sys v0.0.0-20200420163511-1957bb5e6d1f h1:gWF768j/LaZugp8dyS4UwsslYCYz9XgFxvlgsn0n9H8=

+golang.org/x/sys v0.0.0-20200420163511-1957bb5e6d1f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=

+google.golang.org/genproto v0.0.0-20190502173448-54afdca5d873/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=

+google.golang.org/grpc v1.23.1/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=

+ "fmt"

+ encconfig "github.com/containers/ocicrypt/config"

+ "github.com/openshift/imagebuilder/dockerfile/parser"

+ // OciDecryptConfig contains the config that can be used to decrypt an image if it is

+ // encrypted if non-nil. If nil, it does not attempt to decrypt an image.

+ OciDecryptConfig *encconfig.DecryptConfig

+

+ warnOnUnsetBuildArgs(mainNode, options.Args)

+

+func warnOnUnsetBuildArgs(node *parser.Node, args map[string]string) {

+ for _, child := range node.Children {

+ switch strings.ToUpper(child.Value) {

+ case "ARG":

+ argName := child.Next.Value

+ if _, ok := args[argName]; !strings.Contains(argName, "=") && !ok {

+ logrus.Warnf("missing %q build argument. Try adding %q to the command line", argName, fmt.Sprintf("--build-arg %s=<VALUE>", argName))

+ }

+ default:

+ continue

+ }

+ }

+}

+

+ encconfig "github.com/containers/ocicrypt/config"

+ ociDecryptConfig *encconfig.DecryptConfig

+ ociDecryptConfig: options.OciDecryptConfig,

+func (b *Executor) startStage(stage *imagebuilder.Stage, stages int, output string) *StageExecutor {

+ stageExecutor := b.startStage(&stage, len(stages), output)

+ if other, ok := s.executor.stages[from]; ok && other.index < s.index {

+ OciDecryptConfig: s.executor.ociDecryptConfig,

+ if otherStage, ok := s.executor.stages[arr[1]]; ok && otherStage.index < s.index {

+ } else if mountPoint, err = s.getImageRootfs(ctx, arr[1]); err != nil {

+ return "", nil, errors.Errorf("%s --from=%s: no stage or image found with that name", command, arr[1])

+ ReportWriter: options.ReportWriter,

+ Store: store,

+ SystemContext: options.SystemContext,

+ BlobDirectory: options.BlobDirectory,

+ MaxRetries: options.MaxPullRetries,

+ RetryDelay: options.PullRetryDelay,

+ OciDecryptConfig: options.OciDecryptConfig,

+ DecryptionKeys []string

+ encconfig "github.com/containers/ocicrypt/config"

+ // OciDecryptConfig contains the config that can be used to decrypt an image if it is

+ // encrypted if non-nil. If nil, it does not attempt to decrypt an image.

+ OciDecryptConfig *encconfig.DecryptConfig

+ OciDecryptConfig: options.OciDecryptConfig,

+ if _, err := retryCopyImage(ctx, policyContext, maybeCachedDestRef, srcRef, srcRef, "pull", getCopyOptions(store, options.ReportWriter, sc, nil, "", options.RemoveSignatures, "", nil, nil, options.OciDecryptConfig), options.MaxRetries, options.RetryDelay); err != nil {

+ if StartsWithValidTransport(name) && len(split) == 2 {

+// StartsWithValidTransport validates the name starts with Buildah supported transport

+// to avoid the corner case image name same as the transport name

+func StartsWithValidTransport(name string) bool {

+ return strings.HasPrefix(name, "dir:") || strings.HasPrefix(name, "docker://") || strings.HasPrefix(name, "docker-archive:") || strings.HasPrefix(name, "docker-daemon:") || strings.HasPrefix(name, "oci:") || strings.HasPrefix(name, "oci-archive:")

+}

+

+ if c.Engine.CgroupManager == SystemdCgroupsManager {

+ cgroup2, _ := cgroupv2.Enabled()

+ if cgroup2 {

+ return c.Containers.PidsLimit

+ }

+ if libpodConf.InitPath != "" {

+ c.Containers.InitPath = libpodConf.InitPath

+ }

+ if libpodConf.SignaturePolicyPath != "" {

+ c.Engine.SignaturePolicyPath = libpodConf.SignaturePolicyPath

+ }

+ if libpodConf.VolumePath != "" {

+ c.Engine.VolumePath = libpodConf.VolumePath

+ }

+ if libpodConf.ImageDefaultTransport != "" {

+ c.Engine.ImageDefaultTransport = libpodConf.ImageDefaultTransport

+ }

+ if libpodConf.OCIRuntime != "" {

+ c.Engine.OCIRuntime = libpodConf.OCIRuntime

+ }

+ if libpodConf.CgroupManager != "" {

+ c.Engine.CgroupManager = libpodConf.CgroupManager

+ }

+ if libpodConf.StaticDir != "" {

+ c.Engine.StaticDir = libpodConf.StaticDir

+ }

+ if libpodConf.TmpDir != "" {

+ c.Engine.TmpDir = libpodConf.TmpDir

+ }

+ if libpodConf.Namespace != "" {

+ c.Engine.Namespace = libpodConf.Namespace

+ }

+ if libpodConf.InfraImage != "" {

+ c.Engine.InfraImage = libpodConf.InfraImage

+ }

+ if libpodConf.InfraCommand != "" {

+ c.Engine.InfraCommand = libpodConf.InfraCommand

+ }

+

+ if libpodConf.NetworkCmdPath != "" {

+ c.Engine.NetworkCmdPath = libpodConf.NetworkCmdPath

+ }

+ if libpodConf.EventsLogger != "" {

+ c.Engine.EventsLogger = libpodConf.EventsLogger

+ }

+ if libpodConf.EventsLogFilePath != "" {

+ c.Engine.EventsLogFilePath = libpodConf.EventsLogFilePath

+ }

+ if libpodConf.DetachKeys != "" {

+ c.Engine.DetachKeys = libpodConf.DetachKeys

+ }

+ if libpodConf.CNIConfigDir != "" {

+ c.Network.NetworkConfigDir = libpodConf.CNIConfigDir

+ }

+ if libpodConf.CNIDefaultNetwork != "" {

+ c.Network.DefaultNetwork = libpodConf.CNIDefaultNetwork

+ }

+1.20.1

+ if err := idtools.MkdirAllAs(dirname, 0700, uid, gid); err != nil {

+ if err := idtools.MkdirAs(devices.root, 0700, uid, gid); err != nil {

+ if err := os.MkdirAll(devices.metadataDir(), 0700); err != nil {

+ if err := idtools.MkdirAllAs(path.Join(d.home, "mnt"), 0755, uid, gid); err != nil {

+ if err := idtools.MkdirAllAs(rootFs, 0755, uid, gid); err != nil {

+ return false, errors.Wrapf(err, "failed to mount overlay for metacopy check with %q options", mountOpts)

+ "github.com/vbatts/tar-split/tar/storage"

+ if err := idtools.MkdirAllAs(path.Join(home, linkDir), 0700, rootUID, rootGID); err != nil {

+ if err := idtools.MkdirAllAs(runhome, 0700, rootUID, rootGID); err != nil {

+ if err := idtools.MkdirAllAs(path.Join(d.home, linkDir), 0700, rootUID, rootGID); err != nil {

+ if err := idtools.MkdirAllAs(path.Join(d.home, linkDir), 0700, rootUID, rootGID); err != nil {

+ for _, o := range options.Options {

+ if o == "ro" {

+ readWrite = false

+ break

+ }

+ }

+

+ if !readWrite && d.options.mountProgram == "" {

+ if err := idtools.MkdirAllAs(diffDir, 0755, rootUID, rootGID); err != nil {

+ return "", err

+ opts = fmt.Sprintf("lowerdir=%s:%s", diffDir, strings.Join(absLowers, ":"))

+ if err != nil && errors.Cause(err) != exec.ErrNotFound {

+type fileGetNilCloser struct {

+ storage.FileGetter

+}

+

+func (f fileGetNilCloser) Close() error {

+ return nil

+}

+

+// DiffGetter returns a FileGetCloser that can read files from the directory that

+// contains files for the layer differences. Used for direct access for tar-split.

+func (d *Driver) DiffGetter(id string) (graphdriver.FileGetCloser, error) {

+ p := d.getDiffPath(id)

+ return fileGetNilCloser{storage.NewPathFileGetter(p)}, nil

+}

+

+ "github.com/vbatts/tar-split/tar/storage"

+type fileGetNilCloser struct {

+ storage.FileGetter

+}

+

+func (f fileGetNilCloser) Close() error {

+ return nil

+}

+

+// DiffGetter returns a FileGetCloser that can read files from the directory that

+// contains files for the layer differences. Used for direct access for tar-split.

+func (d *Driver) DiffGetter(id string) (graphdriver.FileGetCloser, error) {

+ p := d.dir(id)

+ return fileGetNilCloser{storage.NewPathFileGetter(p)}, nil

+}

+

+ github.com/klauspost/pgzip v1.2.4

+ github.com/opencontainers/go-digest v1.0.0

+github.com/klauspost/pgzip v1.2.4 h1:TQ7CNpYKovDOmqzRHKxJh0BeaBI7UdQZYc6p7pMQh1A=

+github.com/klauspost/pgzip v1.2.4/go.mod h1:Ch1tH69qFZu15pkjo5kYi6mth2Zzwzt50oCQKQE9RUs=

+github.com/opencontainers/go-digest v1.0.0 h1:apOUWs51W5PlhuyGyz9FCeeBIOUDA/6nW8Oi/yOhh5U=

+github.com/opencontainers/go-digest v1.0.0/go.mod h1:0JzlMkj0TRzQZfJkVvzbP0HBR3IKzErnv2BNG4W4MAM=

+ // escape next char.

+ return filepath.ErrBadPattern

+ regStr += "(/.*)?$"

+ "syscall"

+ st, err := os.Stat(path)

+ if err != nil && os.IsNotExist(err) {

+ if !st.IsDir() {

+ return &os.PathError{Op: "mkdir", Path: path, Err: syscall.ENOTDIR}

+ }

+ if chownExisting {

+ // short-circuit--we were called with an existing directory and chown was requested

+ return SafeChown(path, ownerUID, ownerGID)

+ }

+ // nothing to do; directory exists and chown was NOT requested

+ if err := os.MkdirAll(path, mode); err != nil {

+ if err := os.MkdirAll(path, mode); err != nil {

+ if err := os.MkdirAll(options.RunRoot, 0700); err != nil {

+ if err := os.MkdirAll(options.GraphRoot, 0700); err != nil {

+ if err := os.MkdirAll(filepath.Join(options.GraphRoot, subdir), 0700); err != nil {

+ size = u.Gid

+// 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

+ }

+ }

+}

+// 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

+ })

+}

+// 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.

+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.

+// Deprecated: Do not use.

+// Deprecated: Do not use.

+// Deprecated: Do not use.

+// Deprecated: Do not use.

+// Deprecated: Do not use.

+// Deprecated: Do not use.

+

+// 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))

+}

+// 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.

+ "google.golang.org/protobuf/reflect/protoreflect"

+ 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)

+// 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.

+ "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")

+// 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() {

+ 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

+ }

+ })

+ 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() {

+

+ 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 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:

+ 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 == 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))

+// 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() {

+

+ // 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 {

+ 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