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