components/wifi/network_properties.cc

   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 "components/wifi/network_properties.h"
   6
   7 #include "base/json/json_reader.h"
   8 #include "base/message_loop/message_loop.h"
   9 #include "base/strings/string_number_conversions.h"
  10 #include "base/strings/stringprintf.h"
  11 #include "components/onc/onc_constants.h"
  12
  13 namespace wifi {
  14
  15 NetworkProperties::NetworkProperties()
  16     : connection_state(onc::connection_state::kNotConnected),
  17       security(onc::wifi::kSecurityNone),
  18       signal_strength(0),
  19       auto_connect(false),
  20       frequency(kFrequencyUnknown) {
  21 }
  22
  23 NetworkProperties::~NetworkProperties() {
  24 }
  25
  26 scoped_ptr<base::DictionaryValue> NetworkProperties::ToValue(
  27     bool network_list) const {
  28   scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
  29
  30   value->SetString(onc::network_config::kGUID, guid);
  31   value->SetString(onc::network_config::kName, name);
  32   value->SetString(onc::network_config::kConnectionState, connection_state);
  33   DCHECK(type == onc::network_type::kWiFi);
  34   value->SetString(onc::network_config::kType, type);
  35
  36   // For now, assume all WiFi services are connectable.
  37   value->SetBoolean(onc::network_config::kConnectable, true);
  38
  39   scoped_ptr<base::DictionaryValue> wifi(new base::DictionaryValue());
  40   wifi->SetString(onc::wifi::kSecurity, security);
  41   wifi->SetInteger(onc::wifi::kSignalStrength, signal_strength);
  42
  43   // Network list expects subset of data.
  44   if (!network_list) {
  45     if (frequency != kFrequencyUnknown)
  46       wifi->SetInteger(onc::wifi::kFrequency, frequency);
  47     scoped_ptr<base::ListValue> frequency_list(new base::ListValue());
  48     for (FrequencySet::const_iterator it = this->frequency_set.begin();
  49          it != this->frequency_set.end();
  50          ++it) {
  51       frequency_list->AppendInteger(*it);
  52     }
  53     if (!frequency_list->empty())
  54       wifi->Set(onc::wifi::kFrequencyList, frequency_list.release());
  55     if (!bssid.empty())
  56       wifi->SetString(onc::wifi::kBSSID, bssid);
  57     wifi->SetString(onc::wifi::kSSID, ssid);
  58     wifi->SetString(onc::wifi::kHexSSID,
  59                     base::HexEncode(ssid.c_str(), ssid.size()));
  60   }
  61   value->Set(onc::network_type::kWiFi, wifi.release());
  62
  63   if (!network_list && !json_extra.empty()) {
  64     base::Value* value_extra = base::JSONReader::Read(json_extra);
  65     CHECK(value_extra);
  66     base::DictionaryValue* value_dictionary;
  67     if (value_extra->GetAsDictionary(&value_dictionary))
  68       value->MergeDictionary(value_dictionary);
  69   }
  70
  71   return value.Pass();
  72 }
  73
  74 bool NetworkProperties::UpdateFromValue(const base::DictionaryValue& value) {
  75   const base::DictionaryValue* wifi = NULL;
  76   std::string network_type;
  77   // Get network type and make sure that it is WiFi (if specified).
  78   if (value.GetString(onc::network_config::kType, &network_type)) {
  79     if (network_type != onc::network_type::kWiFi)
  80       return false;
  81     type = network_type;
  82   }
  83   if (value.GetDictionary(onc::network_type::kWiFi, &wifi)) {
  84     value.GetString(onc::network_config::kName, &name);
  85     value.GetString(onc::network_config::kGUID, &guid);
  86     value.GetString(onc::network_config::kConnectionState, &connection_state);
  87     wifi->GetString(onc::wifi::kSecurity, &security);
  88     wifi->GetString(onc::wifi::kSSID, &ssid);
  89     wifi->GetString(onc::wifi::kPassphrase, &password);
  90     wifi->GetBoolean(onc::wifi::kAutoConnect, &auto_connect);
  91     return true;
  92   }
  93   return false;
  94 }
  95
  96 std::string NetworkProperties::MacAddressAsString(const uint8 mac_as_int[6]) {
  97   // mac_as_int is big-endian. Write in byte chunks.
  98   // Format is XX:XX:XX:XX:XX:XX.
  99   static const char* const kMacFormatString = "%02x:%02x:%02x:%02x:%02x:%02x";
 100   return base::StringPrintf(kMacFormatString,
 101                             mac_as_int[0],
 102                             mac_as_int[1],
 103                             mac_as_int[2],
 104                             mac_as_int[3],
 105                             mac_as_int[4],
 106                             mac_as_int[5]);
 107 }
 108
 109 bool NetworkProperties::OrderByType(const NetworkProperties& l,
 110                                     const NetworkProperties& r) {
 111   if (l.connection_state != r.connection_state)
 112     return l.connection_state < r.connection_state;
 113   // This sorting order is needed only for browser_tests, which expect this
 114   // network type sort order: ethernet < wifi < vpn < cellular.
 115   if (l.type == r.type)
 116     return l.guid < r.guid;
 117   if (l.type == onc::network_type::kEthernet)
 118     return true;
 119   if (r.type == onc::network_type::kEthernet)
 120     return false;
 121   return l.type > r.type;
 122 }
 123
 124 }  // namespace wifi