h4_packet.h

// Copyright 2024 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.
 
#pragma once
 
#include <cstdint>
#include <cstring>
 
#include "lib/stdcompat/utility.h"
#include "pw_allocator/allocator.h"
#include "pw_bluetooth/hci_h4.emb.h"
#include "pw_function/function.h"
#include "pw_result/result.h"
#include "pw_span/span.h"
 
namespace pw::bluetooth::proxy {
 
 
class H4PacketInterface {
 public:
  using ReleaseFn = Function<void(const uint8_t*)>;
 
  constexpr H4PacketInterface() = default;
  H4PacketInterface(span<uint8_t> buffer,
                    size_t hci_offset,
                    ReleaseFn&& release_fn)
      : buffer_(buffer),
        hci_offset_(hci_offset),
        release_fn_(std::move(release_fn)) {}
 
  H4PacketInterface(const H4PacketInterface& other) = delete;
  H4PacketInterface& operator=(const H4PacketInterface& other) = delete;
 
  H4PacketInterface(H4PacketInterface&& other) { *this = std::move(other); }
  H4PacketInterface& operator=(H4PacketInterface&& other) {
    if (this != &other) {
      buffer_ = other.buffer_;
      hci_offset_ = other.hci_offset_;
      release_fn_ = std::move(other.release_fn_);
      other.Reset();
    }
    return *this;
  }
 
  virtual ~H4PacketInterface() {
    if (!buffer_.empty() && HasReleaseFn()) {
      release_fn_(buffer_.data());
    }
  }
 
  emboss::H4PacketType GetH4Type() const { return DoGetH4Type(); }
 
  void SetH4Type(emboss::H4PacketType type) { DoSetH4Type(type); }
 
  constexpr span<uint8_t> GetHciSpan() {
    return buffer_.empty() ? buffer_ : buffer_.subspan(hci_offset_);
  }
  constexpr span<const uint8_t> GetHciSpan() const {
    return buffer_.empty() ? buffer_ : buffer_.subspan(hci_offset_);
  }
 
  bool HasReleaseFn() { return bool{release_fn_}; }
 
  // Returns the release function (which could be empty) and resets the packet.
  // The caller takes ownership of the buffer and should already have stored it.
  ReleaseFn ResetAndReturnReleaseFn() {
    ReleaseFn fn = std::move(release_fn_);
    Reset();
    return fn;
  }
 
 protected:
  static constexpr std::uint8_t kH4PacketIndicatorSize = 1;
 
  constexpr span<uint8_t> buffer() { return buffer_; }
  constexpr span<const uint8_t> buffer() const { return buffer_; }
 
 private:
  virtual emboss::H4PacketType DoGetH4Type() const = 0;
  virtual void DoSetH4Type(emboss::H4PacketType) = 0;
 
  void Reset() {
    buffer_ = span<uint8_t>();
    hci_offset_ = 0;
    release_fn_ = ReleaseFn{};
  }
 
  span<uint8_t> buffer_;
  size_t hci_offset_ = 0;
  ReleaseFn release_fn_{};
};
 
namespace internal {
 
template <typename T, typename... Args>
Result<T> CopyPacketFrom(Allocator& allocator,
                         span<const uint8_t> src,
                         Args&&... args) {
  uint8_t* owned_buf = static_cast<uint8_t*>(
      allocator.Allocate(allocator::Layout::Of<uint8_t[]>(src.size())));
  if (owned_buf == nullptr) {
    return Status::ResourceExhausted();
  }
  std::memcpy(owned_buf, src.data(), src.size());
  return T(std::forward<Args>(args)...,
           span<uint8_t>(owned_buf, src.size()),
           [&allocator](const uint8_t* data) {
             allocator.Deallocate(const_cast<uint8_t*>(data));
           });
}
 
}  // namespace internal
 
class H4PacketWithHci final : public H4PacketInterface {
 public:
  constexpr H4PacketWithHci() = default;
 
  H4PacketWithHci(emboss::H4PacketType h4_type,
                  span<uint8_t> hci_span,
                  ReleaseFn&& release_fn = nullptr)
      : H4PacketInterface(hci_span, 0, std::move(release_fn)),
        h4_type_(h4_type) {}
 
  H4PacketWithHci(span<uint8_t> h4_span, ReleaseFn&& release_fn = nullptr)
      : H4PacketInterface(
            h4_span, kH4PacketIndicatorSize, std::move(release_fn)),
        h4_type_(emboss::H4PacketType{h4_span[0]}) {}
 
  H4PacketWithHci(H4PacketWithHci&& other) = default;
  H4PacketWithHci& operator=(H4PacketWithHci&& other) = default;
 
  static Result<H4PacketWithHci> CopyFrom(Allocator& allocator,
                                          const H4PacketWithHci& packet) {
    return internal::CopyPacketFrom<H4PacketWithHci>(
        allocator, packet.GetHciSpan(), packet.GetH4Type());
  }
 
 private:
  emboss::H4PacketType DoGetH4Type() const override { return h4_type_; }
  void DoSetH4Type(emboss::H4PacketType h4_type) override {
    h4_type_ = h4_type;
  }
 
  emboss::H4PacketType h4_type_ = emboss::H4PacketType::UNKNOWN;
};
 
class H4PacketWithH4 final : public H4PacketInterface {
 public:
  constexpr H4PacketWithH4() = default;
 
  H4PacketWithH4(span<uint8_t> h4_span, ReleaseFn&& release_fn = nullptr)
      : H4PacketInterface(
            h4_span, kH4PacketIndicatorSize, std::move(release_fn)) {}
 
  H4PacketWithH4(emboss::H4PacketType h4_type,
                 span<uint8_t> h4_span,
                 ReleaseFn&& release_fn = nullptr)
      : H4PacketWithH4(h4_span, std::move(release_fn)) {
    SetH4Type(h4_type);
  }
 
  constexpr span<uint8_t> GetH4Span() { return buffer(); }
  constexpr span<const uint8_t> GetH4Span() const { return buffer(); }
 
  static Result<H4PacketWithH4> CopyFrom(Allocator& allocator,
                                         const H4PacketWithH4& packet) {
    return internal::CopyPacketFrom<H4PacketWithH4>(allocator,
                                                    packet.GetH4Span());
  }
 
 private:
  emboss::H4PacketType DoGetH4Type() const override {
    span<const uint8_t> h4_span = GetH4Span();
    return !h4_span.empty() ? emboss::H4PacketType(h4_span[0])
                            : emboss::H4PacketType::UNKNOWN;
  }
 
  void DoSetH4Type(emboss::H4PacketType h4_type) override {
    span<uint8_t> h4_span = GetH4Span();
    if (!h4_span.empty()) {
      h4_span.data()[0] = cpp23::to_underlying(h4_type);
    }
  }
};
 
}  // namespace pw::bluetooth::proxy