// Copyright 2019 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "net/third_party/quiche/src/quic/core/quic_udp_socket.h"
#include <sys/socket.h>

#ifdef __APPLE__
#include <TargetConditionals.h>
#endif

#include "net/third_party/quiche/src/quic/core/quic_constants.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"

namespace quic {
namespace test {
namespace {
// Used by ReadMultiplePackets tests.
struct ReadBuffers {
  char control_buffer[512];
  char packet_buffer[1536];
};

// Allows IPv6-specific testing.
struct TestParameters {
  // If true, the test will only use IPv6.  If false, IPv4 will be used if
  // possible, with IPv6 used as a fallback.
  bool force_ipv6;
  // The value of ipv6_only to be used in QuicUdpSocketApi::Create calls.
  bool ipv6_only;
};
}  // namespace

class QuicUdpSocketTest : public QuicTestWithParam<TestParameters> {
 protected:
  void SetUp() override {
    const TestParameters& parameters = GetParam();
    if (!parameters.force_ipv6) {
      // Try creating AF_INET socket, if it fails because of unsupported address
      // family then tests are being run under IPv6-only environment, initialize
      // address family to use for running the test under as AF_INET6 otherwise
      // initialize it as AF_INET.
      address_family_ = AF_INET;
      fd_client_ =
          api_.Create(address_family_,
                      /*receive_buffer_size =*/kDefaultSocketReceiveBuffer,
                      /*send_buffer_size =*/kDefaultSocketReceiveBuffer,
                      /*ipv6_only =*/parameters.ipv6_only);
    }
    if (fd_client_ == kQuicInvalidSocketFd) {
      // Either AF_INET is unsupported, or force_ipv6 is true.
      address_family_ = AF_INET6;
      fd_client_ =
          api_.Create(address_family_,
                      /*receive_buffer_size =*/kDefaultSocketReceiveBuffer,
                      /*send_buffer_size =*/kDefaultSocketReceiveBuffer,
                      /*ipv6_only =*/parameters.ipv6_only);
    }
    ASSERT_NE(fd_client_, kQuicInvalidSocketFd);

    fd_server_ =
        api_.Create(address_family_,
                    /*receive_buffer_size =*/kDefaultSocketReceiveBuffer,
                    /*send_buffer_size =*/kDefaultSocketReceiveBuffer,
                    /*ipv6_only =*/parameters.ipv6_only);
    ASSERT_NE(fd_server_, kQuicInvalidSocketFd);

    ASSERT_TRUE(
        api_.Bind(fd_server_, QuicSocketAddress(Loopback(), /*port=*/0)));

    ASSERT_EQ(0, server_address_.FromSocket(fd_server_));

    QUIC_LOG(INFO) << "Testing under IP"
                   << std::string((address_family_ == AF_INET) ? "v4" : "v6");
  }

  ~QuicUdpSocketTest() {
    api_.Destroy(fd_client_);
    api_.Destroy(fd_server_);
  }

  QuicIpAddress Loopback() const {
    return (address_family_ == AF_INET) ? QuicIpAddress::Loopback4()
                                        : QuicIpAddress::Loopback6();
  }

  // Client sends the first |packet_size| bytes in |client_packet_buffer_| to
  // server.
  WriteResult SendPacketFromClient(size_t packet_size) {
    EXPECT_LE(packet_size, sizeof(client_packet_buffer_));
    QuicUdpPacketInfo packet_info;
    packet_info.SetPeerAddress(server_address_);
    return api_.WritePacket(fd_client_, client_packet_buffer_, packet_size,
                            packet_info);
  }

  WriteResult SendPacketFromClientWithTtl(size_t packet_size, int ttl) {
    EXPECT_LE(packet_size, sizeof(client_packet_buffer_));
    QuicUdpPacketInfo packet_info;
    packet_info.SetPeerAddress(server_address_);
    packet_info.SetTtl(ttl);
    return api_.WritePacket(fd_client_, client_packet_buffer_, packet_size,
                            packet_info);
  }

