| // 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" |
| |
| "github.com/golang/protobuf/internal/wire" |
| "google.golang.org/protobuf/encoding/prototext" |
| "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 wire.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 wire.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 := wire.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. |
| // |
| // Unlike proto.Unmarshal, this does not reset the message before starting to unmarshal. |
| 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 = wire.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 = wire.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 = wire.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 = wire.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 = wire.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 = wire.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 := wire.ConsumeVarint(b.buf[b.idx:]) |
| if n < 0 { |
| return 0, wire.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 := wire.ConsumeFixed32(b.buf[b.idx:]) |
| if n < 0 { |
| return 0, wire.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 := wire.ConsumeFixed64(b.buf[b.idx:]) |
| if n < 0 { |
| return 0, wire.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 := wire.ConsumeBytes(b.buf[b.idx:]) |
| if n < 0 { |
| return nil, wire.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 := wire.ConsumeString(b.buf[b.idx:]) |
| if n < 0 { |
| return "", wire.ParseError(n) |
| } |
| b.idx += n |
| return v, nil |
| } |
| |
| // DecodeMessage consumes a length-prefixed message from the buffer. |
| // It does not reset m. |
| 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. |
| 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 := wire.ConsumeTag(b) |
| if tagLen < 0 { |
| return nil, 0, wire.ParseError(tagLen) |
| } |
| b = b[tagLen:] |
| |
| var valLen int |
| switch wtyp { |
| case wire.VarintType: |
| _, valLen = wire.ConsumeVarint(b) |
| case wire.Fixed32Type: |
| _, valLen = wire.ConsumeFixed32(b) |
| case wire.Fixed64Type: |
| _, valLen = wire.ConsumeFixed64(b) |
| case wire.BytesType: |
| _, valLen = wire.ConsumeBytes(b) |
| case wire.StartGroupType: |
| depth++ |
| case wire.EndGroupType: |
| depth-- |
| default: |
| return nil, 0, errors.New("proto: cannot parse reserved wire type") |
| } |
| if valLen < 0 { |
| return nil, 0, wire.ParseError(valLen) |
| } |
| b = b[valLen:] |
| |
| if depth == 0 { |
| return b0[:len(b0)-len(b)-tagLen], len(b0) - len(b), nil |
| } |
| } |
| } |