router.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
 
//         __      ___   ___ _  _ ___ _  _  ___
//         \ \    / /_\ | _ \ \| |_ _| \| |/ __|
//          \ \/\/ / _ \|   / .` || || .` | (_ |
//           \_/\_/_/ \_\_|_\_|\_|___|_|\_|\___|
//  _____  _____ ___ ___ ___ __  __ ___ _  _ _____ _   _
// | __\ \/ / _ \ __| _ \_ _|  \/  | __| \| |_   _/_\ | |
// | _| >  <|  _/ _||   /| || |\/| | _|| .` | | |/ _ \| |__
// |___/_/\_\_| |___|_|_\___|_|  |_|___|_|\_| |_/_/ \_\____|
//
// This module is in an early, experimental state. The APIs are in flux and may
// change without notice. Please do not rely on it in production code, but feel
// free to explore and share feedback with the Pigweed team!
 
#include "pw_async2/dispatcher.h"
#include "pw_async2/poll.h"
#include "pw_channel/channel.h"
#include "pw_containers/vector.h"
#include "pw_hdlc/decoder.h"
#include "pw_multibuf/allocator.h"
#include "pw_multibuf/multibuf.h"
#include "pw_status/status.h"
 
namespace pw::hdlc {
 
 
class Router final {
 public:
  class Registration;
 
  Router(pw::channel::ByteReaderWriter& io_channel, ByteSpan decode_buffer)
      : io_channel_(io_channel), decoder_(decode_buffer) {}
 
  // Router is not copyable or movable.
  Router(const Router&) = delete;
  Router& operator=(const Router&) = delete;
  Router(Router&&) = delete;
  Router& operator=(Router&&) = delete;
 
  Status AddChannel(pw::channel::DatagramReaderWriter& channel,
                    uint64_t receive_address,
                    uint64_t send_address);
 
  Status RemoveChannel(pw::channel::DatagramReaderWriter& channel,
                       uint64_t receive_address,
                       uint64_t send_address);
 
  pw::async2::Poll<> Pend(pw::async2::Context& cx);
 
  pw::async2::Poll<> PendClose(pw::async2::Context& cx);
 
 private:
  // TODO: https://pwbug.dev/329902904 - Use allocator-based collections and
  // remove this arbitrary limit.
  constexpr static size_t kSomeNumberOfChannels = 16;
 
  struct ChannelData {
    ChannelData(pw::channel::DatagramReaderWriter& channel_arg,
                uint64_t receive_address_arg,
                uint64_t send_address_arg)
        : channel(&channel_arg),
          receive_address(receive_address_arg),
          send_address(send_address_arg) {}
 
    ChannelData(const ChannelData&) = delete;
    ChannelData& operator=(const ChannelData&) = delete;
    ChannelData(ChannelData&&) = default;
    ChannelData& operator=(ChannelData&&) = default;
 
    pw::channel::DatagramReaderWriter* channel;
 
    uint64_t receive_address;
 
    uint64_t send_address;
  };
 
  ChannelData* FindChannelForReceiveAddress(uint64_t receive_address);
 
  void DecodeAndWriteIncoming(pw::async2::Context& cx);
 
  pw::async2::Poll<> PollDeliverIncomingFrame(pw::async2::Context& cx,
                                              const Frame& frame);
 
  void TryFillBufferToEncodeAndSend(pw::async2::Context& cx);
 
  void WriteOutgoingMessages(pw::async2::Context& cx);
 
  void RemoveClosedChannels();
 
 
  pw::channel::ByteReaderWriter& io_channel_;
 
  pw::Vector<ChannelData, kSomeNumberOfChannels> channel_datas_;
 
 
  pw::multibuf::MultiBuf incoming_data_;
 
  pw::hdlc::Decoder decoder_;
 
  std::optional<pw::hdlc::Frame> decoded_frame_;
 
 
  struct OutgoingBuffer {
    pw::multibuf::MultiBuf buffer;
    size_t hdlc_encoded_size;
    uint64_t target_address;
  };
  std::optional<OutgoingBuffer> buffer_to_encode_and_send_;
 
  size_t next_first_read_index_ = 0;
};
 
}  // namespace pw::hdlc