Home | History | Annotate | Download | only in dhcp 
      1 //
      2 // Copyright (C) 2015 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/dhcp/dhcpv6_config.h"
     18 
     19 #include <memory>
     20 #include <string>
     21 #include <vector>
     22 
     23 #include <base/bind.h>
     24 #include <base/files/file_util.h>
     25 #include <base/files/scoped_temp_dir.h>
     26 #include <base/strings/stringprintf.h>
     27 #if defined(__ANDROID__)
     28 #include <dbus/service_constants.h>
     29 #else
     30 #include <chromeos/dbus/service_constants.h>
     31 #endif  // __ANDROID__
     32 
     33 #include "shill/dhcp/mock_dhcp_provider.h"
     34 #include "shill/dhcp/mock_dhcp_proxy.h"
     35 #include "shill/event_dispatcher.h"
     36 #include "shill/mock_control.h"
     37 #include "shill/mock_log.h"
     38 #include "shill/mock_metrics.h"
     39 #include "shill/mock_process_manager.h"
     40 #include "shill/property_store_unittest.h"
     41 #include "shill/testing.h"
     42 
     43 using base::Bind;
     44 using base::FilePath;
     45 using base::ScopedTempDir;
     46 using base::Unretained;
     47 using std::string;
     48 using std::unique_ptr;
     49 using std::vector;
     50 using testing::_;
     51 using testing::AnyNumber;
     52 using testing::ContainsRegex;
     53 using testing::InvokeWithoutArgs;
     54 using testing::Mock;
     55 using testing::Return;
     56 using testing::SetArgumentPointee;
     57 using testing::Test;
     58 
     59 namespace shill {
     60 
     61 namespace {
     62 const char kDeviceName[] = "eth0";
     63 const char kLeaseFileSuffix[] = "leasefilesuffix";
     64 const bool kHasLeaseSuffix = true;
     65 const char kIPAddress[] = "2001:db8:0:1::1";
     66 const char kDelegatedPrefix[] = "2001:db8:0:100::";
     67 }  // namespace
     68 
     69 typedef scoped_refptr<DHCPv6Config> DHCPv6ConfigRefPtr;
     70 
     71 class DHCPv6ConfigTest : public PropertyStoreTest {
     72  public:
     73   DHCPv6ConfigTest()
     74       : proxy_(new MockDHCPProxy()),
     75         config_(new DHCPv6Config(&control_,
     76                                  dispatcher(),
     77                                  &provider_,
     78                                  kDeviceName,
     79                                  kLeaseFileSuffix)) {}
     80 
     81   virtual void SetUp() {
     82     config_->process_manager_ = &process_manager_;
     83   }
     84 
     85   bool StartInstance(DHCPv6ConfigRefPtr config) {
     86     return config->Start();
     87   }
     88 
     89   void StopInstance() {
     90     config_->Stop("In test");
     91   }
     92 
     93   DHCPv6ConfigRefPtr CreateMockMinijailConfig(const string& lease_suffix);
     94   DHCPv6ConfigRefPtr CreateRunningConfig(const string& lease_suffix);
     95   void StopRunningConfigAndExpect(DHCPv6ConfigRefPtr config,
     96                                   bool lease_file_exists);
     97 
     98  protected:
     99   static const int kPID;
    100   static const unsigned int kTag;
    101 
    102   FilePath lease_file_;
    103   FilePath pid_file_;
    104   ScopedTempDir temp_dir_;
    105   unique_ptr<MockDHCPProxy> proxy_;
    106   MockControl control_;
    107   MockProcessManager process_manager_;
    108   MockDHCPProvider provider_;
    109   DHCPv6ConfigRefPtr config_;
    110 };
    111 
    112 const int DHCPv6ConfigTest::kPID = 123456;
    113 const unsigned int DHCPv6ConfigTest::kTag = 77;
    114 
    115 DHCPv6ConfigRefPtr DHCPv6ConfigTest::CreateMockMinijailConfig(
    116     const string& lease_suffix) {
    117   DHCPv6ConfigRefPtr config(new DHCPv6Config(&control_,
    118                                              dispatcher(),
    119                                              &provider_,
    120                                              kDeviceName,
    121                                              lease_suffix));
    122   config->process_manager_ = &process_manager_;
    123 
    124   return config;
    125 }
    126 
    127 DHCPv6ConfigRefPtr DHCPv6ConfigTest::CreateRunningConfig(
    128     const string& lease_suffix) {
    129   DHCPv6ConfigRefPtr config(new DHCPv6Config(&control_,
    130                                              dispatcher(),
    131                                              &provider_,
    132                                              kDeviceName,
    133                                              lease_suffix));
    134   config->process_manager_ = &process_manager_;
    135   EXPECT_CALL(process_manager_, StartProcessInMinijail(_, _, _, _, _, _, _))
    136       .WillOnce(Return(kPID));
    137   EXPECT_CALL(provider_, BindPID(kPID, IsRefPtrTo(config)));
    138   EXPECT_TRUE(config->Start());
    139   EXPECT_EQ(kPID, config->pid_);
    140 
    141   EXPECT_TRUE(temp_dir_.CreateUniqueTempDir());
    142   config->root_ = temp_dir_.path();
    143   FilePath varrun = temp_dir_.path().Append("var/run/dhcpcd");
    144   EXPECT_TRUE(base::CreateDirectory(varrun));
    145   pid_file_ = varrun.Append(base::StringPrintf("dhcpcd-%s-6.pid", kDeviceName));
    146   FilePath varlib = temp_dir_.path().Append("var/lib/dhcpcd");
    147   EXPECT_TRUE(base::CreateDirectory(varlib));
    148   lease_file_ =
    149       varlib.Append(base::StringPrintf("dhcpcd-%s.lease6", kDeviceName));
    150   EXPECT_EQ(0, base::WriteFile(pid_file_, "", 0));
    151   EXPECT_EQ(0, base::WriteFile(lease_file_, "", 0));
    152   EXPECT_TRUE(base::PathExists(pid_file_));
    153   EXPECT_TRUE(base::PathExists(lease_file_));
    154 
    155   return config;
    156 }
    157 
    158 void DHCPv6ConfigTest::StopRunningConfigAndExpect(DHCPv6ConfigRefPtr config,
    159                                                   bool lease_file_exists) {
    160   ScopedMockLog log;
    161   // We use a non-zero exit status so that we get the log message.
    162   EXPECT_CALL(log, Log(_, _, ::testing::EndsWith("status 10")));
    163   EXPECT_CALL(provider_, UnbindPID(kPID));
    164   config->OnProcessExited(10);
    165 
    166   EXPECT_FALSE(base::PathExists(pid_file_));
    167   EXPECT_EQ(lease_file_exists, base::PathExists(lease_file_));
    168 }
    169 
    170 TEST_F(DHCPv6ConfigTest, ParseConfiguration) {
    171   const char kConfigIPAddress[] = "2001:db8:0:1::129";
    172   const char kConfigDelegatedPrefix[] = "2001:db8:1:100::";
    173   const char kConfigNameServer[] = "fec8:0::1";
    174   const char kConfigDomainSearch[] = "example.domain";
    175   const uint32_t kConfigDelegatedPrefixLength = 56;
    176   const uint32_t kConfigIPAddressLeaseTime = 5;
    177   const uint32_t kConfigDelegatedPrefixLeaseTime = 10;
    178 
    179   KeyValueStore conf;
    180   conf.SetString(DHCPv6Config::kConfigurationKeyIPAddress, kConfigIPAddress);
    181   conf.SetUint(DHCPv6Config::kConfigurationKeyIPAddressLeaseTime,
    182                kConfigIPAddressLeaseTime);
    183   conf.SetString(DHCPv6Config::kConfigurationKeyDelegatedPrefix,
    184                  kConfigDelegatedPrefix);
    185   conf.SetUint(DHCPv6Config::kConfigurationKeyDelegatedPrefixLength,
    186                kConfigDelegatedPrefixLength);
    187   conf.SetUint(DHCPv6Config::kConfigurationKeyDelegatedPrefixLeaseTime,
    188                kConfigDelegatedPrefixLeaseTime);
    189   {
    190     vector<string> dns;
    191     dns.push_back(kConfigNameServer);
    192     conf.SetStrings(DHCPv6Config::kConfigurationKeyDNS, dns);
    193   }
    194   {
    195     vector<string> domain_search;
    196     domain_search.push_back(kConfigDomainSearch);
    197     conf.SetStrings(DHCPv6Config::kConfigurationKeyDomainSearch, domain_search);
    198   }
    199   conf.SetString("UnknownKey", "UnknownValue");
    200 
    201   ASSERT_TRUE(config_->ParseConfiguration(conf));
    202   EXPECT_EQ(kConfigIPAddress, config_->properties_.address);
    203   EXPECT_EQ(kConfigDelegatedPrefix, config_->properties_.delegated_prefix);
    204   EXPECT_EQ(kConfigDelegatedPrefixLength,
    205             config_->properties_.delegated_prefix_length);
    206   ASSERT_EQ(1, config_->properties_.dns_servers.size());
    207   EXPECT_EQ(kConfigNameServer, config_->properties_.dns_servers[0]);
    208   ASSERT_EQ(1, config_->properties_.domain_search.size());
    209   EXPECT_EQ(kConfigDomainSearch, config_->properties_.domain_search[0]);
    210   // Use IP address lease time since it is shorter.
    211   EXPECT_EQ(kConfigIPAddressLeaseTime,
    212             config_->properties_.lease_duration_seconds);
    213 }
    214 
    215 MATCHER_P(IsDHCPCDv6Args, has_lease_suffix, "") {
    216   if (arg[0] != "-B" ||
    217       arg[1] != "-q" ||
    218       arg[2] != "-6" ||
    219       arg[3] != "-a") {
    220     return false;
    221   }
    222 
    223   int end_offset = 4;
    224 
    225   string device_arg = has_lease_suffix ?
    226       string(kDeviceName) + "=" + string(kLeaseFileSuffix) : kDeviceName;
    227   return arg[end_offset] == device_arg;
    228 }
    229 
    230 TEST_F(DHCPv6ConfigTest, StartDhcpcd) {
    231   EXPECT_CALL(process_manager_,
    232               StartProcessInMinijail(_, _, IsDHCPCDv6Args(kHasLeaseSuffix),
    233                                      _, _, _, _))
    234       .WillOnce(Return(-1));
    235   EXPECT_FALSE(StartInstance(config_));
    236 }
    237 
    238 
    239 namespace {
    240 
    241 class DHCPv6ConfigCallbackTest : public DHCPv6ConfigTest {
    242  public:
    243   virtual void SetUp() {
    244     DHCPv6ConfigTest::SetUp();
    245     config_->RegisterUpdateCallback(
    246         Bind(&DHCPv6ConfigCallbackTest::SuccessCallback, Unretained(this)));
    247     config_->RegisterFailureCallback(
    248         Bind(&DHCPv6ConfigCallbackTest::FailureCallback, Unretained(this)));
    249     ip_config_ = config_;
    250   }
    251 
    252   MOCK_METHOD2(SuccessCallback,
    253                void(const IPConfigRefPtr& ipconfig, bool new_lease_acquired));
    254   MOCK_METHOD1(FailureCallback, void(const IPConfigRefPtr& ipconfig));
    255 
    256   // The mock methods above take IPConfigRefPtr because this is the type
    257   // that the registered callbacks take.  This conversion of the DHCP
    258   // config ref pointer eases our work in setting up expectations.
    259   const IPConfigRefPtr& ConfigRef() { return ip_config_; }
    260 
    261  private:
    262   IPConfigRefPtr ip_config_;
    263 };
    264 
    265 }  // namespace
    266 
    267 TEST_F(DHCPv6ConfigCallbackTest, ProcessEventSignalFail) {
    268   KeyValueStore conf;
    269   conf.SetString(DHCPv6Config::kConfigurationKeyIPAddress, kIPAddress);
    270   conf.SetString(DHCPv6Config::kConfigurationKeyDelegatedPrefix,
    271                  kDelegatedPrefix);
    272   EXPECT_CALL(*this, SuccessCallback(_, _)).Times(0);
    273   EXPECT_CALL(*this, FailureCallback(ConfigRef()));
    274   config_->ProcessEventSignal(DHCPv6Config::kReasonFail, conf);
    275   Mock::VerifyAndClearExpectations(this);
    276   EXPECT_TRUE(config_->properties().address.empty());
    277 }
    278 
    279 TEST_F(DHCPv6ConfigCallbackTest, ProcessEventSignalSuccess) {
    280   for (const auto& reason : { DHCPv6Config::kReasonBound,
    281                               DHCPv6Config::kReasonRebind,
    282                               DHCPv6Config::kReasonReboot,
    283                               DHCPv6Config::kReasonRenew }) {
    284     for (const auto lease_time_given : { false, true }) {
    285       KeyValueStore conf;
    286       conf.SetString(DHCPv6Config::kConfigurationKeyIPAddress, kIPAddress);
    287       conf.SetString(DHCPv6Config::kConfigurationKeyDelegatedPrefix,
    288                      kDelegatedPrefix);
    289       if (lease_time_given) {
    290         const uint32_t kLeaseTime = 1;
    291         conf.SetUint(DHCPv6Config::kConfigurationKeyIPAddressLeaseTime,
    292                      kLeaseTime);
    293       }
    294       EXPECT_CALL(*this, SuccessCallback(ConfigRef(), true));
    295       EXPECT_CALL(*this, FailureCallback(_)).Times(0);
    296       config_->ProcessEventSignal(reason, conf);
    297       string failure_message = string(reason) + " failed with lease time " +
    298           (lease_time_given ? "given" : "not given");
    299       EXPECT_TRUE(Mock::VerifyAndClearExpectations(this)) << failure_message;
    300       EXPECT_EQ("2001:db8:0:1::1", config_->properties().address)
    301           << failure_message;
    302     }
    303   }
    304 }
    305 
    306 TEST_F(DHCPv6ConfigCallbackTest, StoppedDuringFailureCallback) {
    307   KeyValueStore conf;
    308   conf.SetString(DHCPv6Config::kConfigurationKeyIPAddress, kIPAddress);
    309   conf.SetString(DHCPv6Config::kConfigurationKeyDelegatedPrefix,
    310                  kDelegatedPrefix);
    311   // Stop the DHCP config while it is calling the failure callback.  We
    312   // need to ensure that no callbacks are left running inadvertently as
    313   // a result.
    314   EXPECT_CALL(*this, FailureCallback(ConfigRef()))
    315       .WillOnce(InvokeWithoutArgs(this, &DHCPv6ConfigTest::StopInstance));
    316   config_->ProcessEventSignal(DHCPv6Config::kReasonFail, conf);
    317   EXPECT_TRUE(Mock::VerifyAndClearExpectations(this));
    318 }
    319 
    320 TEST_F(DHCPv6ConfigCallbackTest, StoppedDuringSuccessCallback) {
    321   KeyValueStore conf;
    322   conf.SetString(DHCPv6Config::kConfigurationKeyIPAddress, kIPAddress);
    323   conf.SetString(DHCPv6Config::kConfigurationKeyDelegatedPrefix,
    324                  kDelegatedPrefix);
    325   const uint32_t kLeaseTime = 1;
    326   conf.SetUint(DHCPv6Config::kConfigurationKeyIPAddressLeaseTime, kLeaseTime);
    327   // Stop the DHCP config while it is calling the success callback.  This
    328   // can happen if the device has a static IP configuration and releases
    329   // the lease after accepting other network parameters from the DHCP
    330   // IPConfig properties.  We need to ensure that no callbacks are left
    331   // running inadvertently as a result.
    332   EXPECT_CALL(*this, SuccessCallback(ConfigRef(), true))
    333       .WillOnce(InvokeWithoutArgs(this, &DHCPv6ConfigTest::StopInstance));
    334   config_->ProcessEventSignal(DHCPv6Config::kReasonBound, conf);
    335   EXPECT_TRUE(Mock::VerifyAndClearExpectations(this));
    336 }
    337 
    338 TEST_F(DHCPv6ConfigCallbackTest, ProcessEventSignalUnknown) {
    339   KeyValueStore conf;
    340   conf.SetString(DHCPv6Config::kConfigurationKeyIPAddress, kIPAddress);
    341   conf.SetString(DHCPv6Config::kConfigurationKeyDelegatedPrefix,
    342                  kDelegatedPrefix);
    343   static const char kReasonUnknown[] = "UNKNOWN_REASON";
    344   EXPECT_CALL(*this, SuccessCallback(_, _)).Times(0);
    345   EXPECT_CALL(*this, FailureCallback(_)).Times(0);
    346   config_->ProcessEventSignal(kReasonUnknown, conf);
    347   Mock::VerifyAndClearExpectations(this);
    348   EXPECT_TRUE(config_->properties().address.empty());
    349 }
    350 
    351 TEST_F(DHCPv6ConfigTest, StartSuccessEphemeral) {
    352   DHCPv6ConfigRefPtr config =
    353       CreateRunningConfig(kDeviceName);
    354   StopRunningConfigAndExpect(config, false);
    355 }
    356 
    357 TEST_F(DHCPv6ConfigTest, StartSuccessPersistent) {
    358   DHCPv6ConfigRefPtr config =
    359       CreateRunningConfig(kLeaseFileSuffix);
    360   StopRunningConfigAndExpect(config, true);
    361 }
    362 
    363 }  // namespace shill
    364