  // Server waits for an incoming packet and reads it into
  // |server_packet_buffer_|.
  QuicUdpSocketApi::ReadPacketResult ReadPacketFromServer(
      BitMask64 packet_info_interested) {
    EXPECT_TRUE(
        api_.WaitUntilReadable(fd_server_, QuicTime::Delta::FromSeconds(5)));
    memset(server_packet_buffer_, 0, sizeof(server_packet_buffer_));
    QuicUdpSocketApi::ReadPacketResult result;
    result.packet_buffer = {server_packet_buffer_,
                            sizeof(server_packet_buffer_)};
    result.control_buffer = {server_control_buffer_,
                             sizeof(server_control_buffer_)};
    api_.ReadPacket(fd_server_, packet_info_interested, &result);
    return result;
  }

  int ComparePacketBuffers(size_t packet_size) {
    return memcmp(client_packet_buffer_, server_packet_buffer_, packet_size);
  }

  bool VerifyBufferIsFilledWith(const char* buffer,
                                size_t buffer_length,
                                char c) {
    for (size_t i = 0; i < buffer_length; ++i) {
      if (buffer[i] != c) {
        return false;
      }
    }
    return true;
  }

  QuicUdpSocketApi api_;
  QuicUdpSocketFd fd_client_ = kQuicInvalidSocketFd;
  QuicUdpSocketFd fd_server_ = kQuicInvalidSocketFd;
  QuicSocketAddress server_address_;
  int address_family_;
  char client_packet_buffer_[kEthernetMTU] = {0};
  char server_packet_buffer_[kDefaultMaxPacketSize] = {0};
  char server_control_buffer_[512] = {0};
};

INSTANTIATE_TEST_SUITE_P(
    PlatformIndependent,
    QuicUdpSocketTest,
    testing::Values(TestParameters{/*force_ipv6 =*/false, /*ipv6_only =*/false},
                    TestParameters{/*force_ipv6 =*/false, /*ipv6_only =*/true},
                    TestParameters{/*force_ipv6 =*/true, /*ipv6_only =*/true}));

#ifndef TARGET_OS_IPHONE
// IPv6 on iOS is known to fail without ipv6_only, so should not be tested.
INSTANTIATE_TEST_SUITE_P(NonIos,
                         QuicUdpSocketTest,
                         testing::Values(TestParameters{/*force_ipv6 =*/true,
                                                        /*ipv6_only =*/false}));
#endif

TEST_P(QuicUdpSocketTest, ReadPacketResultReset) {
  QuicUdpSocketApi::ReadPacketResult result;
  result.packet_info.SetDroppedPackets(100);
  result.packet_buffer.buffer_len = 100;
  result.ok = true;

  result.Reset(/*packet_buffer_length=*/200);

  EXPECT_FALSE(result.ok);
  EXPECT_FALSE(
      result.packet_info.HasValue(QuicUdpPacketInfoBit::DROPPED_PACKETS));
  EXPECT_EQ(200u, result.packet_buffer.buffer_len);
}

TEST_P(QuicUdpSocketTest, ReadPacketOnly) {
  const size_t kPacketSize = 512;
  memset(client_packet_buffer_, '-', kPacketSize);
  ASSERT_EQ(WriteResult(WRITE_STATUS_OK, kPacketSize),
            SendPacketFromClient(kPacketSize));

  QuicUdpSocketApi::ReadPacketResult read_result =
      ReadPacketFromServer(/*packet_info_interested=*/BitMask64());
  ASSERT_TRUE(read_result.ok);
  ASSERT_EQ(kPacketSize, read_result.packet_buffer.buffer_len);
  ASSERT_EQ(0, ComparePacketBuffers(kPacketSize));
}

TEST_P(QuicUdpSocketTest, ReadTruncated) {
  const size_t kPacketSize = kDefaultMaxPacketSize + 1;
  memset(client_packet_buffer_, '*', kPacketSize);
  ASSERT_EQ(WriteResult(WRITE_STATUS_OK, kPacketSize),
            SendPacketFromClient(kPacketSize));

  QuicUdpSocketApi::ReadPacketResult read_result =
      ReadPacketFromServer(/*packet_info_interested=*/BitMask64());
  ASSERT_FALSE(read_result.ok);
}

TEST_P(QuicUdpSocketTest, ReadDroppedPackets) {
  const size_t kPacketSize = kDefaultMaxPacketSize;
  memset(client_packet_buffer_, '-', kPacketSize);
  ASSERT_EQ(WriteResult(WRITE_STATUS_OK, kPacketSize),
            SendPacketFromClient(kPacketSize));
  ASSERT_EQ(WriteResult(WRITE_STATUS_OK, kPacketSize),
            SendPacketFromClient(kPacketSize));

  // Read the first packet without enabling DROPPED_PACKETS.
  QuicUdpSocketApi::ReadPacketResult read_result =
      ReadPacketFromServer(BitMask64(QuicUdpPacketInfoBit::DROPPED_PACKETS));
  ASSERT_TRUE(read_result.ok);
  ASSERT_EQ(kPacketSize, read_result.packet_buffer.buffer_len);
  ASSERT_EQ(0, ComparePacketBuffers(kPacketSize));
  ASSERT_FALSE(
      read_result.packet_info.HasValue(QuicUdpPacketInfoBit::DROPPED_PACKETS));

  // Enable DROPPED_PACKETS and read the second packet.
  if (!api_.EnableDroppedPacketCount(fd_server_)) {
    QUIC_LOG(INFO) << "DROPPED_PACKETS is not supported";
    return;
  }
  read_result =
      ReadPacketFromServer(BitMask64(QuicUdpPacketInfoBit::DROPPED_PACKETS));
  ASSERT_TRUE(read_result.ok);
  ASSERT_EQ(kPacketSize, read_result.packet_buffer.buffer_len);
  ASSERT_EQ(0, ComparePacketBuffers(kPacketSize));
  if (read_result.packet_info.HasValue(QuicUdpPacketInfoBit::DROPPED_PACKETS)) {
    EXPECT_EQ(0u, read_result.packet_info.dropped_packets());
  }
}

TEST_P(QuicUdpSocketTest, ReadSelfIp) {
  const QuicUdpPacketInfoBit self_ip_bit =
      (address_family_ == AF_INET) ? QuicUdpPacketInfoBit::V4_SELF_IP
                                   : QuicUdpPacketInfoBit::V6_SELF_IP;

  const size_t kPacketSize = 512;
  memset(client_packet_buffer_, '&', kPacketSize);
  ASSERT_EQ(WriteResult(WRITE_STATUS_OK, kPacketSize),
            SendPacketFromClient(kPacketSize));

  QuicUdpSocketApi::ReadPacketResult read_result =
      ReadPacketFromServer(BitMask64(self_ip_bit));
  ASSERT_TRUE(read_result.ok);
  ASSERT_EQ(kPacketSize, read_result.packet_buffer.buffer_len);
  ASSERT_EQ(0, ComparePacketBuffers(kPacketSize));
  ASSERT_TRUE(read_result.packet_info.HasValue(self_ip_bit));
  EXPECT_EQ(Loopback(), (address_family_ == AF_INET)
                            ? read_result.packet_info.self_v4_ip()
                            : read_result.packet_info.self_v6_ip());
}

TEST_P(QuicUdpSocketTest, ReadReceiveTimestamp) {
  const size_t kPacketSize = kDefaultMaxPacketSize;
  memset(client_packet_buffer_, '-', kPacketSize);
  ASSERT_EQ(WriteResult(WRITE_STATUS_OK, kPacketSize),
            SendPacketFromClient(kPacketSize));
  ASSERT_EQ(WriteResult(WRITE_STATUS_OK, kPacketSize),
            SendPacketFromClient(kPacketSize));

  // Read the first packet without enabling RECV_TIMESTAMP.
  QuicUdpSocketApi::ReadPacketResult read_result =
      ReadPacketFromServer(BitMask64(QuicUdpPacketInfoBit::RECV_TIMESTAMP));
  ASSERT_TRUE(read_result.ok);
  ASSERT_EQ(kPacketSize, read_result.packet_buffer.buffer_len);
  ASSERT_EQ(0, ComparePacketBuffers(kPacketSize));
  ASSERT_FALSE(
      read_result.packet_info.HasValue(QuicUdpPacketInfoBit::RECV_TIMESTAMP));

  // Enable RECV_TIMESTAMP and read the second packet.
  if (!api_.EnableReceiveTimestamp(fd_server_)) {
    QUIC_LOG(INFO) << "RECV_TIMESTAMP is not supported";
    return;
  }
  read_result =
      ReadPacketFromServer(BitMask64(QuicUdpPacketInfoBit::RECV_TIMESTAMP));
  ASSERT_TRUE(read_result.ok);
  ASSERT_EQ(kPacketSize, read_result.packet_buffer.buffer_len);
  ASSERT_EQ(0, ComparePacketBuffers(kPacketSize));
  ASSERT_TRUE(
      read_result.packet_info.HasValue(QuicUdpPacketInfoBit::RECV_TIMESTAMP));
  QuicWallTime recv_timestamp = read_result.packet_info.receive_timestamp();
  // 1577836800 is the unix seconds for 2020-01-01
  EXPECT_TRUE(
      QuicWallTime::FromUNIXSeconds(1577836800).IsBefore(recv_timestamp));
}

TEST_P(QuicUdpSocketTest, Ttl) {
  const size_t kPacketSize = 512;
  memset(client_packet_buffer_, '$', kPacketSize);
  ASSERT_EQ(WriteResult(WRITE_STATUS_OK, kPacketSize),
            SendPacketFromClientWithTtl(kPacketSize, 13));
  ASSERT_EQ(WriteResult(WRITE_STATUS_OK, kPacketSize),
            SendPacketFromClientWithTtl(kPacketSize, 13));

  // Read the first packet without enabling ttl reporting.
  QuicUdpSocketApi::ReadPacketResult read_result =
      ReadPacketFromServer(BitMask64(QuicUdpPacketInfoBit::TTL));
  ASSERT_TRUE(read_result.ok);
  ASSERT_EQ(kPacketSize, read_result.packet_buffer.buffer_len);
  ASSERT_EQ(0, ComparePacketBuffers(kPacketSize));
  ASSERT_FALSE(read_result.packet_info.HasValue(QuicUdpPacketInfoBit::TTL));

  // Enable ttl reporting and read the second packet.
  if (!((address_family_ == AF_INET)
            ? api_.EnableReceiveTtlForV4(fd_server_)
            : api_.EnableReceiveTtlForV6(fd_server_))) {
    QUIC_LOG(INFO) << "TTL is not supported for address family "
                   << address_family_;
    return;
  }

  read_result = ReadPacketFromServer(BitMask64(QuicUdpPacketInfoBit::TTL));
  ASSERT_TRUE(read_result.ok);
  ASSERT_EQ(kPacketSize, read_result.packet_buffer.buffer_len);
  ASSERT_EQ(0, ComparePacketBuffers(kPacketSize));
  ASSERT_TRUE(read_result.packet_info.HasValue(QuicUdpPacketInfoBit::TTL));
  EXPECT_EQ(13, read_result.packet_info.ttl());
}

TEST_P(QuicUdpSocketTest, ReadMultiplePackets) {
  const QuicUdpPacketInfoBit self_ip_bit =
      (address_family_ == AF_INET) ? QuicUdpPacketInfoBit::V4_SELF_IP
                                   : QuicUdpPacketInfoBit::V6_SELF_IP;
  const size_t kPacketSize = kDefaultMaxPacketSize;
  const size_t kNumPackets = 90;
  for (size_t i = 0; i < kNumPackets; ++i) {
    memset(client_packet_buffer_, ' ' + i, kPacketSize);
    ASSERT_EQ(WriteResult(WRITE_STATUS_OK, kPacketSize),
              SendPacketFromClient(kPacketSize));
  }

  const size_t kNumPacketsPerRead = 16;
  size_t total_packets_read = 0;
  while (total_packets_read < kNumPackets) {
    std::unique_ptr<ReadBuffers[]> read_buffers =
        std::make_unique<ReadBuffers[]>(kNumPacketsPerRead);
    QuicUdpSocketApi::ReadPacketResults results(kNumPacketsPerRead);
    for (size_t i = 0; i < kNumPacketsPerRead; ++i) {
      results[i].packet_buffer.buffer = read_buffers[i].packet_buffer;
      results[i].packet_buffer.buffer_len =
          sizeof(read_buffers[i].packet_buffer);

      results[i].control_buffer.buffer = read_buffers[i].control_buffer;
      results[i].control_buffer.buffer_len =
          sizeof(read_buffers[i].control_buffer);
    }
    size_t packets_read =
        api_.ReadMultiplePackets(fd_server_, BitMask64(self_ip_bit), &results);
    if (packets_read == 0) {
      ASSERT_TRUE(
          api_.WaitUntilReadable(fd_server_, QuicTime::Delta::FromSeconds(5)));
      packets_read = api_.ReadMultiplePackets(fd_server_,
                                              BitMask64(self_ip_bit), &results);
      ASSERT_GT(packets_read, 0u);
    }

    for (size_t i = 0; i < packets_read; ++i) {
      const auto& result = results[i];
      ASSERT_TRUE(result.ok);
      ASSERT_EQ(kPacketSize, result.packet_buffer.buffer_len);
      ASSERT_TRUE(VerifyBufferIsFilledWith(result.packet_buffer.buffer,
                                           result.packet_buffer.buffer_len,
                                           ' ' + total_packets_read));
      ASSERT_TRUE(result.packet_info.HasValue(self_ip_bit));
      EXPECT_EQ(Loopback(), (address_family_ == AF_INET)
                                ? result.packet_info.self_v4_ip()
                                : result.packet_info.self_v6_ip());
      total_packets_read++;
    }
  }
}

TEST_P(QuicUdpSocketTest, ReadMultiplePacketsSomeTruncated) {
  const QuicUdpPacketInfoBit self_ip_bit =
      (address_family_ == AF_INET) ? QuicUdpPacketInfoBit::V4_SELF_IP
                                   : QuicUdpPacketInfoBit::V6_SELF_IP;
  const size_t kPacketSize = kDefaultMaxPacketSize;
  const size_t kNumPackets = 90;
  for (size_t i = 0; i < kNumPackets; ++i) {
    memset(client_packet_buffer_, ' ' + i, kPacketSize);
    ASSERT_EQ(WriteResult(WRITE_STATUS_OK, kPacketSize),
              SendPacketFromClient(kPacketSize));
  }

  const size_t kNumPacketsPerRead = 16;
  size_t total_packets_read = 0;  // Including truncated packets.
  while (total_packets_read < kNumPackets) {
    std::unique_ptr<ReadBuffers[]> read_buffers =
        std::make_unique<ReadBuffers[]>(kNumPacketsPerRead);
    QuicUdpSocketApi::ReadPacketResults results(kNumPacketsPerRead);
    // Use small packet buffer for all even-numbered packets and expect them to
    // be truncated.
    auto is_truncated = [total_packets_read](size_t i) {
      return ((total_packets_read + i) % 2) == 1;
    };

    for (size_t i = 0; i < kNumPacketsPerRead; ++i) {
      results[i].packet_buffer.buffer = read_buffers[i].packet_buffer;
      results[i].packet_buffer.buffer_len =
          is_truncated(i) ? kPacketSize - 1
                          : sizeof(read_buffers[i].packet_buffer);

      results[i].control_buffer.buffer = read_buffers[i].control_buffer;
      results[i].control_buffer.buffer_len =
          sizeof(read_buffers[i].control_buffer);
    }
    size_t packets_read =
        api_.ReadMultiplePackets(fd_server_, BitMask64(self_ip_bit), &results);
    if (packets_read == 0) {
      ASSERT_TRUE(
          api_.WaitUntilReadable(fd_server_, QuicTime::Delta::FromSeconds(5)));
      packets_read = api_.ReadMultiplePackets(fd_server_,
                                              BitMask64(self_ip_bit), &results);
      ASSERT_GT(packets_read, 0u);
    }

    for (size_t i = 0; i < packets_read; ++i) {
      const auto& result = results[i];
      if (is_truncated(i)) {
        ASSERT_FALSE(result.ok);
      } else {
        ASSERT_TRUE(result.ok);
        ASSERT_EQ(kPacketSize, result.packet_buffer.buffer_len);
        ASSERT_TRUE(VerifyBufferIsFilledWith(result.packet_buffer.buffer,
                                             result.packet_buffer.buffer_len,
                                             ' ' + total_packets_read));
        ASSERT_TRUE(result.packet_info.HasValue(self_ip_bit));
        EXPECT_EQ(Loopback(), (address_family_ == AF_INET)
                                  ? result.packet_info.self_v4_ip()
                                  : result.packet_info.self_v6_ip());
      }
      total_packets_read++;
    }
  }
}

}  // namespace test
}  // namespace quic