third_party_vpn_driver_unittest.cc revision a63da1dc556b1ec9a5b3676a75665ad1a5fda0bc 
1// Copyright 2014 The Chromium OS Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "shill/vpn/third_party_vpn_driver.h"
6
7#include <gtest/gtest.h>
8
9#include "shill/mock_adaptors.h"
10#include "shill/mock_device_info.h"
11#include "shill/mock_event_dispatcher.h"
12#include "shill/mock_file_io.h"
13#include "shill/mock_glib.h"
14#include "shill/mock_manager.h"
15#include "shill/mock_metrics.h"
16#include "shill/mock_service.h"
17#include "shill/mock_store.h"
18#include "shill/mock_virtual_device.h"
19#include "shill/nice_mock_control.h"
20#include "shill/vpn/mock_vpn_service.h"
21
22using testing::_;
23using testing::Mock;
24using testing::NiceMock;
25using testing::Return;
26using testing::SetArgumentPointee;
27
28namespace shill {
29
30class ThirdPartyVpnDriverTest : public testing::Test {
31 public:
32  ThirdPartyVpnDriverTest()
33      : device_info_(&control_, &dispatcher_, &metrics_, &manager_),
34        metrics_(&dispatcher_),
35        manager_(&control_, &dispatcher_, &metrics_, &glib_),
36        driver_(new ThirdPartyVpnDriver(&control_, &dispatcher_, &metrics_,
37                                        &manager_, &device_info_)),
38        adaptor_interface_(new ThirdPartyVpnMockAdaptor()),
39        service_(new MockVPNService(&control_, &dispatcher_, &metrics_,
40                                    &manager_, driver_)),
41        device_(new MockVirtualDevice(&control_, &dispatcher_, &metrics_,
42                                      &manager_, kInterfaceName,
43                                      kInterfaceIndex, Technology::kVPN)) {}
44
45  virtual ~ThirdPartyVpnDriverTest() {}
46
47  virtual void SetUp() {
48    driver_->adaptor_interface_.reset(adaptor_interface_);
49    driver_->file_io_ = &mock_file_io_;
50  }
51
52  virtual void TearDown() {
53    driver_->device_ = nullptr;
54    driver_->service_ = nullptr;
55    driver_->file_io_ = nullptr;
56  }
57
58 protected:
59  static const char kConfigName[];
60  static const char kInterfaceName[];
61  static const int kInterfaceIndex;
62
63  NiceMockControl control_;
64  NiceMock<MockDeviceInfo> device_info_;
65  MockEventDispatcher dispatcher_;
66  MockMetrics metrics_;
67  MockFileIO mock_file_io_;
68  MockGLib glib_;
69  MockManager manager_;
70  ThirdPartyVpnDriver* driver_;                  // Owned by |service_|
71  ThirdPartyVpnMockAdaptor* adaptor_interface_;  // Owned by |driver_|
72  scoped_refptr<MockVPNService> service_;
73  scoped_refptr<MockVirtualDevice> device_;
74};
75
76const char ThirdPartyVpnDriverTest::kConfigName[] = "default-1";
77const char ThirdPartyVpnDriverTest::kInterfaceName[] = "tun0";
78const int ThirdPartyVpnDriverTest::kInterfaceIndex = 123;
79
80TEST_F(ThirdPartyVpnDriverTest, ConnectAndDisconnect) {
81  const std::string interface = kInterfaceName;
82  IOHandler* io_handler = new IOHandler();  // Owned by |driver_|
83  int fd = 1;
84
85  EXPECT_CALL(*service_, SetState(Service::kStateConfiguring)).Times(1);
86  EXPECT_CALL(device_info_, CreateTunnelInterface(_))
87      .WillOnce(DoAll(SetArgumentPointee<0>(interface), Return(true)));
88  Error error;
89  driver_->Connect(service_, &error);
90  EXPECT_TRUE(error.IsSuccess());
91  EXPECT_EQ(kInterfaceName, driver_->tunnel_interface_);
92  EXPECT_TRUE(driver_->IsConnectTimeoutStarted());
93
94  EXPECT_CALL(device_info_, OpenTunnelInterface(interface))
95      .WillOnce(Return(fd));
96  EXPECT_CALL(dispatcher_, CreateInputHandler(fd, _, _))
97      .WillOnce(Return(io_handler));
98  EXPECT_CALL(*adaptor_interface_, EmitPlatformMessage(static_cast<uint32_t>(
99                                       ThirdPartyVpnDriver::kConnected)));
100  EXPECT_FALSE(driver_->ClaimInterface("eth1", kInterfaceIndex));
101  EXPECT_TRUE(driver_->ClaimInterface(interface, kInterfaceIndex));
102  EXPECT_EQ(driver_->active_client_, driver_);
103  EXPECT_TRUE(driver_->parameters_expected_);
104  EXPECT_EQ(driver_->io_handler_.get(), io_handler);
105  ASSERT_TRUE(driver_->device_);
106  EXPECT_EQ(kInterfaceIndex, driver_->device_->interface_index());
107
108  EXPECT_CALL(*service_, SetState(Service::kStateIdle)).Times(1);
109  EXPECT_CALL(*adaptor_interface_, EmitPlatformMessage(static_cast<uint32_t>(
110                                       ThirdPartyVpnDriver::kDisconnected)));
111  EXPECT_CALL(mock_file_io_, Close(fd));
112  driver_->Disconnect();
113  EXPECT_EQ(driver_->io_handler_.get(), nullptr);
114}
115
116TEST_F(ThirdPartyVpnDriverTest, SendPacket) {
117  int fd = 1;
118  std::string error;
119  std::vector<uint8_t> ip_packet(5, 0);
120  driver_->SendPacket(ip_packet, &error);
121  EXPECT_EQ(error, "Unexpected call");
122
123  error.clear();
124  ThirdPartyVpnDriver::active_client_ = driver_;
125  driver_->SendPacket(ip_packet, &error);
126  EXPECT_EQ(error, "Device not open");
127
128  driver_->tun_fd_ = fd;
129  error.clear();
130  EXPECT_CALL(mock_file_io_, Write(fd, ip_packet.data(), ip_packet.size()))
131      .WillOnce(Return(ip_packet.size() - 1));
132  EXPECT_CALL(
133      *adaptor_interface_,
134      EmitPlatformMessage(static_cast<uint32_t>(ThirdPartyVpnDriver::kError)));
135  driver_->SendPacket(ip_packet, &error);
136  EXPECT_EQ(error, "Partial write");
137
138  error.clear();
139  EXPECT_CALL(mock_file_io_, Write(fd, ip_packet.data(), ip_packet.size()))
140      .WillOnce(Return(ip_packet.size()));
141  driver_->SendPacket(ip_packet, &error);
142  EXPECT_TRUE(error.empty());
143
144  driver_->tun_fd_ = -1;
145
146  EXPECT_CALL(*adaptor_interface_, EmitPlatformMessage(static_cast<uint32_t>(
147                                       ThirdPartyVpnDriver::kDisconnected)));
148}
149
150TEST_F(ThirdPartyVpnDriverTest, UpdateConnectionState) {
151  std::string error;
152  driver_->UpdateConnectionState(Service::kStateConfiguring, &error);
153  EXPECT_EQ(error, "Unexpected call");
154
155  error.clear();
156  ThirdPartyVpnDriver::active_client_ = driver_;
157  driver_->UpdateConnectionState(Service::kStateConfiguring, &error);
158  EXPECT_EQ(error, "Invalid argument");
159
160  error.clear();
161  driver_->service_ = service_;
162  EXPECT_CALL(*service_, SetState(_)).Times(0);
163  driver_->UpdateConnectionState(Service::kStateOnline, &error);
164  EXPECT_TRUE(error.empty());
165  Mock::VerifyAndClearExpectations(service_.get());
166
167  EXPECT_CALL(*service_, SetState(Service::kStateFailure)).Times(1);
168  EXPECT_CALL(*adaptor_interface_, EmitPlatformMessage(static_cast<uint32_t>(
169                                       ThirdPartyVpnDriver::kDisconnected)))
170      .Times(1);
171  driver_->UpdateConnectionState(Service::kStateFailure, &error);
172  EXPECT_TRUE(error.empty());
173  Mock::VerifyAndClearExpectations(service_.get());
174  Mock::VerifyAndClearExpectations(adaptor_interface_);
175}
176
177TEST_F(ThirdPartyVpnDriverTest, SetParameters) {
178  std::map<std::string, std::string> parameters;
179  std::string error;
180  std::string warning;
181  driver_->SetParameters(parameters, &error, &warning);
182  EXPECT_EQ(error, "Unexpected call");
183
184  error.clear();
185  ThirdPartyVpnDriver::active_client_ = driver_;
186  driver_->parameters_expected_ = true;
187  driver_->SetParameters(parameters, &error, &warning);
188  EXPECT_EQ(error,
189            "address is missing;subnet_prefix is missing;"
190            "dns_servers is missing;"
191            "exclusion_list is missing;inclusion_list is missing;");
192  EXPECT_TRUE(warning.empty());
193
194  error.clear();
195  parameters["address"] = "1234.1.1.1";
196  driver_->SetParameters(parameters, &error, &warning);
197  EXPECT_EQ(error,
198            "address is not a valid IP;subnet_prefix is missing;"
199            "dns_servers is missing;"
200            "exclusion_list is missing;inclusion_list is missing;");
201  EXPECT_TRUE(warning.empty());
202
203  error.clear();
204  parameters["address"] = "123.211.21.18";
205  driver_->SetParameters(parameters, &error, &warning);
206  EXPECT_EQ(error,
207            "subnet_prefix is missing;dns_servers is missing;"
208            "exclusion_list is missing;inclusion_list is missing;");
209  EXPECT_TRUE(warning.empty());
210
211  error.clear();
212  parameters["subnet_prefix"] = "123";
213  driver_->SetParameters(parameters, &error, &warning);
214  EXPECT_EQ(error,
215            "subnet_prefix not in expected range;dns_servers is missing;"
216            "exclusion_list is missing;inclusion_list is missing;");
217  EXPECT_TRUE(warning.empty());
218
219  error.clear();
220  parameters["subnet_prefix"] = "12";
221  driver_->SetParameters(parameters, &error, &warning);
222  EXPECT_EQ(error, "dns_servers is missing;"
223                   "exclusion_list is missing;inclusion_list is missing;");
224  EXPECT_TRUE(warning.empty());
225
226  error.clear();
227  parameters["dns_servers"] = "12 123123 43902374";
228  driver_->SetParameters(parameters, &error, &warning);
229  EXPECT_EQ(error, "dns_servers has no valid values or is empty;"
230                   "exclusion_list is missing;inclusion_list is missing;");
231  EXPECT_EQ(warning, "12 for dns_servers is invalid;"
232                     "123123 for dns_servers is invalid;"
233                     "43902374 for dns_servers is invalid;");
234
235  driver_->device_ =
236      new MockVirtualDevice(&control_, &dispatcher_, &metrics_, &manager_,
237                            kInterfaceName, kInterfaceIndex, Technology::kVPN);
238  error.clear();
239  warning.clear();
240  parameters["exclusion_list"] =
241      "400.400.400.400/12 1.1.1.1/44 1.1.1.1/-1 "
242      "123.211.21.0/23 123.211.21.1/23 123.211.21.0/25 "
243      "1.1.1.1.1/12 1.1.1/13";
244  parameters["dns_servers"] = "";
245  driver_->SetParameters(parameters, &error, &warning);
246  EXPECT_EQ(error, "dns_servers has no valid values or is empty;"
247                   "inclusion_list is missing;");
248  EXPECT_EQ(warning,
249            "400.400.400.400/12 for exclusion_list is invalid;"
250            "1.1.1.1/44 for exclusion_list is invalid;"
251            "1.1.1.1/-1 for exclusion_list is invalid;"
252            "Duplicate entry for 123.211.21.1/23 in exclusion_list found;"
253            "1.1.1.1.1/12 for exclusion_list is invalid;"
254            "1.1.1/13 for exclusion_list is invalid;");
255
256  error.clear();
257  warning.clear();
258  parameters["exclusion_list"] = "0.0.0.0/0 123.211.21.29/31 123.211.21.1/24";
259  parameters["inclusion_list"] =
260      "400.400.400.400/12 1.1.1.1/44 1.1.1.1/-1 "
261      "123.211.22.0/24 123.211.22.1/24 "
262      "1.1.1.1.1/12 1.1.1/13 123.211.21.0/24";
263  driver_->SetParameters(parameters, &error, &warning);
264  EXPECT_EQ(error, "dns_servers has no valid values or is empty;");
265  EXPECT_EQ(warning,
266            "400.400.400.400/12 for inclusion_list is invalid;"
267            "1.1.1.1/44 for inclusion_list is invalid;"
268            "1.1.1.1/-1 for inclusion_list is invalid;"
269            "Duplicate entry for 123.211.22.1/24 in inclusion_list found;"
270            "1.1.1.1.1/12 for inclusion_list is invalid;"
271            "1.1.1/13 for inclusion_list is invalid;"
272            "Duplicate entry for 123.211.21.0/24 in inclusion_list found;");
273
274  error.clear();
275  warning.clear();
276  parameters["dns_servers"] = "123.211.21.18 123.211.21.19";
277  parameters["inclusion_list"] = "123.211.61.29/7 123.211.42.29/17";
278  driver_->SetParameters(parameters, &error, &warning);
279  EXPECT_EQ(driver_->ip_properties_.exclusion_list.size(), 3);
280  EXPECT_EQ(driver_->ip_properties_.exclusion_list[0], "123.211.21.29/31");
281  EXPECT_EQ(driver_->ip_properties_.exclusion_list[1], "0.0.0.0/0");
282  EXPECT_EQ(driver_->ip_properties_.exclusion_list[2], "123.211.21.1/24");
283  EXPECT_EQ(driver_->ip_properties_.routes.size(), 2);
284  EXPECT_EQ(driver_->ip_properties_.routes[0].host, "123.211.61.29");
285  EXPECT_EQ(driver_->ip_properties_.routes[1].host, "123.211.42.29");
286  EXPECT_EQ(driver_->ip_properties_.routes[0].netmask, "254.0.0.0");
287  EXPECT_EQ(driver_->ip_properties_.routes[1].netmask, "255.255.128.0");
288  EXPECT_EQ(driver_->ip_properties_.routes[0].gateway, parameters["address"]);
289  EXPECT_EQ(driver_->ip_properties_.routes[1].gateway, parameters["address"]);
290  EXPECT_TRUE(error.empty());
291  EXPECT_TRUE(warning.empty());
292  EXPECT_FALSE(driver_->parameters_expected_);
293  driver_->device_ = nullptr;
294}
295
296}  // namespace shill
297