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 33 using testing::_; 34 using testing::Mock; 35 using testing::NiceMock; 36 using testing::Return; 37 using testing::SetArgumentPointee; 38 39 namespace shill { 40 41 class 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 86 const char ThirdPartyVpnDriverTest::kConfigName[] = "default-1"; 87 const char ThirdPartyVpnDriverTest::kInterfaceName[] = "tun0"; 88 const int ThirdPartyVpnDriverTest::kInterfaceIndex = 123; 89 90 TEST_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 126 TEST_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 160 TEST_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 187 TEST_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