Line data    Source code

       1             : #include "source/common/quic/envoy_quic_packet_writer.h"
       2             : 
       3             : #include <memory>
       4             : 
       5             : #include "source/common/buffer/buffer_impl.h"
       6             : #include "source/common/quic/envoy_quic_utils.h"
       7             : 
       8             : namespace Envoy {
       9             : namespace Quic {
      10             : 
      11             : namespace {
      12             : 
      13           0 : quic::WriteResult convertToQuicWriteResult(Api::IoCallUint64Result& result) {
      14           0 :   if (result.ok()) {
      15           0 :     return {quic::WRITE_STATUS_OK, static_cast<int>(result.return_value_)};
      16           0 :   }
      17           0 :   quic::WriteStatus status = result.err_->getErrorCode() == Api::IoError::IoErrorCode::Again
      18           0 :                                  ? quic::WRITE_STATUS_BLOCKED
      19           0 :                                  : quic::WRITE_STATUS_ERROR;
      20           0 :   return {status, static_cast<int>(result.err_->getSystemErrorCode())};
      21           0 : }
      22             : 
      23             : } // namespace
      24             : 
      25             : EnvoyQuicPacketWriter::EnvoyQuicPacketWriter(Network::UdpPacketWriterPtr envoy_udp_packet_writer)
      26           0 :     : envoy_udp_packet_writer_(std::move(envoy_udp_packet_writer)) {}
      27             : 
      28             : quic::WriteResult EnvoyQuicPacketWriter::WritePacket(
      29             :     const char* buffer, size_t buffer_len, const quic::QuicIpAddress& self_ip,
      30             :     const quic::QuicSocketAddress& peer_address, quic::PerPacketOptions* options,
      31           0 :     [[maybe_unused]] const quic::QuicPacketWriterParams& params) {
      32           0 :   ASSERT(options == nullptr, "Per packet option is not supported yet.");
      33             : 
      34           0 :   Buffer::BufferFragmentImpl fragment(buffer, buffer_len, nullptr);
      35           0 :   Buffer::OwnedImpl buf;
      36           0 :   buf.addBufferFragment(fragment);
      37             : 
      38           0 :   quic::QuicSocketAddress self_address(self_ip, /*port=*/0);
      39           0 :   Network::Address::InstanceConstSharedPtr local_addr =
      40           0 :       quicAddressToEnvoyAddressInstance(self_address);
      41           0 :   Network::Address::InstanceConstSharedPtr remote_addr =
      42           0 :       quicAddressToEnvoyAddressInstance(peer_address);
      43             : 
      44           0 :   Api::IoCallUint64Result result = envoy_udp_packet_writer_->writePacket(
      45           0 :       buf, local_addr == nullptr ? nullptr : local_addr->ip(), *remote_addr);
      46             : 
      47           0 :   return convertToQuicWriteResult(result);
      48           0 : }
      49             : 
      50           0 : absl::optional<int> EnvoyQuicPacketWriter::MessageTooBigErrorCode() const { return EMSGSIZE; }
      51             : 
      52             : quic::QuicByteCount
      53           0 : EnvoyQuicPacketWriter::GetMaxPacketSize(const quic::QuicSocketAddress& peer_address) const {
      54           0 :   Network::Address::InstanceConstSharedPtr remote_addr =
      55           0 :       quicAddressToEnvoyAddressInstance(peer_address);
      56           0 :   return static_cast<quic::QuicByteCount>(envoy_udp_packet_writer_->getMaxPacketSize(*remote_addr));
      57           0 : }
      58             : 
      59             : quic::QuicPacketBuffer
      60             : EnvoyQuicPacketWriter::GetNextWriteLocation(const quic::QuicIpAddress& self_ip,
      61           0 :                                             const quic::QuicSocketAddress& peer_address) {
      62           0 :   quic::QuicSocketAddress self_address(self_ip, /*port=*/0);
      63           0 :   Network::Address::InstanceConstSharedPtr local_addr =
      64           0 :       quicAddressToEnvoyAddressInstance(self_address);
      65           0 :   Network::Address::InstanceConstSharedPtr remote_addr =
      66           0 :       quicAddressToEnvoyAddressInstance(peer_address);
      67           0 :   Network::UdpPacketWriterBuffer write_location = envoy_udp_packet_writer_->getNextWriteLocation(
      68           0 :       local_addr == nullptr ? nullptr : local_addr->ip(), *remote_addr);
      69           0 :   return {reinterpret_cast<char*>(write_location.buffer_), write_location.release_buffer_};
      70           0 : }
      71             : 
      72           0 : quic::WriteResult EnvoyQuicPacketWriter::Flush() {
      73           0 :   Api::IoCallUint64Result result = envoy_udp_packet_writer_->flush();
      74           0 :   return convertToQuicWriteResult(result);
      75           0 : }
      76             : 
      77             : } // namespace Quic
      78             : } // namespace Envoy