proxy_host.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 <bitset>
 
#include "pw_bluetooth/hci_common.emb.h"
#include "pw_bluetooth_proxy/gatt_notify_channel.h"
#include "pw_bluetooth_proxy/internal/acl_data_channel.h"
#include "pw_bluetooth_proxy/internal/hci_transport.h"
#include "pw_bluetooth_proxy/internal/l2cap_channel_manager.h"
#include "pw_bluetooth_proxy/l2cap_channel_common.h"
#include "pw_bluetooth_proxy/l2cap_coc.h"
#include "pw_bluetooth_proxy/l2cap_status_delegate.h"
#include "pw_function/function.h"
#include "pw_multibuf/multibuf.h"
#include "pw_status/status.h"
#include "pw_sync/lock_annotations.h"
#include "pw_sync/mutex.h"
 
#if PW_BLUETOOTH_PROXY_ASYNC == 0
#include "pw_bluetooth_proxy/internal/proxy_host_sync.h"
 
// TODO: b/472522742 - Forward-declare the dispatcher until downstream support
// for pw_async2 is resolved.
namespace pw::async2 {
class Dispatcher;
}  // namespace pw::async2
#else
#include "pw_async2/dispatcher.h"
#include "pw_bluetooth_proxy/internal/proxy_host_async.h"
#endif  // PW_BLUETOOTH_PROXY_ASYNC
 
namespace pw::bluetooth::proxy {
 
 
class ProxyHost : public L2capChannelManagerInterface {
 public:
  // TODO: b/505912880 - Fix deadlock when release_fn sends packets.
  ProxyHost(pw::Function<void(H4PacketWithHci&& packet)>&& send_to_host_fn,
            pw::Function<void(H4PacketWithH4&& packet)>&& send_to_controller_fn,
            pw::Allocator& allocator);
 
  ProxyHost(pw::Function<void(H4PacketWithHci&& packet)>&& send_to_host_fn,
            pw::Function<void(H4PacketWithH4&& packet)>&& send_to_controller_fn,
            uint16_t le_acl_credits_to_reserve,
            uint16_t br_edr_acl_credits_to_reserve,
            pw::Allocator* allocator);
 
  ProxyHost() = delete;
  ProxyHost(const ProxyHost&) = delete;
  ProxyHost& operator=(const ProxyHost&) = delete;
  ProxyHost(ProxyHost&&) = delete;
  ProxyHost& operator=(ProxyHost&&) = delete;
  ~ProxyHost() override;
 
  // ##### Configuration APIs
 
  void SetEventBlocked(emboss::EventCode event_code, bool blocked);
 
  void SetLeSubeventBlocked(emboss::LeSubEventCode subevent_code, bool blocked);
 
  void ResetFilters();
 
  bool IsEventBlocked(emboss::EventCode event_code) const;
 
  bool IsLeSubeventBlocked(emboss::LeSubEventCode subevent_code) const;
 
  // ##### Container API
  // Containers are expected to call these functions (in addition to ctor).
 
  void HandleH4HciFromHost(H4PacketWithH4&& h4_packet);
 
  void HandleH4HciFromController(H4PacketWithHci&& h4_packet);
 
  void Reset();
 
  // ##### Container async API
 
  Status SetDispatcher(async2::Dispatcher& dispatcher);
 
  // ##### Client APIs
 
  void RegisterL2capStatusDelegate(L2capStatusDelegate& delegate);
 
  void UnregisterL2capStatusDelegate(L2capStatusDelegate& delegate);
 
  pw::Result<L2capCoc> AcquireL2capCoc(
      multibuf::MultiBufAllocator& rx_multibuf_allocator,
      uint16_t connection_handle,
      L2capCoc::CocConfig rx_config,
      L2capCoc::CocConfig tx_config,
      Function<void(multibuf::MultiBuf&& payload)>&& receive_fn,
      ChannelEventCallback&& event_fn);
 
  pw::Result<BasicL2capChannel> AcquireBasicL2capChannel(
      multibuf::MultiBufAllocator& rx_multibuf_allocator,
      uint16_t connection_handle,
      uint16_t local_cid,
      uint16_t remote_cid,
      AclTransportType transport,
      OptionalPayloadReceiveCallback&& payload_from_controller_fn,
      OptionalPayloadReceiveCallback&& payload_from_host_fn,
      ChannelEventCallback&& event_fn);
 
  pw::Result<GattNotifyChannel> AcquireGattNotifyChannel(
      int16_t connection_handle,
      uint16_t attribute_handle,
      ChannelEventCallback&& event_fn);
 
  bool HasSendLeAclCapability() const;
 
  bool HasSendBrEdrAclCapability() const;
 
  uint16_t GetNumFreeLeAclPackets() const;
 
  uint16_t GetNumFreeBrEdrAclPackets() const;
 
  static constexpr size_t GetMaxNumAclConnections() {
    return AclDataChannel::GetMaxNumAclConnections();
  }
 
 private:
  friend class internal::ProxyHostImpl;
 
