Home | History | Annotate | Download | only in network 
      1 // Copyright 2014 The Chromium 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 "chromeos/network/host_resolver_impl_chromeos.h"
      6 
      7 #include "base/message_loop/message_loop_proxy.h"
      8 #include "base/values.h"
      9 #include "chromeos/network/device_state.h"
     10 #include "chromeos/network/network_handler.h"
     11 #include "chromeos/network/network_state.h"
     12 #include "chromeos/network/network_state_handler.h"
     13 #include "chromeos/network/network_state_handler_observer.h"
     14 #include "net/base/address_list.h"
     15 #include "net/base/net_errors.h"
     16 #include "net/base/net_util.h"
     17 #include "third_party/cros_system_api/dbus/service_constants.h"
     18 
     19 namespace chromeos {
     20 
     21 // HostResolverImplChromeOS::NetworkStateHandlerObserver
     22 //
     23 // An instance of this class is created on the NetworkHandler (UI) thread and
     24 // manages its own lifetime, destroying itself when NetworkStateHandlerObserver
     25 // ::IsShuttingDown() gets called.
     26 
     27 class HostResolverImplChromeOS::NetworkObserver
     28     : public chromeos::NetworkStateHandlerObserver {
     29  public:
     30   static void Create(
     31       const base::WeakPtr<HostResolverImplChromeOS>& resolver,
     32       scoped_refptr<base::MessageLoopProxy> resolver_message_loop,
     33       NetworkStateHandler* network_state_handler) {
     34     new NetworkObserver(resolver, resolver_message_loop, network_state_handler);
     35   }
     36 
     37   NetworkObserver(const base::WeakPtr<HostResolverImplChromeOS>& resolver,
     38                   scoped_refptr<base::MessageLoopProxy> resolver_message_loop,
     39                   NetworkStateHandler* network_state_handler)
     40       : resolver_(resolver),
     41         resolver_message_loop_(resolver_message_loop),
     42         network_state_handler_(network_state_handler),
     43         weak_ptr_factory_resolver_thread_(this) {
     44     network_state_handler_->AddObserver(this, FROM_HERE);
     45     DefaultNetworkChanged(network_state_handler_->DefaultNetwork());
     46   }
     47 
     48  private:
     49   virtual ~NetworkObserver() {
     50     network_state_handler_->RemoveObserver(this, FROM_HERE);
     51   }
     52 
     53   // NetworkStateHandlerObserver
     54   virtual void DefaultNetworkChanged(const NetworkState* network) OVERRIDE {
     55     if (!network) {
     56       DVLOG(2) << "DefaultNetworkChanged: No Network.";
     57       CallResolverSetIpAddress("", "");
     58       return;
     59     }
     60     std::string ipv4_address, ipv6_address;
     61     const DeviceState* device_state =
     62         network_state_handler_->GetDeviceState(network->device_path());
     63     if (!device_state) {
     64       LOG(ERROR) << "DefaultNetworkChanged: Network missing device: "
     65                  << network->path();
     66       CallResolverSetIpAddress("", "");
     67       return;
     68     }
     69     for (base::DictionaryValue::Iterator iter(device_state->ip_configs());
     70          !iter.IsAtEnd(); iter.Advance()) {
     71       const base::DictionaryValue* ip_config;
     72       if (!iter.value().GetAsDictionary(&ip_config)) {
     73         LOG(ERROR) << "Badly formatted IPConfigs: " << network->path();
     74         continue;
     75       }
     76       std::string method, address;
     77       if (ip_config->GetString(shill::kMethodProperty, &method) &&
     78           ip_config->GetString(shill::kAddressProperty, &address)) {
     79         if (method == shill::kTypeIPv4 || method == shill::kTypeDHCP)
     80           ipv4_address = address;
     81         else if (method == shill::kTypeIPv6 || method == shill::kTypeDHCP6)
     82           ipv6_address = address;
     83       } else {
     84         LOG(ERROR) << "DefaultNetworkChanged: IPConfigs missing properties: "
     85                    << network->path();
     86       }
     87     }
     88     DVLOG(2) << "DefaultNetworkChanged: " << network->name()
     89              << " IPv4: " << ipv4_address << " IPv6: " << ipv6_address;
     90     CallResolverSetIpAddress(ipv4_address, ipv6_address);
     91   }
     92 
     93   virtual void IsShuttingDown() OVERRIDE {
     94     delete this;
     95   }
     96 
     97   void CallResolverSetIpAddress(const std::string& ipv4_address,
     98                                 const std::string& ipv6_address) {
     99     resolver_message_loop_->PostTask(
    100         FROM_HERE,
    101         base::Bind(&NetworkObserver::SetIpAddressOnResolverThread,
    102                    weak_ptr_factory_resolver_thread_.GetWeakPtr(),
    103                    ipv4_address, ipv6_address));
    104   }
    105 
    106   void SetIpAddressOnResolverThread(const std::string& ipv4_address,
    107                                     const std::string& ipv6_address) {
    108     if (resolver_)
    109       resolver_->SetIPAddresses(ipv4_address, ipv6_address);
    110   }
    111 
    112   base::WeakPtr<HostResolverImplChromeOS> resolver_;
    113   scoped_refptr<base::MessageLoopProxy> resolver_message_loop_;
    114   NetworkStateHandler* network_state_handler_;
    115   base::WeakPtrFactory<NetworkObserver> weak_ptr_factory_resolver_thread_;
    116 
    117   DISALLOW_COPY_AND_ASSIGN(NetworkObserver);
    118 };
    119 
    120 // HostResolverImplChromeOS
    121 
    122 HostResolverImplChromeOS::HostResolverImplChromeOS(
    123     scoped_refptr<base::MessageLoopProxy> network_handler_message_loop,
    124     NetworkStateHandler* network_state_handler,
    125     const Options& options,
    126     net::NetLog* net_log)
    127     : HostResolverImpl(options, net_log),
    128       network_handler_message_loop_(network_handler_message_loop),
    129       weak_ptr_factory_(this) {
    130   network_handler_message_loop->PostTask(
    131       FROM_HERE,
    132       base::Bind(&NetworkObserver::Create,
    133                  weak_ptr_factory_.GetWeakPtr(),
    134                  base::MessageLoopProxy::current(),
    135                  network_state_handler));
    136 }
    137 
    138 HostResolverImplChromeOS::~HostResolverImplChromeOS() {
    139 }
    140 
    141 int HostResolverImplChromeOS::Resolve(const RequestInfo& info,
    142                                       net::RequestPriority priority,
    143                                       net::AddressList* addresses,
    144                                       const net::CompletionCallback& callback,
    145                                       RequestHandle* out_req,
    146                                       const net::BoundNetLog& source_net_log) {
    147   DCHECK(thread_checker_.CalledOnValidThread());
    148   if (ResolveLocalIPAddress(info, addresses))
    149     return net::OK;
    150   return net::HostResolverImpl::Resolve(
    151       info, priority, addresses, callback, out_req, source_net_log);
    152 }
    153 
    154 void HostResolverImplChromeOS::SetIPAddresses(const std::string& ipv4_address,
    155                                               const std::string& ipv6_address) {
    156   DCHECK(thread_checker_.CalledOnValidThread());
    157   ipv4_address_ = ipv4_address;
    158   ipv6_address_ = ipv6_address;
    159 }
    160 
    161 bool HostResolverImplChromeOS::ResolveLocalIPAddress(
    162     const RequestInfo& info,
    163     net::AddressList* addresses) {
    164   DCHECK(thread_checker_.CalledOnValidThread());
    165   if (!info.is_my_ip_address() || ipv4_address_.empty())
    166     return false;
    167 
    168   // Use IPConfig data for localhost address lookup.
    169   addresses->clear();
    170 
    171   if (info.address_family() != net::ADDRESS_FAMILY_IPV4 &&
    172       !ipv6_address_.empty()) {
    173     net::IPAddressNumber ipv6;
    174     if (net::ParseIPLiteralToNumber(ipv6_address_, &ipv6))
    175       addresses->push_back(net::IPEndPoint(ipv6, 0));
    176   }
    177 
    178   net::IPAddressNumber ipv4;
    179   if (net::ParseIPLiteralToNumber(ipv4_address_, &ipv4))
    180     addresses->push_back(net::IPEndPoint(ipv4, 0));
    181 
    182   DVLOG(2) << "ResolveLocalIPAddress("
    183            << static_cast<int>(info.address_family()) << "): "
    184            << addresses->size()
    185            << " IPv4: " << ipv4_address_ << " IPv6: " << ipv6_address_;
    186   addresses->SetDefaultCanonicalName();
    187   return true;
    188 }
    189 
    190 // static
    191 scoped_ptr<net::HostResolver> HostResolverImplChromeOS::CreateSystemResolver(
    192     const Options& options,
    193     net::NetLog* net_log) {
    194   return scoped_ptr<net::HostResolver>(new HostResolverImplChromeOS(
    195       NetworkHandler::Get()->message_loop(),
    196       NetworkHandler::Get()->network_state_handler(),
    197       options,
    198       net_log));
    199 }
    200 
    201 // static
    202 scoped_ptr<net::HostResolver>
    203 HostResolverImplChromeOS::CreateHostResolverForTest(
    204     scoped_refptr<base::MessageLoopProxy> network_handler_message_loop,
    205     NetworkStateHandler* network_state_handler) {
    206   Options options;
    207   return scoped_ptr<net::HostResolver>(new HostResolverImplChromeOS(
    208       network_handler_message_loop,
    209       network_state_handler,
    210       options,
    211       NULL));
    212 }
    213 
    214 }  // namespace chromeos
    215