mirror of https://github.com/prometheus/prometheus
428 lines
11 KiB
Go
428 lines
11 KiB
Go
// Go support for Protocol Buffers - Google's data interchange format
|
|
//
|
|
// Copyright 2010 The Go Authors. All rights reserved.
|
|
// https://github.com/golang/protobuf
|
|
//
|
|
// 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.
|
|
|
|
package proto
|
|
|
|
/*
|
|
* Routines for decoding protocol buffer data to construct in-memory representations.
|
|
*/
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
)
|
|
|
|
// errOverflow is returned when an integer is too large to be represented.
|
|
var errOverflow = errors.New("proto: integer overflow")
|
|
|
|
// ErrInternalBadWireType is returned by generated code when an incorrect
|
|
// wire type is encountered. It does not get returned to user code.
|
|
var ErrInternalBadWireType = errors.New("proto: internal error: bad wiretype for oneof")
|
|
|
|
// DecodeVarint reads a varint-encoded integer from the slice.
|
|
// It returns the integer and the number of bytes consumed, or
|
|
// zero if there is not enough.
|
|
// This is the format for the
|
|
// int32, int64, uint32, uint64, bool, and enum
|
|
// protocol buffer types.
|
|
func DecodeVarint(buf []byte) (x uint64, n int) {
|
|
for shift := uint(0); shift < 64; shift += 7 {
|
|
if n >= len(buf) {
|
|
return 0, 0
|
|
}
|
|
b := uint64(buf[n])
|
|
n++
|
|
x |= (b & 0x7F) << shift
|
|
if (b & 0x80) == 0 {
|
|
return x, n
|
|
}
|
|
}
|
|
|
|
// The number is too large to represent in a 64-bit value.
|
|
return 0, 0
|
|
}
|
|
|
|
func (p *Buffer) decodeVarintSlow() (x uint64, err error) {
|
|
i := p.index
|
|
l := len(p.buf)
|
|
|
|
for shift := uint(0); shift < 64; shift += 7 {
|
|
if i >= l {
|
|
err = io.ErrUnexpectedEOF
|
|
return
|
|
}
|
|
b := p.buf[i]
|
|
i++
|
|
x |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
p.index = i
|
|
return
|
|
}
|
|
}
|
|
|
|
// The number is too large to represent in a 64-bit value.
|
|
err = errOverflow
|
|
return
|
|
}
|
|
|
|
// DecodeVarint reads a varint-encoded integer from the Buffer.
|
|
// This is the format for the
|
|
// int32, int64, uint32, uint64, bool, and enum
|
|
// protocol buffer types.
|
|
func (p *Buffer) DecodeVarint() (x uint64, err error) {
|
|
i := p.index
|
|
buf := p.buf
|
|
|
|
if i >= len(buf) {
|
|
return 0, io.ErrUnexpectedEOF
|
|
} else if buf[i] < 0x80 {
|
|
p.index++
|
|
return uint64(buf[i]), nil
|
|
} else if len(buf)-i < 10 {
|
|
return p.decodeVarintSlow()
|
|
}
|
|
|
|
var b uint64
|
|
// we already checked the first byte
|
|
x = uint64(buf[i]) - 0x80
|
|
i++
|
|
|
|
b = uint64(buf[i])
|
|
i++
|
|
x += b << 7
|
|
if b&0x80 == 0 {
|
|
goto done
|
|
}
|
|
x -= 0x80 << 7
|
|
|
|
b = uint64(buf[i])
|
|
i++
|
|
x += b << 14
|
|
if b&0x80 == 0 {
|
|
goto done
|
|
}
|
|
x -= 0x80 << 14
|
|
|
|
b = uint64(buf[i])
|
|
i++
|
|
x += b << 21
|
|
if b&0x80 == 0 {
|
|
goto done
|
|
}
|
|
x -= 0x80 << 21
|
|
|
|
b = uint64(buf[i])
|
|
i++
|
|
x += b << 28
|
|
if b&0x80 == 0 {
|
|
goto done
|
|
}
|
|
x -= 0x80 << 28
|
|
|
|
b = uint64(buf[i])
|
|
i++
|
|
x += b << 35
|
|
if b&0x80 == 0 {
|
|
goto done
|
|
}
|
|
x -= 0x80 << 35
|
|
|
|
b = uint64(buf[i])
|
|
i++
|
|
x += b << 42
|
|
if b&0x80 == 0 {
|
|
goto done
|
|
}
|
|
x -= 0x80 << 42
|
|
|
|
b = uint64(buf[i])
|
|
i++
|
|
x += b << 49
|
|
if b&0x80 == 0 {
|
|
goto done
|
|
}
|
|
x -= 0x80 << 49
|
|
|
|
b = uint64(buf[i])
|
|
i++
|
|
x += b << 56
|
|
if b&0x80 == 0 {
|
|
goto done
|
|
}
|
|
x -= 0x80 << 56
|
|
|
|
b = uint64(buf[i])
|
|
i++
|
|
x += b << 63
|
|
if b&0x80 == 0 {
|
|
goto done
|
|
}
|
|
|
|
return 0, errOverflow
|
|
|
|
done:
|
|
p.index = i
|
|
return x, nil
|
|
}
|
|
|
|
// DecodeFixed64 reads a 64-bit integer from the Buffer.
|
|
// This is the format for the
|
|
// fixed64, sfixed64, and double protocol buffer types.
|
|
func (p *Buffer) DecodeFixed64() (x uint64, err error) {
|
|
// x, err already 0
|
|
i := p.index + 8
|
|
if i < 0 || i > len(p.buf) {
|
|
err = io.ErrUnexpectedEOF
|
|
return
|
|
}
|
|
p.index = i
|
|
|
|
x = uint64(p.buf[i-8])
|
|
x |= uint64(p.buf[i-7]) << 8
|
|
x |= uint64(p.buf[i-6]) << 16
|
|
x |= uint64(p.buf[i-5]) << 24
|
|
x |= uint64(p.buf[i-4]) << 32
|
|
x |= uint64(p.buf[i-3]) << 40
|
|
x |= uint64(p.buf[i-2]) << 48
|
|
x |= uint64(p.buf[i-1]) << 56
|
|
return
|
|
}
|
|
|
|
// DecodeFixed32 reads a 32-bit integer from the Buffer.
|
|
// This is the format for the
|
|
// fixed32, sfixed32, and float protocol buffer types.
|
|
func (p *Buffer) DecodeFixed32() (x uint64, err error) {
|
|
// x, err already 0
|
|
i := p.index + 4
|
|
if i < 0 || i > len(p.buf) {
|
|
err = io.ErrUnexpectedEOF
|
|
return
|
|
}
|
|
p.index = i
|
|
|
|
x = uint64(p.buf[i-4])
|
|
x |= uint64(p.buf[i-3]) << 8
|
|
x |= uint64(p.buf[i-2]) << 16
|
|
x |= uint64(p.buf[i-1]) << 24
|
|
return
|
|
}
|
|
|
|
// DecodeZigzag64 reads a zigzag-encoded 64-bit integer
|
|
// from the Buffer.
|
|
// This is the format used for the sint64 protocol buffer type.
|
|
func (p *Buffer) DecodeZigzag64() (x uint64, err error) {
|
|
x, err = p.DecodeVarint()
|
|
if err != nil {
|
|
return
|
|
}
|
|
x = (x >> 1) ^ uint64((int64(x&1)<<63)>>63)
|
|
return
|
|
}
|
|
|
|
// DecodeZigzag32 reads a zigzag-encoded 32-bit integer
|
|
// from the Buffer.
|
|
// This is the format used for the sint32 protocol buffer type.
|
|
func (p *Buffer) DecodeZigzag32() (x uint64, err error) {
|
|
x, err = p.DecodeVarint()
|
|
if err != nil {
|
|
return
|
|
}
|
|
x = uint64((uint32(x) >> 1) ^ uint32((int32(x&1)<<31)>>31))
|
|
return
|
|
}
|
|
|
|
// DecodeRawBytes reads a count-delimited byte buffer from the Buffer.
|
|
// This is the format used for the bytes protocol buffer
|
|
// type and for embedded messages.
|
|
func (p *Buffer) DecodeRawBytes(alloc bool) (buf []byte, err error) {
|
|
n, err := p.DecodeVarint()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
nb := int(n)
|
|
if nb < 0 {
|
|
return nil, fmt.Errorf("proto: bad byte length %d", nb)
|
|
}
|
|
end := p.index + nb
|
|
if end < p.index || end > len(p.buf) {
|
|
return nil, io.ErrUnexpectedEOF
|
|
}
|
|
|
|
if !alloc {
|
|
// todo: check if can get more uses of alloc=false
|
|
buf = p.buf[p.index:end]
|
|
p.index += nb
|
|
return
|
|
}
|
|
|
|
buf = make([]byte, nb)
|
|
copy(buf, p.buf[p.index:])
|
|
p.index += nb
|
|
return
|
|
}
|
|
|
|
// DecodeStringBytes reads an encoded string from the Buffer.
|
|
// This is the format used for the proto2 string type.
|
|
func (p *Buffer) DecodeStringBytes() (s string, err error) {
|
|
buf, err := p.DecodeRawBytes(false)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return string(buf), nil
|
|
}
|
|
|
|
// Unmarshaler is the interface representing objects that can
|
|
// unmarshal themselves. The argument points to data that may be
|
|
// overwritten, so implementations should not keep references to the
|
|
// buffer.
|
|
// Unmarshal implementations should not clear the receiver.
|
|
// Any unmarshaled data should be merged into the receiver.
|
|
// Callers of Unmarshal that do not want to retain existing data
|
|
// should Reset the receiver before calling Unmarshal.
|
|
type Unmarshaler interface {
|
|
Unmarshal([]byte) error
|
|
}
|
|
|
|
// newUnmarshaler is the interface representing objects that can
|
|
// unmarshal themselves. The semantics are identical to Unmarshaler.
|
|
//
|
|
// This exists to support protoc-gen-go generated messages.
|
|
// The proto package will stop type-asserting to this interface in the future.
|
|
//
|
|
// DO NOT DEPEND ON THIS.
|
|
type newUnmarshaler interface {
|
|
XXX_Unmarshal([]byte) error
|
|
}
|
|
|
|
// Unmarshal parses the protocol buffer representation in buf and places the
|
|
// decoded result in pb. If the struct underlying pb does not match
|
|
// the data in buf, the results can be unpredictable.
|
|
//
|
|
// Unmarshal resets pb before starting to unmarshal, so any
|
|
// existing data in pb is always removed. Use UnmarshalMerge
|
|
// to preserve and append to existing data.
|
|
func Unmarshal(buf []byte, pb Message) error {
|
|
pb.Reset()
|
|
if u, ok := pb.(newUnmarshaler); ok {
|
|
return u.XXX_Unmarshal(buf)
|
|
}
|
|
if u, ok := pb.(Unmarshaler); ok {
|
|
return u.Unmarshal(buf)
|
|
}
|
|
return NewBuffer(buf).Unmarshal(pb)
|
|
}
|
|
|
|
// UnmarshalMerge parses the protocol buffer representation in buf and
|
|
// writes the decoded result to pb. If the struct underlying pb does not match
|
|
// the data in buf, the results can be unpredictable.
|
|
//
|
|
// UnmarshalMerge merges into existing data in pb.
|
|
// Most code should use Unmarshal instead.
|
|
func UnmarshalMerge(buf []byte, pb Message) error {
|
|
if u, ok := pb.(newUnmarshaler); ok {
|
|
return u.XXX_Unmarshal(buf)
|
|
}
|
|
if u, ok := pb.(Unmarshaler); ok {
|
|
// NOTE: The history of proto have unfortunately been inconsistent
|
|
// whether Unmarshaler should or should not implicitly clear itself.
|
|
// Some implementations do, most do not.
|
|
// Thus, calling this here may or may not do what people want.
|
|
//
|
|
// See https://github.com/golang/protobuf/issues/424
|
|
return u.Unmarshal(buf)
|
|
}
|
|
return NewBuffer(buf).Unmarshal(pb)
|
|
}
|
|
|
|
// DecodeMessage reads a count-delimited message from the Buffer.
|
|
func (p *Buffer) DecodeMessage(pb Message) error {
|
|
enc, err := p.DecodeRawBytes(false)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return NewBuffer(enc).Unmarshal(pb)
|
|
}
|
|
|
|
// DecodeGroup reads a tag-delimited group from the Buffer.
|
|
// StartGroup tag is already consumed. This function consumes
|
|
// EndGroup tag.
|
|
func (p *Buffer) DecodeGroup(pb Message) error {
|
|
b := p.buf[p.index:]
|
|
x, y := findEndGroup(b)
|
|
if x < 0 {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
err := Unmarshal(b[:x], pb)
|
|
p.index += y
|
|
return err
|
|
}
|
|
|
|
// Unmarshal parses the protocol buffer representation in the
|
|
// Buffer and places the decoded result in pb. If the struct
|
|
// underlying pb does not match the data in the buffer, the results can be
|
|
// unpredictable.
|
|
//
|
|
// Unlike proto.Unmarshal, this does not reset pb before starting to unmarshal.
|
|
func (p *Buffer) Unmarshal(pb Message) error {
|
|
// If the object can unmarshal itself, let it.
|
|
if u, ok := pb.(newUnmarshaler); ok {
|
|
err := u.XXX_Unmarshal(p.buf[p.index:])
|
|
p.index = len(p.buf)
|
|
return err
|
|
}
|
|
if u, ok := pb.(Unmarshaler); ok {
|
|
// NOTE: The history of proto have unfortunately been inconsistent
|
|
// whether Unmarshaler should or should not implicitly clear itself.
|
|
// Some implementations do, most do not.
|
|
// Thus, calling this here may or may not do what people want.
|
|
//
|
|
// See https://github.com/golang/protobuf/issues/424
|
|
err := u.Unmarshal(p.buf[p.index:])
|
|
p.index = len(p.buf)
|
|
return err
|
|
}
|
|
|
|
// Slow workaround for messages that aren't Unmarshalers.
|
|
// This includes some hand-coded .pb.go files and
|
|
// bootstrap protos.
|
|
// TODO: fix all of those and then add Unmarshal to
|
|
// the Message interface. Then:
|
|
// The cast above and code below can be deleted.
|
|
// The old unmarshaler can be deleted.
|
|
// Clients can call Unmarshal directly (can already do that, actually).
|
|
var info InternalMessageInfo
|
|
err := info.Unmarshal(pb, p.buf[p.index:])
|
|
p.index = len(p.buf)
|
|
return err
|
|
}
|