blob: 7d9665a35ab0d438887c42babfee7bbc6ae64105 [file] [log] [blame]
// 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_bluetooth_hci/packet.h"
#include "pw_bytes/byte_builder.h"
#include "pw_bytes/endian.h"
#include "pw_status/try.h"
namespace pw::bluetooth_hci {
namespace {
using pw::bytes::ReadInOrder;
} // namespace
Result<ConstByteSpan> CommandPacket::Encode(ByteSpan buffer,
endian order) const {
ByteBuilder builder(buffer);
builder.PutUint16(opcode_, order);
builder.PutUint8(parameters_.size_bytes());
builder.append(parameters_);
PW_TRY(builder.status());
return ConstByteSpan(builder.data(), builder.size());
}
std::optional<CommandPacket> CommandPacket::Decode(ConstByteSpan data,
endian order) {
if (data.size_bytes() < kHeaderSizeBytes) {
return std::nullopt; // Not enough data to parse the packet header.
}
const uint8_t parameter_total_length =
static_cast<uint8_t>(data[kParameterTotalLengthByteOffset]);
if (data.size_bytes() < (kHeaderSizeBytes + parameter_total_length)) {
return std::nullopt; // Not enough data to cover the parameter bytes.
}
const uint16_t opcode =
ReadInOrder<uint16_t>(order, &data[kOpcodeByteOffset]);
return CommandPacket(
opcode, ConstByteSpan(&data[kHeaderSizeBytes], parameter_total_length));
}
Result<ConstByteSpan> AsyncDataPacket::Encode(ByteSpan buffer,
endian order) const {
ByteBuilder builder(buffer);
builder.PutUint16(handle_and_fragmentation_bits_, order);
builder.PutUint16(data_.size_bytes(), order);
builder.append(data_);
PW_TRY(builder.status());
return ConstByteSpan(builder.data(), builder.size());
}
std::optional<AsyncDataPacket> AsyncDataPacket::Decode(ConstByteSpan data,
endian order) {
if (data.size_bytes() < kHeaderSizeBytes) {
return std::nullopt; // Not enough data to parse the packet header.
}
const uint16_t data_total_length =
ReadInOrder<uint16_t>(order, &data[kDataTotalLengthByteOffset]);
if (data.size_bytes() < (kHeaderSizeBytes + data_total_length)) {
return std::nullopt; // Not enough data to cover the data bytes.
}
const uint16_t handle_and_flag_bits = ReadInOrder<uint16_t>(
order, &data[kHandleAndFragmentationBitsByteOffset]);
return AsyncDataPacket(
handle_and_flag_bits,
ConstByteSpan(&data[kHeaderSizeBytes], data_total_length));
}
Result<ConstByteSpan> SyncDataPacket::Encode(ByteSpan buffer,
endian order) const {
ByteBuilder builder(buffer);
builder.PutUint16(handle_and_status_bits_, order);
builder.PutUint8(data_.size_bytes());
builder.append(data_);
PW_TRY(builder.status());
return ConstByteSpan(builder.data(), builder.size());
}
std::optional<SyncDataPacket> SyncDataPacket::Decode(ConstByteSpan data,
endian order) {
if (data.size_bytes() < kHeaderSizeBytes) {
return std::nullopt; // Not enough data to parse the packet header.
}
const uint8_t data_total_length =
static_cast<uint8_t>(data[kDataTotalLengthByteOffset]);
if (data.size_bytes() < (kHeaderSizeBytes + data_total_length)) {
return std::nullopt; // Not enough data to cover the data bytes.
}
const uint16_t handle_and_status_bits =
ReadInOrder<uint16_t>(order, &data[kHandleAndStatusBitsByteOffset]);
return SyncDataPacket(
handle_and_status_bits,
ConstByteSpan(&data[kHeaderSizeBytes], data_total_length));
}
Result<ConstByteSpan> EventPacket::Encode(ByteSpan buffer) const {
ByteBuilder builder(buffer);
builder.PutUint8(event_code_);
builder.PutUint8(parameters_.size_bytes());
builder.append(parameters_);
PW_TRY(builder.status());
return ConstByteSpan(builder.data(), builder.size());
}
std::optional<EventPacket> EventPacket::Decode(ConstByteSpan data) {
if (data.size_bytes() < kHeaderSizeBytes) {
return std::nullopt; // Not enough data to parse the packet header.
}
const uint8_t parameter_total_length =
static_cast<uint8_t>(data[kParameterTotalLengthByteOffset]);
if (data.size_bytes() < (kHeaderSizeBytes + parameter_total_length)) {
return std::nullopt; // Not enough data to cover the parameter bytes.
}
const uint8_t event_code = static_cast<uint8_t>(data[kEventCodeByteOffset]);
return EventPacket(
event_code,
ConstByteSpan(&data[kHeaderSizeBytes], parameter_total_length));
}
} // namespace pw::bluetooth_hci