// Copyright 2020 The Chromium OS 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 "patchpanel/network_monitor_service.h"

#include <memory>
#include <linux/rtnetlink.h>

#include <base/test/task_environment.h>
#include <chromeos/dbus/service_constants.h>
#include <gtest/gtest.h>

#include "patchpanel/fake_shill_client.h"
#include "shill/net/mock_rtnl_handler.h"

namespace patchpanel {

namespace {
constexpr int kTestInterfaceIndex = 1;
constexpr char kTestInterfaceName[] = "wlan0";

MATCHER_P(IsNeighborGetMessage, address, "") {
  if (!(arg->type() == shill::RTNLMessage::kTypeNeighbor &&
        arg->flags() == NLM_F_REQUEST &&
        arg->mode() == shill::RTNLMessage::kModeGet &&
        arg->interface_index() == kTestInterfaceIndex &&
        arg->HasAttribute(NDA_DST)))
    return false;

  shill::IPAddress msg_address(arg->family(), arg->GetAttribute(NDA_DST));
  return msg_address == shill::IPAddress(address);
}

MATCHER_P(IsNeighborProbeMessage, address, "") {
  if (!(arg->type() == shill::RTNLMessage::kTypeNeighbor &&
        arg->flags() == NLM_F_REQUEST | NLM_F_REPLACE &&
        arg->mode() == shill::RTNLMessage::kModeAdd &&
        arg->neighbor_status().state == NUD_PROBE &&
        arg->interface_index() == kTestInterfaceIndex &&
        arg->HasAttribute(NDA_DST)))
    return false;

  shill::IPAddress msg_address(arg->family(), arg->GetAttribute(NDA_DST));
  return msg_address == shill::IPAddress(address);
}

shill::RTNLMessage* CreateIncomingRTNLMessage(
    const shill::RTNLMessage::Mode mode,
    const std::string& address,
    uint16_t nud_state) {
  auto* rtnl_response = new shill::RTNLMessage(
      shill::RTNLMessage::kTypeNeighbor, mode, 0, 0, 0, kTestInterfaceIndex,
      shill::IPAddress::kFamilyIPv4);

  rtnl_response->SetAttribute(NDA_DST, shill::IPAddress(address).address());
  if (mode == shill::RTNLMessage::kModeAdd) {
    rtnl_response->set_neighbor_status(
        shill::RTNLMessage::NeighborStatus(nud_state, 0, 0));
    rtnl_response->SetAttribute(
        NDA_LLADDR, shill::ByteString(std::vector<uint8_t>{1, 2, 3, 4, 5, 6}));
  }

  return rtnl_response;
}

shill::RTNLMessage* CreateNUDStateChangedMessage(const std::string& address,
                                                 uint16_t nud_state) {
  return CreateIncomingRTNLMessage(shill::RTNLMessage::kModeAdd, address,
                                   nud_state);
}

shill::RTNLMessage* CreateNeighborDeletedMessage(const std::string& address) {
  return CreateIncomingRTNLMessage(shill::RTNLMessage::kModeDelete, address, 0);
}

}  // namespace

class NeighborLinkMonitorTest : public testing::Test {
 protected:
  void SetUp() override {
    mock_rtnl_handler_ = std::make_unique<shill::MockRTNLHandler>();
    link_monitor_ = std::make_unique<NeighborLinkMonitor>(
        kTestInterfaceIndex, kTestInterfaceName, mock_rtnl_handler_.get());
  }

  void TearDown() override {
    // We should make sure |mock_rtnl_handler_| is valid during the life time of
    // |link_monitor_|.
    link_monitor_ = nullptr;
    mock_rtnl_handler_ = nullptr;
  }

  void FastForwardOneActiveProbeInterval() {
    task_environment_.FastForwardBy(NeighborLinkMonitor::kActiveProbeInterval);
  }

