Protocol Buffers Go Implementation

This project provides the Go implementation for Protocol Buffers, a language-neutral mechanism for serializing structured data. It consists of two main components:

1. Code Generator: The protoc-gen-go tool is a protoc compiler plugin used to generate Go-specific code from .proto files.
2. Runtime Library: The google.golang.org/protobuf module provides the Go packages required to handle message serialization (in wire, JSON, and text formats) and define message interfaces.

Note: This is the second major revision of the Go API. The legacy version is implemented by github.com/golang/protobuf.

There are two major versions of the Go protocol buffer API. It is critical to use the correct module based on your requirements:

1. google.golang.org/protobuf (New API): The current major revision (released in 2020). It uses a reflection-based approach where the proto.Message interface is defined by the ProtoReflect() method. This version is designed for better type safety, extensibility, and programmatic interaction via protobuf reflection.
2. github.com/golang/protobuf (Legacy API): The first major version (released in 2010). It relies on a marker method ProtoMessage() and expects protobuf messages to be Go structs with specific field tags. This version is considered legacy.

To avoid compatibility issues, you should use a version of protoc-gen-go that is identical to the runtime version provided by the google.golang.org/protobuf module.

Compatibility Guarantees:

• The runtime remains compatible with code produced by a version of the generator that is no older than 1 year from the version of the runtime used (based on minor version release dates).
• Generated code is expected to use a runtime version that is at least as new as the generator used to produce it.
• Generated code uses protoimpl.EnforceVersion to statically ensure the generated code and runtime do not drift too far apart.

To perform local fuzzing, you need to install go-fuzz and go114-fuzz-build. Navigate to the specific fuzzer directory within internal/fuzz/, build the fuzzer using go114-fuzz-build, and then execute go-fuzz.

$ go install github.com/dvyukov/go-fuzz/go-fuzz
$ go install github.com/mdempsky/go114-fuzz-build
$ cd internal/fuzz/{fuzzer}
$ go114-fuzz-build google.golang.org/protobuf/internal/fuzz/{fuzzer}
$ go-fuzz

In the current major version of the Go protobuf API (google.golang.org/protobuf), the proto.Message interface has been redesigned to support robust protobuf reflection. Instead of relying on Go reflection to inspect struct fields and tags, you should use the ProtoReflect() method to obtain a protoreflect.Message view of the data. This allows for principled, programmatic interaction with any protobuf message regardless of its underlying Go implementation (e.g., whether it is a struct or a map).

type Message interface {
    ProtoReflect() protoreflect.Message
}

The evolution of the Go protobuf API involved moving from a marker-based interface to a reflection-based interface to improve type safety and support diverse message implementations.

Legacy proto.Message (github.com/golang/protobuf): Required a marker method to restrict proto.Unmarshal to protobuf types, but relied on undocumented struct layouts.

type Message interface {
   Reset()
   String() string
   ProtoMessage()
}

New proto.Message (google.golang.org/protobuf): Provides a single method to access a reflective view of the message, enabling safe programmatic introspection.

type Message interface {
    ProtoReflect() protoreflect.Message
}

The --plugins flag is not supported in protoc-gen-go. To generate gRPC code, you should use a dedicated gRPC plugin (e.g., protoc-gen-go-grpc) via the protoc command.

Example usage: protoc --go-grpc_out=...

See https://grpc.io/docs/languages/go/quickstart/#regenerate-grpc-code for more information.