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