  base::test::TaskEnvironment task_environment_{
      base::test::TaskEnvironment::TimeSource::MOCK_TIME};
  std::unique_ptr<shill::MockRTNLHandler> mock_rtnl_handler_;
  std::unique_ptr<NeighborLinkMonitor> link_monitor_;
};

TEST_F(NeighborLinkMonitorTest, SendNeighborGetMessageOnIPConfigChanged) {
  ShillClient::IPConfig ipconfig;
  ipconfig.ipv4_address = "1.2.3.4";
  ipconfig.ipv4_gateway = "1.2.3.5";
  ipconfig.ipv4_prefix_length = 24;
  // The second dns address is not in this subnet, and should be ignored by the
  // link monitor.
  ipconfig.ipv4_dns_addresses = {"1.2.3.6", "4.3.2.1"};

  // On ipconfig changed, the link monitor should send a get request for each
  // watching address, to fetch their current NUD state.
  EXPECT_CALL(*mock_rtnl_handler_,
              DoSendMessage(IsNeighborGetMessage("1.2.3.5"), _))
      .WillOnce(Return(true));
  EXPECT_CALL(*mock_rtnl_handler_,
              DoSendMessage(IsNeighborGetMessage("1.2.3.6"), _))
      .WillOnce(Return(true));

  link_monitor_->OnIPConfigChanged(ipconfig);
}

TEST_F(NeighborLinkMonitorTest, WatchLinkLocalIPv6DNSServerAddress) {
  ShillClient::IPConfig ipconfig;
  ipconfig.ipv6_address = "2401::1";
  ipconfig.ipv6_prefix_length = 64;
  ipconfig.ipv6_gateway = "fe80::1";
  ipconfig.ipv6_dns_addresses = {"fe80::2"};

  EXPECT_CALL(*mock_rtnl_handler_,
              DoSendMessage(IsNeighborGetMessage("fe80::1"), _))
      .WillOnce(Return(true));
  EXPECT_CALL(*mock_rtnl_handler_,
              DoSendMessage(IsNeighborGetMessage("fe80::2"), _))
      .WillOnce(Return(true));

  link_monitor_->OnIPConfigChanged(ipconfig);
}

TEST_F(NeighborLinkMonitorTest, SendNeighborProbeMessage) {
  // Only the gateway should be in the wathing list.
  ShillClient::IPConfig ipconfig;
  ipconfig.ipv4_address = "1.2.3.4";
  ipconfig.ipv4_gateway = "1.2.3.5";
  ipconfig.ipv4_prefix_length = 24;
  link_monitor_->OnIPConfigChanged(ipconfig);

  // Creates a RTNL message about the NUD state of the gateway is NUD_REACHABLE
  // now. A probe message should be sent immediately after we know this address.
  std::unique_ptr<shill::RTNLMessage> address_is_reachable(
      CreateNUDStateChangedMessage("1.2.3.5", NUD_REACHABLE));
  EXPECT_CALL(*mock_rtnl_handler_,
              DoSendMessage(IsNeighborProbeMessage("1.2.3.5"), _))
      .WillOnce(Return(true));
  link_monitor_->OnNeighborMessage(*address_is_reachable);

  // Another probe message should be sent when the timer is triggered.
  EXPECT_CALL(*mock_rtnl_handler_,
              DoSendMessage(IsNeighborProbeMessage("1.2.3.5"), _))
      .WillOnce(Return(true));
  FastForwardOneActiveProbeInterval();

  // If the state changed to NUD_PROBE, we should not probe this address again
  // when the timer is triggered.
  std::unique_ptr<shill::RTNLMessage> address_is_probing(
      CreateNUDStateChangedMessage("1.2.3.5", NUD_PROBE));
  link_monitor_->OnNeighborMessage(*address_is_probing);
  FastForwardOneActiveProbeInterval();

  // The gateway is removed in the kernel. A get request should be sent when the
  // timer is triggered.
  std::unique_ptr<shill::RTNLMessage> address_is_removed(
      CreateNeighborDeletedMessage("1.2.3.5"));
  link_monitor_->OnNeighborMessage(*address_is_removed);
  EXPECT_CALL(*mock_rtnl_handler_,
              DoSendMessage(IsNeighborGetMessage("1.2.3.5"), _))
      .WillOnce(Return(true));
  FastForwardOneActiveProbeInterval();
}

TEST_F(NeighborLinkMonitorTest, UpdateWatchingEntries) {
  ShillClient::IPConfig ipconfig;
  ipconfig.ipv4_address = "1.2.3.4";
  ipconfig.ipv4_gateway = "1.2.3.5";
  ipconfig.ipv4_dns_addresses = {"1.2.3.6"};
  ipconfig.ipv4_prefix_length = 24;
  link_monitor_->OnIPConfigChanged(ipconfig);

  ipconfig.ipv4_dns_addresses = {"1.2.3.7"};
  // The watching list should be updated to {"1.2.3.5", "1.2.3.7"}, and only
  // "1.2.3.7" is an new entry, so it should be probed immediately.
  EXPECT_CALL(*mock_rtnl_handler_,
              DoSendMessage(IsNeighborGetMessage("1.2.3.7"), _))
      .WillOnce(Return(true));
  link_monitor_->OnIPConfigChanged(ipconfig);

  // Updates both addresses to NUD_PROBE (to avoid the link monitor sending a
  // probe request), and then NUD_REACHABLE state.
  std::unique_ptr<shill::RTNLMessage> addr_5_is_probing(
      CreateNUDStateChangedMessage("1.2.3.5", NUD_PROBE));
  std::unique_ptr<shill::RTNLMessage> addr_5_is_reachable(
      CreateNUDStateChangedMessage("1.2.3.5", NUD_REACHABLE));
  std::unique_ptr<shill::RTNLMessage> addr_7_is_probing(
      CreateNUDStateChangedMessage("1.2.3.7", NUD_PROBE));
  std::unique_ptr<shill::RTNLMessage> addr_7_is_reachable(
      CreateNUDStateChangedMessage("1.2.3.7", NUD_REACHABLE));
  link_monitor_->OnNeighborMessage(*addr_5_is_probing);
  link_monitor_->OnNeighborMessage(*addr_5_is_reachable);
  link_monitor_->OnNeighborMessage(*addr_7_is_probing);
  link_monitor_->OnNeighborMessage(*addr_7_is_reachable);

  // Nothing should happen within one interval.
  task_environment_.FastForwardBy(base::TimeDelta::FromSeconds(30));

  // Checks if probe requests sent for both addresses when the timer is
  // triggered.
  EXPECT_CALL(*mock_rtnl_handler_,
              DoSendMessage(IsNeighborProbeMessage("1.2.3.5"), _))
      .WillOnce(Return(true));
  EXPECT_CALL(*mock_rtnl_handler_,
              DoSendMessage(IsNeighborProbeMessage("1.2.3.7"), _))
      .WillOnce(Return(true));
  FastForwardOneActiveProbeInterval();
}

class NetworkMonitorServiceTest : public testing::Test {
 protected:
  void SetUp() override {
    fake_shill_client_ = shill_helper_.FakeClient();
    monitor_svc_ =
        std::make_unique<NetworkMonitorService>(fake_shill_client_.get());
    mock_rtnl_handler_ = std::make_unique<shill::MockRTNLHandler>();
  }