  void DoHandleH4HciFromHost(H4PacketWithH4&& h4_packet);
 
  void DoHandleH4HciFromController(H4PacketWithHci&& h4_packet);
 
  void DoReset();
 
  void DoRegisterL2capStatusDelegate(L2capStatusDelegate& delegate);
 
  void DoUnregisterL2capStatusDelegate(L2capStatusDelegate& delegate);
 
  pw::Result<L2capCoc> DoAcquireL2capCoc(
      multibuf::MultiBufAllocator& rx_multibuf_allocator,
      uint16_t connection_handle,
      L2capCoc::CocConfig rx_config,
      L2capCoc::CocConfig tx_config,
      Function<void(multibuf::MultiBuf&& payload)>&& receive_fn,
      ChannelEventCallback&& event_fn);
 
  pw::Result<BasicL2capChannel> DoAcquireBasicL2capChannel(
      multibuf::MultiBufAllocator& rx_multibuf_allocator,
      uint16_t connection_handle,
      uint16_t local_cid,
      uint16_t remote_cid,
      AclTransportType transport,
      OptionalPayloadReceiveCallback&& payload_from_controller_fn,
      OptionalPayloadReceiveCallback&& payload_from_host_fn,
      ChannelEventCallback&& event_fn);
 
  pw::Result<GattNotifyChannel> DoAcquireGattNotifyChannel(
      int16_t connection_handle,
      uint16_t attribute_handle,
      ChannelEventCallback&& event_fn);
 
  bool DoHasSendLeAclCapability() const;
 
  bool DoHasSendBrEdrAclCapability() const;
 
  uint16_t DoGetNumFreeLeAclPackets() const;
 
  uint16_t DoGetNumFreeBrEdrAclPackets() const;
 
  // Handle HCI Event packet from the controller.
  void HandleEventFromController(H4PacketWithHci&& h4_packet);
 
  // Handle HCI Event packet from the host.
  void HandleEventFromHost(H4PacketWithH4&& h4_packet);
 
  // Handle HCI ACL data packet from the controller.
  void HandleAclFromController(H4PacketWithHci&& h4_packet);
 
  // Process an LE_META_EVENT
  bool HandleLeMetaEvent(H4PacketWithHci& h4_packet);
 
  // Process a Command_Complete event.
  bool HandleCommandCompleteEvent(H4PacketWithHci& h4_packet);
 
  // Handle HCI Command packet from the host.
  void HandleCommandFromHost(H4PacketWithH4&& h4_packet);
 
  // Handle HCI ACL data packet from the host.
  void HandleAclFromHost(H4PacketWithH4&& h4_packet);
 
  // Called when any type of connection complete event is received.
  void OnConnectionCompleteSuccess(uint16_t connection_handle,
                                   AclTransportType transport);
 
  // AclDataChannel callback for when new ACL TX credits are received and more
  // L2CAP packets can be sent.
  void OnAclTxCredits();
 
  // L2capChannelManagerInterface override:
  Result<UniquePtr<ChannelProxy>> DoInterceptBasicModeChannel(
      ConnectionHandle connection_handle,
      uint16_t local_channel_id,
      uint16_t remote_channel_id,
      AclTransportType transport,
      BufferReceiveFunction&& payload_from_controller_fn,
      BufferReceiveFunction&& payload_from_host_fn,
      ChannelEventCallback&& event_fn) override;
 
  Result<UniquePtr<ChannelProxy>> InternalDoInterceptBasicModeChannel(
      ConnectionHandle connection_handle,
      uint16_t local_channel_id,
      uint16_t remote_channel_id,
      AclTransportType transport,
      BufferReceiveFunction&& payload_from_controller_fn,
      BufferReceiveFunction&& payload_from_host_fn,
      ChannelEventCallback&& event_fn);
 
  Result<UniquePtr<ChannelProxy>> DoInterceptCreditBasedFlowControlChannel(
      ConnectionHandle connection_handle,
      ConnectionOrientedChannelConfig rx_config,
      ConnectionOrientedChannelConfig tx_config,
      MultiBufReceiveFunction&& receive_fn,
      ChannelEventCallback&& event_fn) override;
 
  // Implementation-specific details that may vary between sync and async modes.
  internal::ProxyHostImpl impl_;
 
  // For sending non-ACL data to the host and controller. ACL traffic shall be
  // sent through the `acl_data_channel_`.
  HciTransport hci_transport_;
 
  // Owns management of the LE ACL data channel.
  AclDataChannel acl_data_channel_;
 
  // Keeps track of the L2CAP-based channels managed by the proxy.
  L2capChannelManager l2cap_channel_manager_;
 
  mutable sync::Mutex filter_mutex_;
 
  // Storage for blocked events (256 bits for 256 possible codes)
  std::bitset<256> blocked_events_ PW_GUARDED_BY(filter_mutex_);
  std::bitset<256> blocked_le_subevents_ PW_GUARDED_BY(filter_mutex_);
};
 
}  // namespace pw::bluetooth::proxy