1// 2// Copyright (C) 2012 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/connection.h" 18 19#include <arpa/inet.h> 20#include <linux/rtnetlink.h> 21 22#include <memory> 23#include <string> 24#include <vector> 25 26#include <gtest/gtest.h> 27#include <gmock/gmock.h> 28 29#include "shill/ipconfig.h" 30#include "shill/mock_connection.h" 31#include "shill/mock_control.h" 32#include "shill/mock_device.h" 33#include "shill/mock_device_info.h" 34#include "shill/mock_firewall_proxy.h" 35#if !defined(__ANDROID__) 36#include "shill/mock_resolver.h" 37#else 38#include "shill/mock_dns_server_proxy.h" 39#include "shill/mock_dns_server_proxy_factory.h" 40#endif // __ANDROID__ 41#include "shill/mock_routing_table.h" 42#include "shill/net/mock_rtnl_handler.h" 43#include "shill/routing_table_entry.h" 44 45using std::string; 46using std::vector; 47using testing::_; 48using testing::Mock; 49using testing::NiceMock; 50using testing::Return; 51using testing::ReturnRef; 52using testing::StrictMock; 53using testing::Test; 54 55namespace shill { 56 57namespace { 58const char kTestDeviceName0[] = "netdev0"; 59const int kTestDeviceInterfaceIndex0 = 123; 60const char kTestDeviceName1[] = "netdev1"; 61const int kTestDeviceInterfaceIndex1 = 321; 62const char kIPAddress0[] = "192.168.1.1"; 63const char kGatewayAddress0[] = "192.168.1.254"; 64const char kBroadcastAddress0[] = "192.168.1.255"; 65const char kNameServer0[] = "8.8.8.8"; 66const char kNameServer1[] = "8.8.9.9"; 67const int32_t kPrefix0 = 24; 68const int32_t kPrefix1 = 31; 69const char kSearchDomain0[] = "chromium.org"; 70const char kSearchDomain1[] = "google.com"; 71const char kIPv6Address[] = "2001:db8::1"; 72const char kIPv6NameServer0[] = "2001:db9::1"; 73const char kIPv6NameServer1[] = "2001:db9::2"; 74} // namespace 75 76class ConnectionTest : public Test { 77 public: 78 ConnectionTest() 79 : device_info_(new StrictMock<MockDeviceInfo>( 80 &control_, 81 nullptr, 82 nullptr, 83 nullptr)), 84 connection_(new Connection( 85 kTestDeviceInterfaceIndex0, 86 kTestDeviceName0, 87 Technology::kUnknown, 88 device_info_.get(), 89 &control_)), 90 ipconfig_(new IPConfig(&control_, kTestDeviceName0)), 91 ip6config_(new IPConfig(&control_, kTestDeviceName0)), 92 local_address_(IPAddress::kFamilyIPv4), 93 broadcast_address_(IPAddress::kFamilyIPv4), 94 gateway_address_(IPAddress::kFamilyIPv4), 95 default_address_(IPAddress::kFamilyIPv4), 96 local_ipv6_address_(IPAddress::kFamilyIPv6) {} 97 98 virtual void SetUp() { 99 ReplaceSingletons(connection_); 100 properties_.address = kIPAddress0; 101 properties_.subnet_prefix = kPrefix0; 102 properties_.gateway = kGatewayAddress0; 103 properties_.broadcast_address = kBroadcastAddress0; 104 properties_.dns_servers.push_back(kNameServer0); 105 properties_.dns_servers.push_back(kNameServer1); 106 properties_.domain_search.push_back(kSearchDomain0); 107 properties_.domain_search.push_back(kSearchDomain1); 108 properties_.address_family = IPAddress::kFamilyIPv4; 109 UpdateProperties(); 110 ipv6_properties_.address = kIPv6Address; 111 ipv6_properties_.dns_servers.push_back(kIPv6NameServer0); 112 ipv6_properties_.dns_servers.push_back(kIPv6NameServer1); 113 ipv6_properties_.address_family = IPAddress::kFamilyIPv6; 114 UpdateIPv6Properties(); 115 EXPECT_TRUE(local_address_.SetAddressFromString(kIPAddress0)); 116 EXPECT_TRUE(broadcast_address_.SetAddressFromString(kBroadcastAddress0)); 117 EXPECT_TRUE(gateway_address_.SetAddressFromString(kGatewayAddress0)); 118 EXPECT_TRUE(local_ipv6_address_.SetAddressFromString(kIPv6Address)); 119 } 120 121 virtual void TearDown() { 122 AddDestructorExpectations(); 123 connection_ = nullptr; 124 } 125 126 void ReplaceSingletons(ConnectionRefPtr connection) { 127#if !defined(__ANDROID__) 128 connection->resolver_ = &resolver_; 129#else 130 connection->dns_server_proxy_factory_ = &dns_server_proxy_factory_; 131#endif // __ANDROID__ 132 connection->routing_table_ = &routing_table_; 133 connection->rtnl_handler_ = &rtnl_handler_; 134 } 135 136 void UpdateProperties() { 137 ipconfig_->UpdateProperties(properties_, true); 138 } 139 140 void UpdateIPv6Properties() { 141 ip6config_->UpdateProperties(ipv6_properties_, true); 142 } 143 144 bool PinHostRoute(ConnectionRefPtr connection, 145 const IPAddress trusted_ip, 146 const IPAddress gateway) { 147 return connection->PinHostRoute(trusted_ip, gateway); 148 } 149 150 const IPAddress& GetLocalAddress(ConnectionRefPtr connection) { 151 return connection->local_; 152 } 153 154 const IPAddress& GetGatewayAddress(ConnectionRefPtr connection) { 155 return connection->gateway_; 156 } 157 158 bool GetHasBroadcastDomain(ConnectionRefPtr connection) { 159 return connection->has_broadcast_domain_; 160 } 161 162 uint32_t GetDefaultMetric() { 163 return Connection::kDefaultMetric; 164 } 165 166 uint32_t GetNonDefaultMetricBase() { 167 return Connection::kNonDefaultMetricBase; 168 } 169 170 void SetLocal(const IPAddress& local) { 171 connection_->local_ = local; 172 } 173 174#if defined(__ANDROID__) 175 // Setting expectations for creating/starting DNS server proxy. 176 void ExpectDNSServerProxyCreation(const vector<string>& dns_servers, 177 bool verify_servers) { 178 MockDNSServerProxy* dns_server_proxy = new MockDNSServerProxy(); 179 if (verify_servers) { 180 EXPECT_CALL(dns_server_proxy_factory_, 181 CreateDNSServerProxy(dns_servers)) 182 .WillOnce(Return(dns_server_proxy)); 183 } else { 184 EXPECT_CALL(dns_server_proxy_factory_, CreateDNSServerProxy(_)) 185 .WillOnce(Return(dns_server_proxy)); 186 } 187 EXPECT_CALL(*dns_server_proxy, Start()); 188 } 189#endif // __ANDROID__ 190 191 protected: 192 class DisconnectCallbackTarget { 193 public: 194 DisconnectCallbackTarget() 195 : callback_(base::Bind(&DisconnectCallbackTarget::CallTarget, 196 base::Unretained(this))) {} 197 198 MOCK_METHOD0(CallTarget, void()); 199 const base::Closure& callback() { return callback_; } 200 201 private: 202 base::Closure callback_; 203 }; 204 205 void AddDestructorExpectations() { 206 EXPECT_CALL(routing_table_, FlushRoutes(kTestDeviceInterfaceIndex0)); 207 EXPECT_CALL(routing_table_, FlushRoutesWithTag(kTestDeviceInterfaceIndex0)); 208 EXPECT_CALL(*device_info_.get(), 209 FlushAddresses(kTestDeviceInterfaceIndex0)); 210 } 211 212 // Returns a new test connection object. The caller usually needs to call 213 // AddDestructorExpectations before destroying the object. 214 ConnectionRefPtr GetNewConnection() { 215 ConnectionRefPtr connection(new Connection(kTestDeviceInterfaceIndex0, 216 kTestDeviceName0, 217 Technology::kUnknown, 218 device_info_.get(), 219 &control_)); 220 ReplaceSingletons(connection); 221 return connection; 222 } 223 224 std::unique_ptr<StrictMock<MockDeviceInfo>> device_info_; 225 ConnectionRefPtr connection_; 226 MockControl control_; 227 IPConfigRefPtr ipconfig_; 228 IPConfigRefPtr ip6config_; 229 IPConfig::Properties properties_; 230 IPConfig::Properties ipv6_properties_; 231 IPAddress local_address_; 232 IPAddress broadcast_address_; 233 IPAddress gateway_address_; 234 IPAddress default_address_; 235 IPAddress local_ipv6_address_; 236#if !defined(__ANDROID__) 237 StrictMock<MockResolver> resolver_; 238#else 239 StrictMock<MockDNSServerProxyFactory> dns_server_proxy_factory_; 240#endif // __ANDROID__ 241 StrictMock<MockRoutingTable> routing_table_; 242 StrictMock<MockRTNLHandler> rtnl_handler_; 243}; 244 245namespace { 246 247MATCHER_P2(IsIPAddress, address, prefix, "") { 248 IPAddress match_address(address); 249 match_address.set_prefix(prefix); 250 return match_address.Equals(arg); 251} 252 253MATCHER_P(IsIPv6Address, address, "") { 254 IPAddress match_address(address); 255 return match_address.Equals(arg); 256} 257 258MATCHER(IsNonNullCallback, "") { 259 return !arg.is_null(); 260} 261 262MATCHER_P(IsValidRoutingTableEntry, dst, "") { 263 return dst.Equals(arg.dst); 264} 265 266MATCHER_P(IsLinkRouteTo, dst, "") { 267 return dst.HasSameAddressAs(arg.dst) && 268 arg.dst.prefix() == 269 IPAddress::GetMaxPrefixLength(IPAddress::kFamilyIPv4) && 270 !arg.src.IsValid() && !arg.gateway.IsValid() && 271 arg.scope == RT_SCOPE_LINK && !arg.from_rtnl; 272} 273 274} // namespace 275 276TEST_F(ConnectionTest, InitState) { 277 EXPECT_EQ(kTestDeviceInterfaceIndex0, connection_->interface_index_); 278 EXPECT_EQ(kTestDeviceName0, connection_->interface_name_); 279 EXPECT_FALSE(connection_->is_default()); 280 EXPECT_FALSE(connection_->routing_request_count_); 281} 282 283TEST_F(ConnectionTest, AddConfig) { 284 EXPECT_CALL(*device_info_, 285 HasOtherAddress(kTestDeviceInterfaceIndex0, 286 IsIPAddress(local_address_, kPrefix0))) 287 .WillOnce(Return(false)); 288 EXPECT_CALL(rtnl_handler_, 289 AddInterfaceAddress(kTestDeviceInterfaceIndex0, 290 IsIPAddress(local_address_, kPrefix0), 291 IsIPAddress(broadcast_address_, 0), 292 IsIPAddress(default_address_, 0))); 293 EXPECT_CALL(routing_table_, 294 SetDefaultRoute(kTestDeviceInterfaceIndex0, 295 IsIPAddress(gateway_address_, 0), 296 GetNonDefaultMetricBase() + 297 kTestDeviceInterfaceIndex0, 298 RT_TABLE_MAIN)); 299 EXPECT_CALL(routing_table_, 300 ConfigureRoutes(kTestDeviceInterfaceIndex0, 301 ipconfig_, 302 GetDefaultMetric(), 303 RT_TABLE_MAIN)); 304 EXPECT_CALL(rtnl_handler_, SetInterfaceMTU(kTestDeviceInterfaceIndex0, 305 IPConfig::kDefaultMTU)); 306 connection_->UpdateFromIPConfig(ipconfig_); 307 IPAddress test_local_address(local_address_); 308 test_local_address.set_prefix(kPrefix0); 309 EXPECT_TRUE(test_local_address.Equals(GetLocalAddress(connection_))); 310 EXPECT_TRUE(gateway_address_.Equals(GetGatewayAddress(connection_))); 311 EXPECT_TRUE(GetHasBroadcastDomain(connection_)); 312 EXPECT_FALSE(connection_->IsIPv6()); 313 314 EXPECT_CALL(routing_table_, 315 CreateLinkRoute(kTestDeviceInterfaceIndex0, 316 IsIPAddress(local_address_, kPrefix0), 317 IsIPAddress(gateway_address_, 0), 318 RT_TABLE_MAIN)) 319 .WillOnce(Return(true)) 320 .WillOnce(Return(false)); 321 EXPECT_TRUE(connection_->CreateGatewayRoute()); 322 EXPECT_FALSE(connection_->CreateGatewayRoute()); 323 connection_->has_broadcast_domain_ = false; 324 EXPECT_FALSE(connection_->CreateGatewayRoute()); 325 326 EXPECT_CALL(routing_table_, SetDefaultMetric(kTestDeviceInterfaceIndex0, 327 GetDefaultMetric())); 328#if !defined(__ANDROID__) 329 EXPECT_CALL(resolver_, SetDNSFromLists( 330 ipconfig_->properties().dns_servers, 331 ipconfig_->properties().domain_search)); 332#else 333 ExpectDNSServerProxyCreation(ipconfig_->properties().dns_servers, true); 334#endif // __ANDROID__ 335 scoped_refptr<MockDevice> device(new StrictMock<MockDevice>( 336 &control_, 337 nullptr, 338 nullptr, 339 nullptr, 340 kTestDeviceName0, 341 string(), 342 kTestDeviceInterfaceIndex0)); 343 EXPECT_CALL(*device_info_, GetDevice(kTestDeviceInterfaceIndex0)) 344 .WillOnce(Return(device)); 345 EXPECT_CALL(*device.get(), RequestPortalDetection()) 346 .WillOnce(Return(true)); 347 EXPECT_CALL(routing_table_, FlushCache()) 348 .WillOnce(Return(true)); 349 connection_->SetIsDefault(true); 350 Mock::VerifyAndClearExpectations(&routing_table_); 351 EXPECT_TRUE(connection_->is_default()); 352 353 EXPECT_CALL(routing_table_, 354 SetDefaultMetric(kTestDeviceInterfaceIndex0, 355 GetNonDefaultMetricBase() + 356 kTestDeviceInterfaceIndex0)); 357 EXPECT_CALL(routing_table_, FlushCache()) 358 .WillOnce(Return(true)); 359 connection_->SetIsDefault(false); 360 EXPECT_FALSE(connection_->is_default()); 361} 362 363TEST_F(ConnectionTest, AddConfigUserTrafficOnly) { 364 ConnectionRefPtr connection = GetNewConnection(); 365 const std::string kExcludeAddress1 = "192.0.1.0/24"; 366 const std::string kExcludeAddress2 = "192.0.2.0/24"; 367 IPAddress address1(IPAddress::kFamilyIPv4); 368 IPAddress address2(IPAddress::kFamilyIPv4); 369 EXPECT_TRUE(address1.SetAddressAndPrefixFromString(kExcludeAddress1)); 370 EXPECT_TRUE(address2.SetAddressAndPrefixFromString(kExcludeAddress2)); 371 EXPECT_CALL(*device_info_, 372 HasOtherAddress(kTestDeviceInterfaceIndex0, 373 IsIPAddress(local_address_, kPrefix0))) 374 .WillOnce(Return(false)); 375 EXPECT_CALL(rtnl_handler_, 376 AddInterfaceAddress(kTestDeviceInterfaceIndex0, 377 IsIPAddress(local_address_, kPrefix0), 378 IsIPAddress(broadcast_address_, 0), 379 IsIPAddress(default_address_, 0))); 380 EXPECT_CALL(routing_table_, 381 ConfigureRoutes(kTestDeviceInterfaceIndex0, ipconfig_, 382 GetDefaultMetric(), 1)); 383 EXPECT_CALL( 384 routing_table_, 385 RequestRouteToHost(IsIPAddress(address1, address1.prefix()), -1, 386 kTestDeviceInterfaceIndex0, IsNonNullCallback(), 1)) 387 .WillOnce(Return(true)); 388 EXPECT_CALL(rtnl_handler_, SetInterfaceMTU(kTestDeviceInterfaceIndex0, 389 IPConfig::kDefaultMTU)); 390 391 MockFirewallProxy* firewall_proxy = new MockFirewallProxy(); 392 connection->firewall_proxy_.reset(firewall_proxy); 393 EXPECT_CALL(*firewall_proxy, RequestVpnSetup(_, _)); 394 properties_.user_traffic_only = true; 395 properties_.default_route = false; 396 properties_.exclusion_list.push_back(kExcludeAddress1); 397 properties_.exclusion_list.push_back(kExcludeAddress2); 398 UpdateProperties(); 399 connection->UpdateFromIPConfig(ipconfig_); 400 401 scoped_refptr<MockDevice> device1( 402 new MockDevice(&control_, nullptr, nullptr, nullptr, kTestDeviceName1, 403 string(), kTestDeviceInterfaceIndex1)); 404 scoped_refptr<MockConnection> mock_connection( 405 new MockConnection(device_info_.get())); 406 ConnectionRefPtr device_connection = mock_connection.get(); 407 408 EXPECT_CALL(*device_info_.get(), 409 FlushAddresses(mock_connection->interface_index())); 410 const string kInterfaceName(kTestDeviceName1); 411 EXPECT_CALL(*mock_connection, interface_name()) 412 .WillRepeatedly(ReturnRef(kInterfaceName)); 413 EXPECT_CALL(*device1, connection()) 414 .WillRepeatedly(testing::ReturnRef(device_connection)); 415 EXPECT_CALL(*device_info_, GetDevice(kTestDeviceInterfaceIndex1)) 416 .WillOnce(Return(device1)); 417 418 EXPECT_CALL(routing_table_, AddRoute(kTestDeviceInterfaceIndex1, 419 IsValidRoutingTableEntry(address2))) 420 .WillOnce(Return(true)); 421 422 connection->OnRouteQueryResponse( 423 kTestDeviceInterfaceIndex1, 424 RoutingTableEntry(default_address_, default_address_, default_address_, 1, 425 1, false)); 426 427 IPAddress test_local_address(local_address_); 428 test_local_address.set_prefix(kPrefix0); 429 EXPECT_TRUE(test_local_address.Equals(GetLocalAddress(connection))); 430 EXPECT_TRUE(gateway_address_.Equals(GetGatewayAddress(connection))); 431 EXPECT_TRUE(GetHasBroadcastDomain(connection)); 432 EXPECT_FALSE(connection->IsIPv6()); 433 434 EXPECT_CALL(routing_table_, 435 CreateLinkRoute(kTestDeviceInterfaceIndex0, 436 IsIPAddress(local_address_, kPrefix0), 437 IsIPAddress(gateway_address_, 0), 1)) 438 .WillOnce(Return(true)) 439 .WillOnce(Return(false)); 440 EXPECT_TRUE(connection->CreateGatewayRoute()); 441 EXPECT_FALSE(connection->CreateGatewayRoute()); 442 connection->has_broadcast_domain_ = false; 443 EXPECT_FALSE(connection->CreateGatewayRoute()); 444 445 EXPECT_CALL(routing_table_, 446 SetDefaultMetric(kTestDeviceInterfaceIndex0, GetDefaultMetric())); 447#if !defined(__ANDROID__) 448 EXPECT_CALL(resolver_, 449 SetDNSFromLists(ipconfig_->properties().dns_servers, 450 ipconfig_->properties().domain_search)); 451#else 452 ExpectDNSServerProxyCreation(ipconfig_->properties().dns_servers, true); 453#endif // __ANDROID__ 454 scoped_refptr<MockDevice> device(new StrictMock<MockDevice>( 455 &control_, nullptr, nullptr, nullptr, kTestDeviceName0, string(), 456 kTestDeviceInterfaceIndex0)); 457 EXPECT_CALL(*device_info_, GetDevice(kTestDeviceInterfaceIndex0)) 458 .WillOnce(Return(device)); 459 EXPECT_CALL(*device.get(), RequestPortalDetection()).WillOnce(Return(true)); 460 EXPECT_CALL(routing_table_, FlushCache()).WillOnce(Return(true)); 461 connection->SetIsDefault(true); 462 Mock::VerifyAndClearExpectations(&routing_table_); 463 EXPECT_TRUE(connection->is_default()); 464 465 EXPECT_CALL(routing_table_, SetDefaultMetric(kTestDeviceInterfaceIndex0, 466 GetNonDefaultMetricBase() + 467 kTestDeviceInterfaceIndex0)); 468 EXPECT_CALL(routing_table_, FlushCache()).WillOnce(Return(true)); 469 connection->SetIsDefault(false); 470 EXPECT_FALSE(connection->is_default()); 471 AddDestructorExpectations(); 472 EXPECT_CALL(*firewall_proxy, RemoveVpnSetup()); 473} 474 475TEST_F(ConnectionTest, AddConfigIPv6) { 476 EXPECT_CALL(*device_info_, 477 HasOtherAddress(kTestDeviceInterfaceIndex0, 478 IsIPv6Address(local_ipv6_address_))) 479 .WillOnce(Return(false)); 480 EXPECT_CALL(rtnl_handler_, 481 AddInterfaceAddress(kTestDeviceInterfaceIndex0, 482 IsIPv6Address(local_ipv6_address_), 483 _, 484 _)); 485 EXPECT_CALL(routing_table_, 486 ConfigureRoutes(kTestDeviceInterfaceIndex0, 487 ip6config_, 488 GetDefaultMetric(), 489 RT_TABLE_MAIN)); 490 EXPECT_CALL(rtnl_handler_, SetInterfaceMTU(kTestDeviceInterfaceIndex0, 491 IPConfig::kDefaultMTU)); 492 connection_->UpdateFromIPConfig(ip6config_); 493 IPAddress test_local_address(local_ipv6_address_); 494 EXPECT_TRUE(test_local_address.Equals(GetLocalAddress(connection_))); 495 EXPECT_TRUE(connection_->IsIPv6()); 496} 497 498TEST_F(ConnectionTest, AddConfigWithPeer) { 499 const string kPeerAddress("192.168.1.222"); 500 IPAddress peer_address(IPAddress::kFamilyIPv4); 501 EXPECT_TRUE(peer_address.SetAddressFromString(kPeerAddress)); 502 properties_.peer_address = kPeerAddress; 503 properties_.gateway = string(); 504 UpdateProperties(); 505 EXPECT_CALL(*device_info_, 506 HasOtherAddress(kTestDeviceInterfaceIndex0, 507 IsIPAddress(local_address_, kPrefix0))) 508 .WillOnce(Return(false)); 509 EXPECT_CALL(rtnl_handler_, 510 AddInterfaceAddress(kTestDeviceInterfaceIndex0, 511 IsIPAddress(local_address_, kPrefix0), 512 IsIPAddress(broadcast_address_, 0), 513 IsIPAddress(peer_address, 0))); 514 EXPECT_CALL(routing_table_, SetDefaultRoute(_, _, _, _)).Times(0); 515 EXPECT_CALL(routing_table_, 516 ConfigureRoutes(kTestDeviceInterfaceIndex0, 517 ipconfig_, 518 GetDefaultMetric(), 519 RT_TABLE_MAIN)); 520 EXPECT_CALL(rtnl_handler_, SetInterfaceMTU(kTestDeviceInterfaceIndex0, 521 IPConfig::kDefaultMTU)); 522 connection_->UpdateFromIPConfig(ipconfig_); 523 EXPECT_FALSE(GetHasBroadcastDomain(connection_)); 524} 525 526TEST_F(ConnectionTest, AddConfigWithBrokenNetmask) { 527 // Assign a prefix that makes the gateway unreachable. 528 properties_.subnet_prefix = kPrefix1; 529 UpdateProperties(); 530 531 // Connection should add a link route which will allow the 532 // gateway to be reachable. 533 IPAddress gateway_address(IPAddress::kFamilyIPv4); 534 EXPECT_TRUE(gateway_address.SetAddressFromString(kGatewayAddress0)); 535 EXPECT_CALL(routing_table_, AddRoute(kTestDeviceInterfaceIndex0, 536 IsLinkRouteTo(gateway_address))) 537 .WillOnce(Return(true)); 538 EXPECT_CALL(*device_info_, 539 HasOtherAddress(kTestDeviceInterfaceIndex0, 540 IsIPAddress(local_address_, kPrefix1))) 541 .WillOnce(Return(false)); 542 EXPECT_CALL(rtnl_handler_, 543 AddInterfaceAddress(kTestDeviceInterfaceIndex0, 544 IsIPAddress(local_address_, kPrefix1), 545 IsIPAddress(broadcast_address_, 0), 546 IsIPAddress(default_address_, 0))); 547 EXPECT_CALL(routing_table_, 548 SetDefaultRoute(kTestDeviceInterfaceIndex0, 549 IsIPAddress(gateway_address_, 0), 550 GetNonDefaultMetricBase() + 551 kTestDeviceInterfaceIndex0, 552 RT_TABLE_MAIN)); 553 EXPECT_CALL(routing_table_, 554 ConfigureRoutes(kTestDeviceInterfaceIndex0, 555 ipconfig_, 556 GetDefaultMetric(), 557 RT_TABLE_MAIN)); 558 EXPECT_CALL(rtnl_handler_, SetInterfaceMTU(kTestDeviceInterfaceIndex0, 559 IPConfig::kDefaultMTU)); 560 connection_->UpdateFromIPConfig(ipconfig_); 561} 562 563TEST_F(ConnectionTest, AddConfigReverse) { 564 EXPECT_CALL(routing_table_, SetDefaultMetric(kTestDeviceInterfaceIndex0, 565 GetDefaultMetric())); 566 vector<string> empty_list; 567#if !defined(__ANDROID__) 568 EXPECT_CALL(resolver_, SetDNSFromLists(empty_list, empty_list)); 569#else 570 ExpectDNSServerProxyCreation(empty_list, true); 571#endif // __ANDROID__ 572 scoped_refptr<MockDevice> device(new StrictMock<MockDevice>( 573 &control_, 574 nullptr, 575 nullptr, 576 nullptr, 577 kTestDeviceName0, 578 string(), 579 kTestDeviceInterfaceIndex0)); 580 EXPECT_CALL(*device_info_, GetDevice(kTestDeviceInterfaceIndex0)) 581 .WillOnce(Return(device)); 582 EXPECT_CALL(*device.get(), RequestPortalDetection()) 583 .WillOnce(Return(true)); 584 EXPECT_CALL(routing_table_, FlushCache()) 585 .WillOnce(Return(true)); 586 connection_->SetIsDefault(true); 587 Mock::VerifyAndClearExpectations(&routing_table_); 588 589 EXPECT_CALL(*device_info_, 590 HasOtherAddress(kTestDeviceInterfaceIndex0, 591 IsIPAddress(local_address_, kPrefix0))) 592 .WillOnce(Return(false)); 593 EXPECT_CALL(rtnl_handler_, 594 AddInterfaceAddress(kTestDeviceInterfaceIndex0, 595 IsIPAddress(local_address_, kPrefix0), 596 IsIPAddress(broadcast_address_, 0), 597 IsIPAddress(default_address_, 0))); 598 EXPECT_CALL(routing_table_, SetDefaultRoute(kTestDeviceInterfaceIndex0, 599 IsIPAddress(gateway_address_, 0), 600 GetDefaultMetric(), 601 RT_TABLE_MAIN)); 602 EXPECT_CALL(routing_table_, 603 ConfigureRoutes(kTestDeviceInterfaceIndex0, 604 ipconfig_, 605 GetDefaultMetric(), 606 RT_TABLE_MAIN)); 607#if !defined(__ANDROID__) 608 EXPECT_CALL(resolver_, 609 SetDNSFromLists(ipconfig_->properties().dns_servers, 610 ipconfig_->properties().domain_search)); 611#else 612 ExpectDNSServerProxyCreation(ipconfig_->properties().dns_servers, true); 613#endif // __ANDROID__ 614 EXPECT_CALL(rtnl_handler_, SetInterfaceMTU(kTestDeviceInterfaceIndex0, 615 IPConfig::kDefaultMTU)); 616 connection_->UpdateFromIPConfig(ipconfig_); 617} 618 619TEST_F(ConnectionTest, AddConfigWithDNSDomain) { 620 const string kDomainName("chromium.org"); 621 properties_.domain_search.clear(); 622 properties_.domain_name = kDomainName; 623 UpdateProperties(); 624 EXPECT_CALL(*device_info_, HasOtherAddress(_, _)) 625 .WillOnce(Return(false)); 626 EXPECT_CALL(rtnl_handler_, AddInterfaceAddress(_, _, _, _)); 627 EXPECT_CALL(routing_table_, SetDefaultRoute(_, _, _, _)); 628 EXPECT_CALL(routing_table_, ConfigureRoutes(_, _, _, _)); 629 EXPECT_CALL(rtnl_handler_, SetInterfaceMTU(_, _)); 630 connection_->UpdateFromIPConfig(ipconfig_); 631 632 EXPECT_CALL(routing_table_, SetDefaultMetric(_, _)); 633 vector<string> domain_search_list; 634 domain_search_list.push_back(kDomainName + "."); 635#if !defined(__ANDROID__) 636 EXPECT_CALL(resolver_, SetDNSFromLists(_, domain_search_list)); 637#else 638 ExpectDNSServerProxyCreation(vector<string>(), false); 639#endif // __ANDROID__ 640 DeviceRefPtr device; 641 EXPECT_CALL(*device_info_, GetDevice(_)).WillOnce(Return(device)); 642 EXPECT_CALL(routing_table_, FlushCache()).WillOnce(Return(true)); 643 connection_->SetIsDefault(true); 644} 645 646TEST_F(ConnectionTest, HasOtherAddress) { 647 EXPECT_CALL(*device_info_, 648 HasOtherAddress(kTestDeviceInterfaceIndex0, 649 IsIPAddress(local_address_, kPrefix0))) 650 .WillOnce(Return(true)); 651 EXPECT_CALL(routing_table_, FlushRoutes(kTestDeviceInterfaceIndex0)); 652 EXPECT_CALL(*device_info_, FlushAddresses(kTestDeviceInterfaceIndex0)); 653 EXPECT_CALL(rtnl_handler_, 654 AddInterfaceAddress(kTestDeviceInterfaceIndex0, 655 IsIPAddress(local_address_, kPrefix0), 656 IsIPAddress(broadcast_address_, 0), 657 IsIPAddress(default_address_, 0))); 658 EXPECT_CALL(routing_table_, 659 SetDefaultRoute(kTestDeviceInterfaceIndex0, 660 IsIPAddress(gateway_address_, 0), 661 GetNonDefaultMetricBase() + 662 kTestDeviceInterfaceIndex0, 663 RT_TABLE_MAIN)); 664 EXPECT_CALL(routing_table_, 665 ConfigureRoutes(kTestDeviceInterfaceIndex0, 666 ipconfig_, 667 GetDefaultMetric(), 668 RT_TABLE_MAIN)); 669 EXPECT_CALL(rtnl_handler_, SetInterfaceMTU(kTestDeviceInterfaceIndex0, 670 IPConfig::kDefaultMTU)); 671 connection_->UpdateFromIPConfig(ipconfig_); 672} 673 674TEST_F(ConnectionTest, UpdateDNSServers) { 675 const char* kDnsServers[] = {"1.1.1.1", "1.1.1.2"}; 676 vector<string> dns_servers(kDnsServers, std::end(kDnsServers)); 677 678 // Non-default connection. 679 connection_->is_default_ = false; 680#if !defined(__ANDROID__) 681 EXPECT_CALL(resolver_, SetDNSFromLists(_, _)).Times(0); 682#else 683 EXPECT_CALL(dns_server_proxy_factory_, CreateDNSServerProxy(_)).Times(0); 684#endif // __ANDROID__ 685 connection_->UpdateDNSServers(dns_servers); 686#if !defined(__ANDROID__) 687 Mock::VerifyAndClearExpectations(&resolver_); 688#else 689 Mock::VerifyAndClearExpectations(&dns_server_proxy_factory_); 690#endif // __ANDROID__ 691 692 // Default connection. 693 connection_->is_default_ = true; 694#if !defined(__ANDROID__) 695 EXPECT_CALL(resolver_, SetDNSFromLists(dns_servers, _)); 696#else 697 ExpectDNSServerProxyCreation(dns_servers, true); 698#endif // __ANDROID__ 699 connection_->UpdateDNSServers(dns_servers); 700#if !defined(__ANDROID__) 701 Mock::VerifyAndClearExpectations(&resolver_); 702#else 703 Mock::VerifyAndClearExpectations(&dns_server_proxy_factory_); 704#endif // __ANDROID__ 705} 706 707TEST_F(ConnectionTest, RouteRequest) { 708 ConnectionRefPtr connection = GetNewConnection(); 709 scoped_refptr<MockDevice> device(new StrictMock<MockDevice>( 710 &control_, 711 nullptr, 712 nullptr, 713 nullptr, 714 kTestDeviceName0, 715 string(), 716 kTestDeviceInterfaceIndex0)); 717 EXPECT_CALL(*device_info_, GetDevice(kTestDeviceInterfaceIndex0)) 718 .WillRepeatedly(Return(device)); 719 EXPECT_CALL(*device.get(), SetLooseRouting(true)).Times(1); 720 connection->RequestRouting(); 721 connection->RequestRouting(); 722 723 // The first release should only decrement the reference counter. 724 connection->ReleaseRouting(); 725 726 // Another release will re-enable reverse-path filter. 727 EXPECT_CALL(*device.get(), SetLooseRouting(false)); 728 EXPECT_CALL(routing_table_, FlushCache()); 729 connection->ReleaseRouting(); 730 731 // The destructor will remove the routes and addresses. 732 AddDestructorExpectations(); 733} 734 735TEST_F(ConnectionTest, Destructor) { 736 ConnectionRefPtr connection(new Connection(kTestDeviceInterfaceIndex1, 737 kTestDeviceName1, 738 Technology::kUnknown, 739 device_info_.get(), 740 &control_)); 741#if !defined(__ANDROID__) 742 connection->resolver_ = &resolver_; 743#else 744 connection->dns_server_proxy_factory_ = &dns_server_proxy_factory_; 745#endif // __ANDROID__ 746 connection->routing_table_ = &routing_table_; 747 connection->rtnl_handler_ = &rtnl_handler_; 748 EXPECT_CALL(routing_table_, FlushRoutes(kTestDeviceInterfaceIndex1)); 749 EXPECT_CALL(routing_table_, FlushRoutesWithTag(kTestDeviceInterfaceIndex1)); 750 EXPECT_CALL(*device_info_, FlushAddresses(kTestDeviceInterfaceIndex1)); 751 connection = nullptr; 752} 753 754TEST_F(ConnectionTest, RequestHostRoute) { 755 ConnectionRefPtr connection = GetNewConnection(); 756 IPAddress address(IPAddress::kFamilyIPv4); 757 ASSERT_TRUE(address.SetAddressFromString(kIPAddress0)); 758 size_t prefix_len = 16; 759 address.set_prefix(prefix_len); 760 EXPECT_CALL(routing_table_, 761 RequestRouteToHost(IsIPAddress(address, prefix_len), 762 -1, 763 kTestDeviceInterfaceIndex0, 764 IsNonNullCallback(), 765 RT_TABLE_MAIN)) 766 .WillOnce(Return(true)); 767 EXPECT_TRUE(connection->RequestHostRoute(address)); 768 769 // The destructor will remove the routes and addresses. 770 AddDestructorExpectations(); 771} 772 773TEST_F(ConnectionTest, BlackholeIPv6) { 774 properties_.blackhole_ipv6 = true; 775 UpdateProperties(); 776 EXPECT_CALL(*device_info_, HasOtherAddress(_, _)) 777 .WillOnce(Return(false)); 778 EXPECT_CALL(rtnl_handler_, AddInterfaceAddress(_, _, _, _)); 779 EXPECT_CALL(routing_table_, SetDefaultRoute(_, _, _, _)); 780 EXPECT_CALL(routing_table_, ConfigureRoutes(_, _, _, _)); 781 EXPECT_CALL(routing_table_, 782 CreateBlackholeRoute(kTestDeviceInterfaceIndex0, 783 IPAddress::kFamilyIPv6, 784 Connection::kDefaultMetric, 785 RT_TABLE_MAIN)) 786 .WillOnce(Return(true)); 787 EXPECT_CALL(rtnl_handler_, SetInterfaceMTU(kTestDeviceInterfaceIndex0, 788 IPConfig::kDefaultMTU)); 789 connection_->UpdateFromIPConfig(ipconfig_); 790} 791 792TEST_F(ConnectionTest, PinHostRoute) { 793 ConnectionRefPtr connection = GetNewConnection(); 794 795 IPAddress gateway(IPAddress::kFamilyIPv4); 796 IPAddress trusted_ip(IPAddress::kFamilyIPv4); 797 798 // Should fail because neither IP address is set. 799 EXPECT_FALSE(PinHostRoute(connection, trusted_ip, gateway)); 800 801 static const char kGateway[] = "10.242.2.13"; 802 ASSERT_TRUE(gateway.SetAddressFromString(kGateway)); 803 804 // Should fail because trusted IP is not set. 805 EXPECT_FALSE(PinHostRoute(connection, trusted_ip, gateway)); 806 807 static const char kTrustedIP[] = "10.0.1.1/8"; 808 ASSERT_TRUE(trusted_ip.SetAddressAndPrefixFromString(kTrustedIP)); 809 810 // Should pass without calling RequestRouteToHost since if the gateway 811 // is not set, there is no work to be done. 812 EXPECT_CALL(routing_table_, RequestRouteToHost(_, _, _, _, _)).Times(0); 813 EXPECT_TRUE(PinHostRoute(connection, trusted_ip, 814 IPAddress(gateway.family()))); 815 Mock::VerifyAndClearExpectations(&routing_table_); 816 817 EXPECT_CALL(routing_table_, 818 RequestRouteToHost(IsIPAddress(trusted_ip, trusted_ip.prefix()), 819 -1, kTestDeviceInterfaceIndex0, _, 820 RT_TABLE_MAIN)).WillOnce(Return(false)); 821 EXPECT_FALSE(PinHostRoute(connection, trusted_ip, gateway)); 822 823 EXPECT_CALL(routing_table_, 824 RequestRouteToHost(IsIPAddress(trusted_ip, trusted_ip.prefix()), 825 -1, kTestDeviceInterfaceIndex0, _, 826 RT_TABLE_MAIN)).WillOnce(Return(true)); 827 EXPECT_TRUE(PinHostRoute(connection, trusted_ip, gateway)); 828 829 // The destructor will remove the routes and addresses. 830 AddDestructorExpectations(); 831} 832 833TEST_F(ConnectionTest, FixGatewayReachability) { 834 ConnectionRefPtr connection = GetNewConnection(); 835 static const char kLocal[] = "10.242.2.13"; 836 IPAddress local(IPAddress::kFamilyIPv4); 837 ASSERT_TRUE(local.SetAddressFromString(kLocal)); 838 const int kPrefix = 24; 839 local.set_prefix(kPrefix); 840 IPAddress gateway(IPAddress::kFamilyIPv4); 841 IPAddress peer(IPAddress::kFamilyIPv4); 842 IPAddress trusted_ip(IPAddress::kFamilyIPv4); 843 844 // Should fail because no gateway is set. 845 EXPECT_FALSE(connection->FixGatewayReachability( 846 local, &peer, &gateway, trusted_ip)); 847 EXPECT_EQ(kPrefix, local.prefix()); 848 EXPECT_FALSE(peer.IsValid()); 849 EXPECT_FALSE(gateway.IsValid()); 850 851 // Should succeed because with the given prefix, this gateway is reachable. 852 static const char kReachableGateway[] = "10.242.2.14"; 853 ASSERT_TRUE(gateway.SetAddressFromString(kReachableGateway)); 854 IPAddress gateway_backup(gateway); 855 peer = IPAddress(IPAddress::kFamilyIPv4); 856 EXPECT_TRUE(connection->FixGatewayReachability( 857 local, &peer, &gateway, trusted_ip)); 858 // Prefix should remain unchanged. 859 EXPECT_EQ(kPrefix, local.prefix()); 860 // Peer should remain unchanged. 861 EXPECT_FALSE(peer.IsValid()); 862 // Gateway should remain unchanged. 863 EXPECT_TRUE(gateway_backup.Equals(gateway)); 864 865 // Should succeed because we created a link route to the gateway. 866 static const char kRemoteGateway[] = "10.242.3.14"; 867 ASSERT_TRUE(gateway.SetAddressFromString(kRemoteGateway)); 868 gateway_backup = gateway; 869 peer = IPAddress(IPAddress::kFamilyIPv4); 870 EXPECT_CALL(routing_table_, AddRoute(kTestDeviceInterfaceIndex0, 871 IsLinkRouteTo(gateway))) 872 .WillOnce(Return(true)); 873 EXPECT_TRUE(connection->FixGatewayReachability( 874 local, &peer, &gateway, trusted_ip)); 875 876 // Peer should remain unchanged. 877 EXPECT_FALSE(peer.IsValid()); 878 // Gateway should remain unchanged. 879 EXPECT_TRUE(gateway_backup.Equals(gateway)); 880 881 // Should fail if AddRoute() fails. 882 EXPECT_CALL(routing_table_, AddRoute(kTestDeviceInterfaceIndex0, 883 IsLinkRouteTo(gateway))) 884 .WillOnce(Return(false)); 885 EXPECT_FALSE(connection->FixGatewayReachability( 886 local, &peer, &gateway, trusted_ip)); 887 888 // If this is a peer-to-peer interface and the peer matches the gateway, 889 // we should succeed. 890 local.set_prefix(kPrefix); 891 static const char kUnreachableGateway[] = "11.242.2.14"; 892 ASSERT_TRUE(gateway.SetAddressFromString(kUnreachableGateway)); 893 gateway_backup = gateway; 894 ASSERT_TRUE(peer.SetAddressFromString(kUnreachableGateway)); 895 EXPECT_TRUE(connection->FixGatewayReachability( 896 local, &peer, &gateway, trusted_ip)); 897 EXPECT_EQ(kPrefix, local.prefix()); 898 EXPECT_TRUE(peer.Equals(gateway)); 899 EXPECT_TRUE(gateway_backup.Equals(gateway)); 900 901 // If there is a peer specified and it does not match the gateway (even 902 // if it was reachable via netmask), we should fail. 903 ASSERT_TRUE(gateway.SetAddressFromString(kReachableGateway)); 904 EXPECT_FALSE(connection->FixGatewayReachability( 905 local, &peer, &gateway, trusted_ip)); 906 EXPECT_EQ(kPrefix, local.prefix()); 907 EXPECT_FALSE(peer.Equals(gateway)); 908 909 // If this is a peer-to-peer interface and the peer matches the gateway, 910 // but it also matches the trusted IP address, the gateway and peer address 911 // should be modified to allow routing to work correctly. 912 ASSERT_TRUE(gateway.SetAddressFromString(kUnreachableGateway)); 913 ASSERT_TRUE(peer.SetAddressFromString(kUnreachableGateway)); 914 ASSERT_TRUE(trusted_ip.SetAddressAndPrefixFromString( 915 string(kUnreachableGateway) + "/32")); 916 EXPECT_TRUE(connection->FixGatewayReachability( 917 local, &peer, &gateway, trusted_ip)); 918 EXPECT_TRUE(peer.IsDefault()); 919 EXPECT_TRUE(gateway.IsDefault()); 920 921 // The destructor will remove the routes and addresses. 922 AddDestructorExpectations(); 923} 924 925TEST_F(ConnectionTest, Binders) { 926 EXPECT_TRUE(connection_->binders_.empty()); 927 DisconnectCallbackTarget target0; 928 DisconnectCallbackTarget target1; 929 DisconnectCallbackTarget target2; 930 DisconnectCallbackTarget target3; 931 Connection::Binder binder0("binder0", target0.callback()); 932 Connection::Binder binder1("binder1", target1.callback()); 933 Connection::Binder binder2("binder2", target2.callback()); 934 Connection::Binder binder3("binder3", target3.callback()); 935 936 binder0.Attach(connection_); 937 binder1.Attach(connection_); 938 939 EXPECT_CALL(target1, CallTarget()).Times(0); 940 binder1.Attach(connection_); 941 942 binder3.Attach(connection_); 943 binder2.Attach(connection_); 944 945 EXPECT_CALL(target3, CallTarget()).Times(0); 946 binder3.Attach(nullptr); 947 948 ASSERT_EQ(3, connection_->binders_.size()); 949 EXPECT_TRUE(connection_->binders_.at(0) == &binder0); 950 EXPECT_TRUE(connection_->binders_.at(1) == &binder1); 951 EXPECT_TRUE(connection_->binders_.at(2) == &binder2); 952 953 EXPECT_CALL(target0, CallTarget()).Times(1); 954 EXPECT_CALL(target1, CallTarget()).Times(1); 955 EXPECT_CALL(target2, CallTarget()).Times(1); 956 connection_->NotifyBindersOnDisconnect(); 957 EXPECT_TRUE(connection_->binders_.empty()); 958 959 // Should be a no-op. 960 connection_->NotifyBindersOnDisconnect(); 961} 962 963TEST_F(ConnectionTest, Binder) { 964 // No connection should be bound initially. 965 Connection::Binder* binder = &connection_->lower_binder_; 966 EXPECT_EQ(connection_->interface_name(), binder->name_); 967 EXPECT_FALSE(binder->client_disconnect_callback_.is_null()); 968 EXPECT_FALSE(binder->IsBound()); 969 970 ConnectionRefPtr connection1 = GetNewConnection(); 971 EXPECT_TRUE(connection1->binders_.empty()); 972 973 // Bind lower |connection1| and check if it's bound. 974 binder->Attach(connection1); 975 EXPECT_TRUE(binder->IsBound()); 976 EXPECT_EQ(connection1.get(), binder->connection().get()); 977 ASSERT_FALSE(connection1->binders_.empty()); 978 EXPECT_TRUE(binder == connection1->binders_.at(0)); 979 980 // Unbind lower |connection1| and check if it's unbound. 981 binder->Attach(nullptr); 982 EXPECT_FALSE(binder->IsBound()); 983 EXPECT_TRUE(connection1->binders_.empty()); 984 985 ConnectionRefPtr connection2 = GetNewConnection(); 986 987 // Bind lower |connection1| to upper |connection2| and destroy the upper 988 // |connection2|. Make sure lower |connection1| is unbound (i.e., the 989 // disconnect callback is deregistered). 990 connection2->lower_binder_.Attach(connection1); 991 EXPECT_FALSE(connection1->binders_.empty()); 992 AddDestructorExpectations(); 993 connection2 = nullptr; 994 EXPECT_TRUE(connection1->binders_.empty()); 995 996 // Bind lower |connection1| to upper |connection_| and destroy lower 997 // |connection1|. Make sure lower |connection1| is unbound from upper 998 // |connection_| and upper |connection_|'s registered disconnect callbacks are 999 // run. 1000 binder->Attach(connection1); 1001 DisconnectCallbackTarget target; 1002 Connection::Binder test_binder("from_test", target.callback()); 1003 test_binder.Attach(connection_); 1004 EXPECT_CALL(target, CallTarget()).Times(1); 1005 ASSERT_FALSE(connection_->binders_.empty()); 1006 AddDestructorExpectations(); 1007 connection1 = nullptr; 1008 EXPECT_FALSE(binder->IsBound()); 1009 EXPECT_FALSE(test_binder.IsBound()); 1010 EXPECT_TRUE(connection_->binders_.empty()); 1011 1012 { 1013 // Binding a connection to itself should be safe. 1014 ConnectionRefPtr connection = GetNewConnection(); 1015 1016 connection->lower_binder_.Attach(connection); 1017 1018 EXPECT_FALSE(connection->binders_.empty()); 1019 1020 DisconnectCallbackTarget target; 1021 Connection::Binder binder("test", target.callback()); 1022 binder.Attach(connection); 1023 1024 AddDestructorExpectations(); 1025 EXPECT_CALL(target, CallTarget()).Times(1); 1026 connection = nullptr; 1027 } 1028 { 1029 // Circular binding of multiple connections should be safe. 1030 ConnectionRefPtr connection_a = GetNewConnection(); 1031 ConnectionRefPtr connection_b = GetNewConnection(); 1032 1033 connection_a->lower_binder_.Attach(connection_b); 1034 connection_b->lower_binder_.Attach(connection_a); 1035 1036 EXPECT_FALSE(connection_a->binders_.empty()); 1037 EXPECT_FALSE(connection_b->binders_.empty()); 1038 1039 DisconnectCallbackTarget target_a; 1040 DisconnectCallbackTarget target_b; 1041 Connection::Binder binder_a("test_a", target_a.callback()); 1042 Connection::Binder binder_b("test_b", target_b.callback()); 1043 binder_a.Attach(connection_a); 1044 binder_b.Attach(connection_b); 1045 1046 AddDestructorExpectations(); 1047 EXPECT_CALL(target_a, CallTarget()).Times(1); 1048 EXPECT_CALL(target_b, CallTarget()).Times(1); 1049 connection_b = nullptr; 1050 1051 EXPECT_TRUE(connection_a->binders_.empty()); 1052 1053 AddDestructorExpectations(); 1054 connection_a = nullptr; 1055 } 1056 { 1057 // Test the weak pointer to the bound Connection. This is not a case that 1058 // should occur but the weak pointer should handle it gracefully. 1059 DisconnectCallbackTarget target; 1060 Connection::Binder binder("test_weak", target.callback()); 1061 ConnectionRefPtr connection = GetNewConnection(); 1062 binder.Attach(connection); 1063 1064 // Make sure the connection doesn't notify the binder on destruction. 1065 connection->binders_.clear(); 1066 AddDestructorExpectations(); 1067 EXPECT_CALL(target, CallTarget()).Times(0); 1068 connection = nullptr; 1069 1070 // Ensure no crash -- the weak pointer to connection should be nullptr. 1071 EXPECT_FALSE(binder.connection()); 1072 binder.Attach(nullptr); 1073 } 1074} 1075 1076TEST_F(ConnectionTest, OnRouteQueryResponse) { 1077 Connection::Binder* binder = &connection_->lower_binder_; 1078 ConnectionRefPtr connection = GetNewConnection(); 1079 scoped_refptr<MockDevice> device(new StrictMock<MockDevice>( 1080 &control_, 1081 nullptr, 1082 nullptr, 1083 nullptr, 1084 kTestDeviceName1, 1085 string(), 1086 kTestDeviceInterfaceIndex1)); 1087 1088 // Make sure we unbind the old lower connection even if we can't lookup the 1089 // lower connection device. 1090 binder->Attach(connection); 1091 scoped_refptr<MockDevice> null_device; 1092 EXPECT_CALL(*device_info_, GetDevice(kTestDeviceInterfaceIndex1)) 1093 .WillOnce(Return(null_device)); 1094 connection_->OnRouteQueryResponse( 1095 kTestDeviceInterfaceIndex1, RoutingTableEntry()); 1096 EXPECT_FALSE(binder->IsBound()); 1097 1098 // Check for graceful handling of a connection loop. 1099 EXPECT_CALL(*device, connection()) 1100 .WillRepeatedly(testing::ReturnRef(connection_)); 1101 EXPECT_CALL(*device_info_, GetDevice(kTestDeviceInterfaceIndex1)) 1102 .WillOnce(Return(device)); 1103 connection_->OnRouteQueryResponse( 1104 kTestDeviceInterfaceIndex1, RoutingTableEntry()); 1105 EXPECT_FALSE(binder->IsBound()); 1106 1107 // Check for graceful handling of a device with no connection. 1108 ConnectionRefPtr device_connection; 1109 EXPECT_CALL(*device, connection()) 1110 .WillRepeatedly(testing::ReturnRef(device_connection)); 1111 EXPECT_CALL(*device_info_, GetDevice(kTestDeviceInterfaceIndex1)) 1112 .WillOnce(Return(device)); 1113 connection_->OnRouteQueryResponse( 1114 kTestDeviceInterfaceIndex1, RoutingTableEntry()); 1115 EXPECT_FALSE(binder->IsBound()); 1116 1117 // Create a mock connection that will be used for binding. 1118 scoped_refptr<MockConnection> mock_connection( 1119 new StrictMock<MockConnection>(device_info_.get())); 1120 EXPECT_CALL(*device_info_.get(), 1121 FlushAddresses(mock_connection->interface_index())); 1122 const string kInterfaceName(kTestDeviceName0); 1123 EXPECT_CALL(*mock_connection, interface_name()) 1124 .WillRepeatedly(ReturnRef(kInterfaceName)); 1125 device_connection = mock_connection.get(); 1126 EXPECT_CALL(*device, connection()) 1127 .WillRepeatedly(testing::ReturnRef(device_connection)); 1128 EXPECT_CALL(*device_info_, GetDevice(kTestDeviceInterfaceIndex1)) 1129 .WillOnce(Return(device)); 1130 1131 // Check that the binding process completes, causing its upper 1132 // connection to create a gateway route. 1133 EXPECT_CALL(*mock_connection, CreateGatewayRoute()) 1134 .WillOnce(Return(true)); 1135 1136 // Ensure that the Device is notified of the change to the connection. 1137 EXPECT_CALL(*device, OnConnectionUpdated()).Times(1); 1138 connection_->OnRouteQueryResponse( 1139 kTestDeviceInterfaceIndex1, RoutingTableEntry()); 1140 1141 // Check that the upper connection is bound to the lower connection. 1142 EXPECT_TRUE(binder->IsBound()); 1143 EXPECT_EQ(mock_connection.get(), binder->connection().get()); 1144 1145 AddDestructorExpectations(); 1146 connection = nullptr; 1147} 1148 1149TEST_F(ConnectionTest, GetCarrierConnection) { 1150 EXPECT_EQ(connection_.get(), connection_->GetCarrierConnection().get()); 1151 1152 ConnectionRefPtr connection1 = GetNewConnection(); 1153 ConnectionRefPtr connection2 = GetNewConnection(); 1154 ConnectionRefPtr connection3 = GetNewConnection(); 1155 1156 connection_->lower_binder_.Attach(connection1); 1157 EXPECT_EQ(connection1.get(), connection_->GetCarrierConnection().get()); 1158 1159 connection1->lower_binder_.Attach(connection2); 1160 EXPECT_EQ(connection2.get(), connection_->GetCarrierConnection().get()); 1161 1162 connection2->lower_binder_.Attach(connection3); 1163 EXPECT_EQ(connection3.get(), connection_->GetCarrierConnection().get()); 1164 1165 // Create a cycle back to |connection1|. 1166 connection3->lower_binder_.Attach(connection1); 1167 EXPECT_EQ(nullptr, connection_->GetCarrierConnection().get()); 1168 1169 AddDestructorExpectations(); 1170 connection3 = nullptr; 1171 1172 AddDestructorExpectations(); 1173 connection2 = nullptr; 1174 1175 AddDestructorExpectations(); 1176 connection1 = nullptr; 1177} 1178 1179TEST_F(ConnectionTest, GetSubnetName) { 1180 EXPECT_EQ("", connection_->GetSubnetName()); 1181 IPAddress local("1.2.3.4"); 1182 local.set_prefix(24); 1183 SetLocal(local); 1184 EXPECT_EQ("1.2.3.0/24", connection_->GetSubnetName()); 1185} 1186 1187TEST_F(ConnectionTest, SetMTU) { 1188 testing::InSequence seq; 1189 EXPECT_CALL(rtnl_handler_, SetInterfaceMTU( 1190 kTestDeviceInterfaceIndex0, IPConfig::kDefaultMTU)); 1191 connection_->SetMTU(0); 1192 1193 EXPECT_CALL(rtnl_handler_, SetInterfaceMTU( 1194 kTestDeviceInterfaceIndex0, IPConfig::kDefaultMTU)); 1195 connection_->SetMTU(IPConfig::kUndefinedMTU); 1196 1197 // Test IPv4 minimum MTU. 1198 SetLocal(local_address_); 1199 EXPECT_CALL(rtnl_handler_, SetInterfaceMTU( 1200 kTestDeviceInterfaceIndex0, IPConfig::kMinIPv4MTU)); 1201 connection_->SetMTU(1); 1202 1203 EXPECT_CALL(rtnl_handler_, SetInterfaceMTU( 1204 kTestDeviceInterfaceIndex0, IPConfig::kMinIPv4MTU)); 1205 connection_->SetMTU(IPConfig::kMinIPv4MTU - 1); 1206 1207 EXPECT_CALL(rtnl_handler_, SetInterfaceMTU( 1208 kTestDeviceInterfaceIndex0, IPConfig::kMinIPv4MTU)); 1209 connection_->SetMTU(IPConfig::kMinIPv4MTU); 1210 1211 EXPECT_CALL(rtnl_handler_, SetInterfaceMTU( 1212 kTestDeviceInterfaceIndex0, IPConfig::kMinIPv4MTU + 1)); 1213 connection_->SetMTU(IPConfig::kMinIPv4MTU + 1); 1214 1215 // Test IPv6 minimum MTU. 1216 SetLocal(local_ipv6_address_); 1217 EXPECT_CALL(rtnl_handler_, SetInterfaceMTU( 1218 kTestDeviceInterfaceIndex0, IPConfig::kMinIPv6MTU)); 1219 connection_->SetMTU(1); 1220 1221 EXPECT_CALL(rtnl_handler_, SetInterfaceMTU( 1222 kTestDeviceInterfaceIndex0, IPConfig::kMinIPv6MTU)); 1223 connection_->SetMTU(IPConfig::kMinIPv6MTU - 1); 1224 1225 EXPECT_CALL(rtnl_handler_, SetInterfaceMTU( 1226 kTestDeviceInterfaceIndex0, IPConfig::kMinIPv6MTU)); 1227 connection_->SetMTU(IPConfig::kMinIPv6MTU); 1228 1229 EXPECT_CALL(rtnl_handler_, SetInterfaceMTU( 1230 kTestDeviceInterfaceIndex0, IPConfig::kMinIPv6MTU + 1)); 1231 connection_->SetMTU(IPConfig::kMinIPv6MTU + 1); 1232} 1233 1234} // namespace shill 1235