  FakeShillClientHelper shill_helper_;
  std::unique_ptr<FakeShillClient> fake_shill_client_;
  std::unique_ptr<shill::MockRTNLHandler> mock_rtnl_handler_;
  std::unique_ptr<NetworkMonitorService> monitor_svc_;
};

TEST_F(NetworkMonitorServiceTest, StartRTNLHanlderOnServiceStart) {
  monitor_svc_->rtnl_handler_ = mock_rtnl_handler_.get();
  EXPECT_CALL(*mock_rtnl_handler_, Start(RTMGRP_NEIGH));
  monitor_svc_->Start();
}

TEST_F(NetworkMonitorServiceTest, CallGetDevicePropertiesOnNewDevice) {
  monitor_svc_->rtnl_handler_ = mock_rtnl_handler_.get();
  // Device added before service starts.
  std::vector<dbus::ObjectPath> devices = {dbus::ObjectPath("/device/eth0")};
  fake_shill_client_->NotifyManagerPropertyChange(shill::kDevicesProperty,
                                                  brillo::Any(devices));
  monitor_svc_->Start();

  // Device added after service starts.
  devices.emplace_back(dbus::ObjectPath("/device/wlan0"));
  fake_shill_client_->NotifyManagerPropertyChange(shill::kDevicesProperty,
                                                  brillo::Any(devices));
  const std::set<std::string>& calls =
      fake_shill_client_->get_device_properties_calls();
  EXPECT_EQ(calls.size(), 2);
  EXPECT_NE(calls.find("eth0"), calls.end());
  EXPECT_NE(calls.find("wlan0"), calls.end());
}

}  // namespace patchpanel