Package protopack enables manual encoding and decoding of protobuf wire data.

This package is intended for use in debugging and/or creation of test data. Proper usage of this package requires knowledge of the wire format.




This section is empty.


This section is empty.


This section is empty.


type Bool

type Bool bool

Bool is a boolean.

type Bytes

type Bytes []byte

Bytes is a length-prefixed bytes.

type Denormalized

type Denormalized struct {
	Count uint // number of extra bytes
	Value Token

Denormalized is a denormalized varint value, where a varint is encoded using more bytes than is strictly necessary. The number of extra bytes alone is sufficient to losslessly represent the denormalized varint.

The value may be one of Tag, Bool, Varint, Svarint, or Uvarint, where the varint representation of each token is denormalized.

Alternatively, the value may be one of String, Bytes, or LengthPrefix, where the varint representation of the length-prefix is denormalized.

type Float32

type Float32 float32

Float32 is a 32-bit fixed-width floating point number.

type Float64

type Float64 float64

Float64 is a 64-bit fixed-width floating point number.

type Int32

type Int32 int32

Int32 is a signed 32-bit fixed-width integer.

type Int64

type Int64 int64

Int64 is a signed 64-bit fixed-width integer.

type LengthPrefix

type LengthPrefix Message

LengthPrefix is a length-prefixed message.

type Message

type Message []Token

Message is an ordered sequence of Tokens, where certain tokens may contain other tokens. It is functionally a concrete syntax tree that losslessly represents any arbitrary wire data (including invalid input).

func (Message) Format

func (m Message) Format(s fmt.State, r rune)

Format implements a custom formatter to visualize the syntax tree. Using "%#v" formats the Message in Go source code.

func (Message) Marshal

func (m Message) Marshal() []byte

Marshal encodes a syntax tree into the protobuf wire format.

Example message definition:

message MyMessage {
	string field1 = 1;
	int64 field2 = 2;
	repeated float32 field3 = 3;

Example encoded message:

b := Message{
	Tag{1, BytesType}, String("Hello, world!"),
	Tag{2, VarintType}, Varint(-10),
	Tag{3, BytesType}, LengthPrefix{
		Float32(1.1), Float32(2.2), Float32(3.3),

Resulting wire data:

0x0000  0a 0d 48 65 6c 6c 6f 2c  20 77 6f 72 6c 64 21 10  |..Hello, world!.|
0x0010  f6 ff ff ff ff ff ff ff  ff 01 1a 0c cd cc 8c 3f  |...............?|
0x0020  cd cc 0c 40 33 33 53 40                           |...@33S@|

func (Message) Size

func (m Message) Size() int

Size reports the size in bytes of the marshaled message.

func (*Message) Unmarshal

func (m *Message) Unmarshal(in []byte)

Unmarshal parses the input protobuf wire data as a syntax tree. Any parsing error results in the remainder of the input being concatenated to the message as a Raw type.

Each tag (a tuple of the field number and wire type) encountered is inserted into the syntax tree as a Tag.

The contents of each wire type is mapped to the following Go types:

VarintType   => Uvarint
Fixed32Type  => Uint32
Fixed64Type  => Uint64
BytesType    => Bytes
GroupType    => Message

Since the wire format is not self-describing, this function cannot parse sub-messages and will leave them as the Bytes type. Further manual parsing can be performed as such:

var m, m1, m2 Message
m[3] = LengthPrefix(m1)
m[3].(LengthPrefix)[1] = LengthPrefix(m2)

Unmarshal is useful for debugging the protobuf wire format.

func (*Message) UnmarshalDescriptor

func (m *Message) UnmarshalDescriptor(in []byte, desc protoreflect.MessageDescriptor)

UnmarshalDescriptor parses the input protobuf wire data as a syntax tree using the provided message descriptor for more accurate parsing of fields. It operates like Unmarshal, but may use a wider range of Go types to represent the wire data.

The contents of each wire type is mapped to one of the following Go types:

VarintType   => Bool, Varint, Svarint, Uvarint
Fixed32Type  => Int32, Uint32, Float32
Fixed64Type  => Uint32, Uint64, Float64
BytesType    => String, Bytes, LengthPrefix
GroupType    => Message

If the field is unknown, it uses the same mapping as Unmarshal. Known sub-messages are parsed as a Message and packed repeated fields are parsed as a LengthPrefix.

type Number

type Number = protowire.Number

Number is the field number; aliased from the protowire package for convenience.

const (
	MinValidNumber      Number = protowire.MinValidNumber
	FirstReservedNumber Number = protowire.FirstReservedNumber
	LastReservedNumber  Number = protowire.LastReservedNumber
	MaxValidNumber      Number = protowire.MaxValidNumber

Number type constants; copied from the protowire package for convenience.

type Raw

type Raw []byte

Raw are bytes directly appended to output.

type String

type String string

String is a length-prefixed string.

type Svarint

type Svarint int64

Svarint is a signed varint using zig-zag encoding.

type Tag

type Tag struct {
	Number Number
	Type   Type

Tag is a tuple of the field number and the wire type.

type Token

type Token token

Token is any other type (e.g., Message, Tag, Varint, Float32, etc).

type Type

type Type = protowire.Type

Type is the wire type; aliased from the protowire package for convenience.

const (
	VarintType     Type = protowire.VarintType
	Fixed32Type    Type = protowire.Fixed32Type
	Fixed64Type    Type = protowire.Fixed64Type
	BytesType      Type = protowire.BytesType
	StartGroupType Type = protowire.StartGroupType
	EndGroupType   Type = protowire.EndGroupType

Wire type constants; copied from the protowire package for convenience.

type Uint32

type Uint32 uint32

Uint32 is an unsigned 32-bit fixed-width integer.

type Uint64

type Uint64 uint64

Uint64 is an unsigned 64-bit fixed-width integer.

type Uvarint

type Uvarint uint64

Uvarint is a unsigned varint.

type Varint

type Varint int64

Varint is a signed varint using 64-bit two's complement encoding.

Source Files