blob: 0cac13f5cb5f51b558535bc8d9b49b3a766cb628 [file] [log] [blame]
// 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(IsNeighborDumpMessage, "") {
if (!(arg->type() == shill::RTNLMessage::kTypeNeighbor &&
arg->flags() == NLM_F_REQUEST | NLM_F_DUMP &&
arg->mode() == shill::RTNLMessage::kModeGet &&
arg->interface_index() == kTestInterfaceIndex))
return false;
return true;
}
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) {
shill::IPAddress addr(address);
auto* rtnl_response =
new shill::RTNLMessage(shill::RTNLMessage::kTypeNeighbor, mode, 0, 0, 0,
kTestInterfaceIndex, addr.family());
rtnl_response->SetAttribute(NDA_DST, addr.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, SendNeighborDumpMessageOnIPConfigChanged) {
ShillClient::IPConfig ipconfig;
ipconfig.ipv4_address = "1.2.3.4";
ipconfig.ipv4_gateway = "1.2.3.5";
ipconfig.ipv4_prefix_length = 24;
ipconfig.ipv4_dns_addresses = {"1.2.3.6"};
// On ipconfig changed, the link monitor should send only one dump request, to
// fetch current NUD state of these new addresses.
EXPECT_CALL(*mock_rtnl_handler_, DoSendMessage(IsNeighborDumpMessage(), _))
.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"};
link_monitor_->OnIPConfigChanged(ipconfig);
std::unique_ptr<shill::RTNLMessage> gateway_is_reachable(
CreateNUDStateChangedMessage("fe80::1", NUD_REACHABLE));
std::unique_ptr<shill::RTNLMessage> dns_is_reachable(
CreateNUDStateChangedMessage("fe80::2", NUD_REACHABLE));
EXPECT_CALL(*mock_rtnl_handler_,
DoSendMessage(IsNeighborProbeMessage("fe80::1"), _))
.WillOnce(Return(true));
EXPECT_CALL(*mock_rtnl_handler_,
DoSendMessage(IsNeighborProbeMessage("fe80::2"), _))
.WillOnce(Return(true));
link_monitor_->OnNeighborMessage(*gateway_is_reachable);
link_monitor_->OnNeighborMessage(*dns_is_reachable);
}
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 dump 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(IsNeighborDumpMessage(), _))
.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"};
// One dump request is expected since there is a new address.
EXPECT_CALL(*mock_rtnl_handler_, DoSendMessage(IsNeighborDumpMessage(), _))
.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);
// This address is not been watching now. Nothing should happen when a message
// about it comes.
std::unique_ptr<shill::RTNLMessage> addr_6_is_reachable(
CreateNUDStateChangedMessage("1.2.3.6", NUD_REACHABLE));
link_monitor_->OnNeighborMessage(*addr_6_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();
}
TEST_F(NeighborLinkMonitorTest, UpdateWatchingEntriesWithSameAddress) {
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);
// No dump request is expected.
EXPECT_CALL(*mock_rtnl_handler_, DoSendMessage(IsNeighborDumpMessage(), _))
.Times(0);
link_monitor_->OnIPConfigChanged(ipconfig);
}
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