564 lines
23 KiB
C++
564 lines
23 KiB
C++
// Copyright 2021 The Pigweed Authors
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License"); you may not
|
|
// use this file except in compliance with the License. You may obtain a copy of
|
|
// the License at
|
|
//
|
|
// https://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
// License for the specific language governing permissions and limitations under
|
|
// the License.
|
|
|
|
#include "pw_protobuf/encoder.h"
|
|
|
|
#include <algorithm>
|
|
#include <cstddef>
|
|
#include <cstring>
|
|
#include <optional>
|
|
|
|
#include "pw_assert/check.h"
|
|
#include "pw_bytes/span.h"
|
|
#include "pw_protobuf/internal/codegen.h"
|
|
#include "pw_protobuf/serialized_size.h"
|
|
#include "pw_protobuf/stream_decoder.h"
|
|
#include "pw_protobuf/wire_format.h"
|
|
#include "pw_span/span.h"
|
|
#include "pw_status/status.h"
|
|
#include "pw_status/try.h"
|
|
#include "pw_stream/memory_stream.h"
|
|
#include "pw_stream/stream.h"
|
|
#include "pw_string/string.h"
|
|
#include "pw_varint/varint.h"
|
|
|
|
namespace pw::protobuf {
|
|
|
|
using internal::VarintType;
|
|
|
|
StreamEncoder StreamEncoder::GetNestedEncoder(uint32_t field_number,
|
|
bool write_when_empty) {
|
|
PW_CHECK(!nested_encoder_open());
|
|
PW_CHECK(ValidFieldNumber(field_number));
|
|
|
|
nested_field_number_ = field_number;
|
|
|
|
// Pass the unused space of the scratch buffer to the nested encoder to use
|
|
// as their scratch buffer.
|
|
size_t key_size =
|
|
varint::EncodedSize(FieldKey(field_number, WireType::kDelimited));
|
|
size_t reserved_size = key_size + config::kMaxVarintSize;
|
|
size_t max_size = std::min(memory_writer_.ConservativeWriteLimit(),
|
|
writer_.ConservativeWriteLimit());
|
|
// Account for reserved bytes.
|
|
max_size = max_size > reserved_size ? max_size - reserved_size : 0;
|
|
// Cap based on max varint size.
|
|
max_size = std::min(varint::MaxValueInBytes(config::kMaxVarintSize),
|
|
static_cast<uint64_t>(max_size));
|
|
|
|
ByteSpan nested_buffer;
|
|
if (max_size > 0) {
|
|
nested_buffer = ByteSpan(
|
|
memory_writer_.data() + reserved_size + memory_writer_.bytes_written(),
|
|
max_size);
|
|
} else {
|
|
nested_buffer = ByteSpan();
|
|
}
|
|
return StreamEncoder(*this, nested_buffer, write_when_empty);
|
|
}
|
|
|
|
void StreamEncoder::CloseEncoder() {
|
|
// If this was an invalidated StreamEncoder which cannot be used, permit the
|
|
// object to be cleanly destructed by doing nothing.
|
|
if (nested_field_number_ == kFirstReservedNumber) {
|
|
return;
|
|
}
|
|
|
|
PW_CHECK(
|
|
!nested_encoder_open(),
|
|
"Tried to destruct a proto encoder with an active submessage encoder");
|
|
|
|
if (parent_ != nullptr) {
|
|
parent_->CloseNestedMessage(*this);
|
|
}
|
|
}
|
|
|
|
void StreamEncoder::CloseNestedMessage(StreamEncoder& nested) {
|
|
PW_DCHECK_PTR_EQ(nested.parent_,
|
|
this,
|
|
"CloseNestedMessage() called on the wrong Encoder parent");
|
|
|
|
// Make the nested encoder look like it has an open child to block writes for
|
|
// the remainder of the object's life.
|
|
nested.nested_field_number_ = kFirstReservedNumber;
|
|
nested.parent_ = nullptr;
|
|
// Temporarily cache the field number of the child so we can re-enable
|
|
// writing to this encoder.
|
|
uint32_t temp_field_number = nested_field_number_;
|
|
nested_field_number_ = 0;
|
|
|
|
// TODO(amontanez): If a submessage fails, we could optionally discard
|
|
// it and continue happily. For now, we'll always invalidate the entire
|
|
// encoder if a single submessage fails.
|
|
status_.Update(nested.status_);
|
|
if (!status_.ok()) {
|
|
return;
|
|
}
|
|
|
|
if (varint::EncodedSize(nested.memory_writer_.bytes_written()) >
|
|
config::kMaxVarintSize) {
|
|
status_ = Status::OutOfRange();
|
|
return;
|
|
}
|
|
|
|
if (!nested.memory_writer_.bytes_written() && !nested.write_when_empty_) {
|
|
return;
|
|
}
|
|
|
|
status_ = WriteLengthDelimitedField(temp_field_number,
|
|
nested.memory_writer_.WrittenData());
|
|
}
|
|
|
|
Status StreamEncoder::WriteVarintField(uint32_t field_number, uint64_t value) {
|
|
PW_TRY(UpdateStatusForWrite(
|
|
field_number, WireType::kVarint, varint::EncodedSize(value)));
|
|
|
|
WriteVarint(FieldKey(field_number, WireType::kVarint))
|
|
.IgnoreError(); // TODO(b/242598609): Handle Status properly
|
|
return WriteVarint(value);
|
|
}
|
|
|
|
Status StreamEncoder::WriteLengthDelimitedField(uint32_t field_number,
|
|
ConstByteSpan data) {
|
|
PW_TRY(UpdateStatusForWrite(field_number, WireType::kDelimited, data.size()));
|
|
status_.Update(WriteLengthDelimitedKeyAndLengthPrefix(
|
|
field_number, data.size(), writer_));
|
|
PW_TRY(status_);
|
|
if (Status status = writer_.Write(data); !status.ok()) {
|
|
status_ = status;
|
|
}
|
|
return status_;
|
|
}
|
|
|
|
Status StreamEncoder::WriteLengthDelimitedFieldFromStream(
|
|
uint32_t field_number,
|
|
stream::Reader& bytes_reader,
|
|
size_t num_bytes,
|
|
ByteSpan stream_pipe_buffer) {
|
|
PW_CHECK_UINT_GT(
|
|
stream_pipe_buffer.size(), 0, "Transfer buffer cannot be 0 size");
|
|
PW_TRY(UpdateStatusForWrite(field_number, WireType::kDelimited, num_bytes));
|
|
status_.Update(
|
|
WriteLengthDelimitedKeyAndLengthPrefix(field_number, num_bytes, writer_));
|
|
PW_TRY(status_);
|
|
|
|
// Stream data from `bytes_reader` to `writer_`.
|
|
// TODO(pwbug/468): move the following logic to pw_stream/copy.h at a later
|
|
// time.
|
|
for (size_t bytes_written = 0; bytes_written < num_bytes;) {
|
|
const size_t chunk_size_bytes =
|
|
std::min(num_bytes - bytes_written, stream_pipe_buffer.size_bytes());
|
|
const Result<ByteSpan> read_result =
|
|
bytes_reader.Read(stream_pipe_buffer.data(), chunk_size_bytes);
|
|
status_.Update(read_result.status());
|
|
PW_TRY(status_);
|
|
|
|
status_.Update(writer_.Write(read_result.value()));
|
|
PW_TRY(status_);
|
|
|
|
bytes_written += read_result.value().size();
|
|
}
|
|
|
|
return OkStatus();
|
|
}
|
|
|
|
Status StreamEncoder::WriteFixed(uint32_t field_number, ConstByteSpan data) {
|
|
WireType type =
|
|
data.size() == sizeof(uint32_t) ? WireType::kFixed32 : WireType::kFixed64;
|
|
|
|
PW_TRY(UpdateStatusForWrite(field_number, type, data.size()));
|
|
|
|
WriteVarint(FieldKey(field_number, type))
|
|
.IgnoreError(); // TODO(b/242598609): Handle Status properly
|
|
if (Status status = writer_.Write(data); !status.ok()) {
|
|
status_ = status;
|
|
}
|
|
return status_;
|
|
}
|
|
|
|
Status StreamEncoder::WritePackedFixed(uint32_t field_number,
|
|
span<const std::byte> values,
|
|
size_t elem_size) {
|
|
if (values.empty()) {
|
|
return status_;
|
|
}
|
|
|
|
PW_CHECK_NOTNULL(values.data());
|
|
PW_DCHECK(elem_size == sizeof(uint32_t) || elem_size == sizeof(uint64_t));
|
|
|
|
PW_TRY(UpdateStatusForWrite(
|
|
field_number, WireType::kDelimited, values.size_bytes()));
|
|
WriteVarint(FieldKey(field_number, WireType::kDelimited))
|
|
.IgnoreError(); // TODO(b/242598609): Handle Status properly
|
|
WriteVarint(values.size_bytes())
|
|
.IgnoreError(); // TODO(b/242598609): Handle Status properly
|
|
|
|
for (auto val_start = values.begin(); val_start != values.end();
|
|
val_start += elem_size) {
|
|
// Allocates 8 bytes so both 4-byte and 8-byte types can be encoded as
|
|
// little-endian for serialization.
|
|
std::array<std::byte, sizeof(uint64_t)> data;
|
|
if (endian::native == endian::little) {
|
|
std::copy(val_start, val_start + elem_size, std::begin(data));
|
|
} else {
|
|
std::reverse_copy(val_start, val_start + elem_size, std::begin(data));
|
|
}
|
|
status_.Update(writer_.Write(span(data).first(elem_size)));
|
|
PW_TRY(status_);
|
|
}
|
|
return status_;
|
|
}
|
|
|
|
Status StreamEncoder::UpdateStatusForWrite(uint32_t field_number,
|
|
WireType type,
|
|
size_t data_size) {
|
|
PW_CHECK(!nested_encoder_open());
|
|
PW_TRY(status_);
|
|
|
|
if (!ValidFieldNumber(field_number)) {
|
|
return status_ = Status::InvalidArgument();
|
|
}
|
|
|
|
const Result<size_t> field_size = SizeOfField(field_number, type, data_size);
|
|
status_.Update(field_size.status());
|
|
PW_TRY(status_);
|
|
|
|
if (field_size.value() > writer_.ConservativeWriteLimit()) {
|
|
status_ = Status::ResourceExhausted();
|
|
}
|
|
|
|
return status_;
|
|
}
|
|
|
|
Status StreamEncoder::Write(span<const std::byte> message,
|
|
span<const internal::MessageField> table) {
|
|
PW_CHECK(!nested_encoder_open());
|
|
PW_TRY(status_);
|
|
|
|
for (const auto& field : table) {
|
|
// Calculate the span of bytes corresponding to the structure field to
|
|
// read from.
|
|
const auto values =
|
|
message.subspan(field.field_offset(), field.field_size());
|
|
PW_CHECK(values.begin() >= message.begin() &&
|
|
values.end() <= message.end());
|
|
|
|
// If the field is using callbacks, interpret the input field accordingly
|
|
// and allow the caller to provide custom handling.
|
|
if (field.use_callback()) {
|
|
const Callback<StreamEncoder, StreamDecoder>* callback =
|
|
reinterpret_cast<const Callback<StreamEncoder, StreamDecoder>*>(
|
|
values.data());
|
|
PW_TRY(callback->Encode(*this));
|
|
continue;
|
|
}
|
|
|
|
switch (field.wire_type()) {
|
|
case WireType::kFixed64:
|
|
case WireType::kFixed32: {
|
|
// Fixed fields call WriteFixed() for singular case and
|
|
// WritePackedFixed() for repeated fields.
|
|
PW_CHECK(field.elem_size() == (field.wire_type() == WireType::kFixed32
|
|
? sizeof(uint32_t)
|
|
: sizeof(uint64_t)),
|
|
"Mismatched message field type and size");
|
|
if (field.is_fixed_size()) {
|
|
PW_CHECK(field.is_repeated(), "Non-repeated fixed size field");
|
|
if (static_cast<size_t>(
|
|
std::count(values.begin(), values.end(), std::byte{0})) <
|
|
values.size()) {
|
|
PW_TRY(WritePackedFixed(
|
|
field.field_number(), values, field.elem_size()));
|
|
}
|
|
} else if (field.is_repeated()) {
|
|
// The struct member for this field is a vector of a type
|
|
// corresponding to the field element size. Cast to the correct
|
|
// vector type so we're not performing type aliasing (except for
|
|
// unsigned vs signed which is explicitly allowed).
|
|
if (field.elem_size() == sizeof(uint64_t)) {
|
|
const auto* vector =
|
|
reinterpret_cast<const pw::Vector<const uint64_t>*>(
|
|
values.data());
|
|
if (!vector->empty()) {
|
|
PW_TRY(WritePackedFixed(
|
|
field.field_number(),
|
|
as_bytes(span(vector->data(), vector->size())),
|
|
field.elem_size()));
|
|
}
|
|
} else if (field.elem_size() == sizeof(uint32_t)) {
|
|
const auto* vector =
|
|
reinterpret_cast<const pw::Vector<const uint32_t>*>(
|
|
values.data());
|
|
if (!vector->empty()) {
|
|
PW_TRY(WritePackedFixed(
|
|
field.field_number(),
|
|
as_bytes(span(vector->data(), vector->size())),
|
|
field.elem_size()));
|
|
}
|
|
}
|
|
} else if (field.is_optional()) {
|
|
// The struct member for this field is a std::optional of a type
|
|
// corresponding to the field element size. Cast to the correct
|
|
// optional type so we're not performing type aliasing (except for
|
|
// unsigned vs signed which is explicitly allowed), and write from
|
|
// a temporary.
|
|
if (field.elem_size() == sizeof(uint64_t)) {
|
|
const auto* optional =
|
|
reinterpret_cast<const std::optional<uint64_t>*>(values.data());
|
|
if (optional->has_value()) {
|
|
uint64_t value = optional->value();
|
|
PW_TRY(
|
|
WriteFixed(field.field_number(), as_bytes(span(&value, 1))));
|
|
}
|
|
} else if (field.elem_size() == sizeof(uint32_t)) {
|
|
const auto* optional =
|
|
reinterpret_cast<const std::optional<uint32_t>*>(values.data());
|
|
if (optional->has_value()) {
|
|
uint32_t value = optional->value();
|
|
PW_TRY(
|
|
WriteFixed(field.field_number(), as_bytes(span(&value, 1))));
|
|
}
|
|
}
|
|
} else {
|
|
PW_CHECK(values.size() == field.elem_size(),
|
|
"Mismatched message field type and size");
|
|
if (static_cast<size_t>(
|
|
std::count(values.begin(), values.end(), std::byte{0})) <
|
|
values.size()) {
|
|
PW_TRY(WriteFixed(field.field_number(), values));
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case WireType::kVarint: {
|
|
// Varint fields call WriteVarintField() for singular case and
|
|
// WritePackedVarints() for repeated fields.
|
|
PW_CHECK(field.elem_size() == sizeof(uint64_t) ||
|
|
field.elem_size() == sizeof(uint32_t) ||
|
|
field.elem_size() == sizeof(bool),
|
|
"Mismatched message field type and size");
|
|
if (field.is_fixed_size()) {
|
|
// The struct member for this field is an array of type corresponding
|
|
// to the field element size. Cast to a span of the correct type over
|
|
// the array so we're not performing type aliasing (except for
|
|
// unsigned vs signed which is explicitly allowed).
|
|
PW_CHECK(field.is_repeated(), "Non-repeated fixed size field");
|
|
if (static_cast<size_t>(
|
|
std::count(values.begin(), values.end(), std::byte{0})) ==
|
|
values.size()) {
|
|
continue;
|
|
}
|
|
if (field.elem_size() == sizeof(uint64_t)) {
|
|
PW_TRY(WritePackedVarints(
|
|
field.field_number(),
|
|
span(reinterpret_cast<const uint64_t*>(values.data()),
|
|
values.size() / field.elem_size()),
|
|
field.varint_type()));
|
|
} else if (field.elem_size() == sizeof(uint32_t)) {
|
|
PW_TRY(WritePackedVarints(
|
|
field.field_number(),
|
|
span(reinterpret_cast<const uint32_t*>(values.data()),
|
|
values.size() / field.elem_size()),
|
|
field.varint_type()));
|
|
} else if (field.elem_size() == sizeof(bool)) {
|
|
static_assert(sizeof(bool) == sizeof(uint8_t),
|
|
"bool must be same size as uint8_t");
|
|
PW_TRY(WritePackedVarints(
|
|
field.field_number(),
|
|
span(reinterpret_cast<const uint8_t*>(values.data()),
|
|
values.size() / field.elem_size()),
|
|
field.varint_type()));
|
|
}
|
|
} else if (field.is_repeated()) {
|
|
// The struct member for this field is a vector of a type
|
|
// corresponding to the field element size. Cast to the correct
|
|
// vector type so we're not performing type aliasing (except for
|
|
// unsigned vs signed which is explicitly allowed).
|
|
if (field.elem_size() == sizeof(uint64_t)) {
|
|
const auto* vector =
|
|
reinterpret_cast<const pw::Vector<const uint64_t>*>(
|
|
values.data());
|
|
if (!vector->empty()) {
|
|
PW_TRY(WritePackedVarints(field.field_number(),
|
|
span(vector->data(), vector->size()),
|
|
field.varint_type()));
|
|
}
|
|
} else if (field.elem_size() == sizeof(uint32_t)) {
|
|
const auto* vector =
|
|
reinterpret_cast<const pw::Vector<const uint32_t>*>(
|
|
values.data());
|
|
if (!vector->empty()) {
|
|
PW_TRY(WritePackedVarints(field.field_number(),
|
|
span(vector->data(), vector->size()),
|
|
field.varint_type()));
|
|
}
|
|
} else if (field.elem_size() == sizeof(bool)) {
|
|
static_assert(sizeof(bool) == sizeof(uint8_t),
|
|
"bool must be same size as uint8_t");
|
|
const auto* vector =
|
|
reinterpret_cast<const pw::Vector<const uint8_t>*>(
|
|
values.data());
|
|
if (!vector->empty()) {
|
|
PW_TRY(WritePackedVarints(field.field_number(),
|
|
span(vector->data(), vector->size()),
|
|
field.varint_type()));
|
|
}
|
|
}
|
|
} else if (field.is_optional()) {
|
|
// The struct member for this field is a std::optional of a type
|
|
// corresponding to the field element size. Cast to the correct
|
|
// optional type so we're not performing type aliasing (except for
|
|
// unsigned vs signed which is explicitly allowed), and write from
|
|
// a temporary.
|
|
uint64_t value = 0;
|
|
if (field.elem_size() == sizeof(uint64_t)) {
|
|
if (field.varint_type() == VarintType::kUnsigned) {
|
|
const auto* optional =
|
|
reinterpret_cast<const std::optional<uint64_t>*>(
|
|
values.data());
|
|
if (!optional->has_value()) {
|
|
continue;
|
|
}
|
|
value = optional->value();
|
|
} else {
|
|
const auto* optional =
|
|
reinterpret_cast<const std::optional<int64_t>*>(
|
|
values.data());
|
|
if (!optional->has_value()) {
|
|
continue;
|
|
}
|
|
value = field.varint_type() == VarintType::kZigZag
|
|
? varint::ZigZagEncode(optional->value())
|
|
: optional->value();
|
|
}
|
|
} else if (field.elem_size() == sizeof(uint32_t)) {
|
|
if (field.varint_type() == VarintType::kUnsigned) {
|
|
const auto* optional =
|
|
reinterpret_cast<const std::optional<uint32_t>*>(
|
|
values.data());
|
|
if (!optional->has_value()) {
|
|
continue;
|
|
}
|
|
value = optional->value();
|
|
} else {
|
|
const auto* optional =
|
|
reinterpret_cast<const std::optional<int32_t>*>(
|
|
values.data());
|
|
if (!optional->has_value()) {
|
|
continue;
|
|
}
|
|
value = field.varint_type() == VarintType::kZigZag
|
|
? varint::ZigZagEncode(optional->value())
|
|
: optional->value();
|
|
}
|
|
} else if (field.elem_size() == sizeof(bool)) {
|
|
const auto* optional =
|
|
reinterpret_cast<const std::optional<bool>*>(values.data());
|
|
if (!optional->has_value()) {
|
|
continue;
|
|
}
|
|
value = optional->value();
|
|
}
|
|
PW_TRY(WriteVarintField(field.field_number(), value));
|
|
} else {
|
|
// The struct member for this field is a scalar of a type
|
|
// corresponding to the field element size. Cast to the correct
|
|
// type to retrieve the value before passing to WriteVarintField()
|
|
// so we're not performing type aliasing (except for unsigned vs
|
|
// signed which is explicitly allowed).
|
|
PW_CHECK(values.size() == field.elem_size(),
|
|
"Mismatched message field type and size");
|
|
uint64_t value = 0;
|
|
if (field.elem_size() == sizeof(uint64_t)) {
|
|
if (field.varint_type() == VarintType::kZigZag) {
|
|
value = varint::ZigZagEncode(
|
|
*reinterpret_cast<const int64_t*>(values.data()));
|
|
} else if (field.varint_type() == VarintType::kNormal) {
|
|
value = *reinterpret_cast<const int64_t*>(values.data());
|
|
} else {
|
|
value = *reinterpret_cast<const uint64_t*>(values.data());
|
|
}
|
|
if (!value) {
|
|
continue;
|
|
}
|
|
} else if (field.elem_size() == sizeof(uint32_t)) {
|
|
if (field.varint_type() == VarintType::kZigZag) {
|
|
value = varint::ZigZagEncode(
|
|
*reinterpret_cast<const int32_t*>(values.data()));
|
|
} else if (field.varint_type() == VarintType::kNormal) {
|
|
value = *reinterpret_cast<const int32_t*>(values.data());
|
|
} else {
|
|
value = *reinterpret_cast<const uint32_t*>(values.data());
|
|
}
|
|
if (!value) {
|
|
continue;
|
|
}
|
|
} else if (field.elem_size() == sizeof(bool)) {
|
|
value = *reinterpret_cast<const bool*>(values.data());
|
|
if (!value) {
|
|
continue;
|
|
}
|
|
}
|
|
PW_TRY(WriteVarintField(field.field_number(), value));
|
|
}
|
|
break;
|
|
}
|
|
case WireType::kDelimited: {
|
|
// Delimited fields are always a singular case because of the
|
|
// inability to cast to a generic vector with an element of a certain
|
|
// size (we always need a type).
|
|
PW_CHECK(!field.is_repeated(),
|
|
"Repeated delimited messages always require a callback");
|
|
if (field.nested_message_fields()) {
|
|
// Nested Message. Struct member is an embedded struct for the
|
|
// nested field. Obtain a nested encoder and recursively call Write()
|
|
// using the fields table pointer from this field.
|
|
auto nested_encoder = GetNestedEncoder(field.field_number(),
|
|
/*write_when_empty=*/false);
|
|
PW_TRY(nested_encoder.Write(values, *field.nested_message_fields()));
|
|
} else if (field.is_fixed_size()) {
|
|
// Fixed-length bytes field. Struct member is a std::array<std::byte>.
|
|
// Call WriteLengthDelimitedField() to output it to the stream.
|
|
PW_CHECK(field.elem_size() == sizeof(std::byte),
|
|
"Mismatched message field type and size");
|
|
if (static_cast<size_t>(
|
|
std::count(values.begin(), values.end(), std::byte{0})) <
|
|
values.size()) {
|
|
PW_TRY(WriteLengthDelimitedField(field.field_number(), values));
|
|
}
|
|
} else {
|
|
// bytes or string field with a maximum size. Struct member is
|
|
// pw::Vector<std::byte> for bytes or pw::InlineString<> for string.
|
|
// Use the contents as a span and call WriteLengthDelimitedField() to
|
|
// output it to the stream.
|
|
PW_CHECK(field.elem_size() == sizeof(std::byte),
|
|
"Mismatched message field type and size");
|
|
if (field.is_string()) {
|
|
PW_TRY(WriteStringOrBytes<const InlineString<>>(
|
|
field.field_number(), values.data()));
|
|
} else {
|
|
PW_TRY(WriteStringOrBytes<const Vector<const std::byte>>(
|
|
field.field_number(), values.data()));
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return status_;
|
|
}
|
|
|
|
} // namespace pw::protobuf
|