network_util.cc revision 1320f92c476a1ad9d19dba2a48c72b75566198e9 
1// Copyright (c) 2012 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/network_util.h"
6
7#include "base/strings/string_tokenizer.h"
8#include "base/strings/string_util.h"
9#include "base/strings/stringprintf.h"
10#include "chromeos/network/network_state.h"
11#include "chromeos/network/network_state_handler.h"
12#include "chromeos/network/onc/onc_signature.h"
13#include "chromeos/network/onc/onc_translation_tables.h"
14#include "chromeos/network/onc/onc_translator.h"
15#include "third_party/cros_system_api/dbus/service_constants.h"
16
17namespace chromeos {
18
19WifiAccessPoint::WifiAccessPoint()
20    : signal_strength(0),
21      signal_to_noise(0),
22      channel(0) {
23}
24
25WifiAccessPoint::~WifiAccessPoint() {
26}
27
28CellularScanResult::CellularScanResult() {
29}
30
31CellularScanResult::~CellularScanResult() {
32}
33
34namespace network_util {
35
36std::string PrefixLengthToNetmask(int32 prefix_length) {
37  std::string netmask;
38  // Return the empty string for invalid inputs.
39  if (prefix_length < 0 || prefix_length > 32)
40    return netmask;
41  for (int i = 0; i < 4; i++) {
42    int remainder = 8;
43    if (prefix_length >= 8) {
44      prefix_length -= 8;
45    } else {
46      remainder = prefix_length;
47      prefix_length = 0;
48    }
49    if (i > 0)
50      netmask += ".";
51    int value = remainder == 0 ? 0 :
52        ((2L << (remainder - 1)) - 1) << (8 - remainder);
53    netmask += base::StringPrintf("%d", value);
54  }
55  return netmask;
56}
57
58int32 NetmaskToPrefixLength(const std::string& netmask) {
59  int count = 0;
60  int prefix_length = 0;
61  base::StringTokenizer t(netmask, ".");
62  while (t.GetNext()) {
63    // If there are more than 4 numbers, then it's invalid.
64    if (count == 4)
65      return -1;
66
67    std::string token = t.token();
68    // If we already found the last mask and the current one is not
69    // "0" then the netmask is invalid. For example, 255.224.255.0
70    if (prefix_length / 8 != count) {
71      if (token != "0")
72        return -1;
73    } else if (token == "255") {
74      prefix_length += 8;
75    } else if (token == "254") {
76      prefix_length += 7;
77    } else if (token == "252") {
78      prefix_length += 6;
79    } else if (token == "248") {
80      prefix_length += 5;
81    } else if (token == "240") {
82      prefix_length += 4;
83    } else if (token == "224") {
84      prefix_length += 3;
85    } else if (token == "192") {
86      prefix_length += 2;
87    } else if (token == "128") {
88      prefix_length += 1;
89    } else if (token == "0") {
90      prefix_length += 0;
91    } else {
92      // mask is not a valid number.
93      return -1;
94    }
95    count++;
96  }
97  if (count < 4)
98    return -1;
99  return prefix_length;
100}
101
102std::string FormattedMacAddress(const std::string& shill_mac_address) {
103  if (shill_mac_address.size() % 2 != 0)
104    return shill_mac_address;
105  std::string result;
106  for (size_t i = 0; i < shill_mac_address.size(); ++i) {
107    if ((i != 0) && (i % 2 == 0))
108      result.push_back(':');
109    result.push_back(base::ToUpperASCII(shill_mac_address[i]));
110  }
111  return result;
112}
113
114bool ParseCellularScanResults(const base::ListValue& list,
115                              std::vector<CellularScanResult>* scan_results) {
116  scan_results->clear();
117  scan_results->reserve(list.GetSize());
118  for (base::ListValue::const_iterator it = list.begin();
119       it != list.end(); ++it) {
120    if (!(*it)->IsType(base::Value::TYPE_DICTIONARY))
121      return false;
122    CellularScanResult scan_result;
123    const base::DictionaryValue* dict =
124        static_cast<const base::DictionaryValue*>(*it);
125    // If the network id property is not present then this network cannot be
126    // connected to so don't include it in the results.
127    if (!dict->GetStringWithoutPathExpansion(shill::kNetworkIdProperty,
128                                             &scan_result.network_id))
129      continue;
130    dict->GetStringWithoutPathExpansion(shill::kStatusProperty,
131                                        &scan_result.status);
132    dict->GetStringWithoutPathExpansion(shill::kLongNameProperty,
133                                        &scan_result.long_name);
134    dict->GetStringWithoutPathExpansion(shill::kShortNameProperty,
135                                        &scan_result.short_name);
136    dict->GetStringWithoutPathExpansion(shill::kTechnologyProperty,
137                                        &scan_result.technology);
138    scan_results->push_back(scan_result);
139  }
140  return true;
141}
142
143scoped_ptr<base::DictionaryValue> TranslateNetworkStateToONC(
144    const NetworkState* network) {
145  // Get the properties from the NetworkState.
146  base::DictionaryValue shill_dictionary;
147  network->GetStateProperties(&shill_dictionary);
148
149  scoped_ptr<base::DictionaryValue> onc_dictionary =
150      TranslateShillServiceToONCPart(shill_dictionary,
151                                     ::onc::ONC_SOURCE_UNKNOWN,
152                                     &onc::kNetworkWithStateSignature);
153  return onc_dictionary.Pass();
154}
155
156scoped_ptr<base::ListValue> TranslateNetworkListToONC(
157    NetworkTypePattern pattern,
158    bool configured_only,
159    bool visible_only,
160    int limit,
161    bool debugging_properties) {
162  NetworkStateHandler::NetworkStateList network_states;
163  NetworkHandler::Get()->network_state_handler()->GetNetworkListByType(
164      pattern, configured_only, visible_only, limit, &network_states);
165
166  scoped_ptr<base::ListValue> network_properties_list(new base::ListValue);
167  for (NetworkStateHandler::NetworkStateList::iterator it =
168           network_states.begin();
169       it != network_states.end();
170       ++it) {
171    scoped_ptr<base::DictionaryValue> onc_dictionary =
172        TranslateNetworkStateToONC(*it);
173
174    if (debugging_properties) {
175      onc_dictionary->SetBoolean("connectable", (*it)->connectable());
176      onc_dictionary->SetBoolean("visible", (*it)->visible());
177      onc_dictionary->SetString("profile_path", (*it)->profile_path());
178      onc_dictionary->SetString("service_path", (*it)->path());
179    }
180
181    network_properties_list->Append(onc_dictionary.release());
182  }
183  return network_properties_list.Pass();
184}
185
186std::string TranslateONCTypeToShill(const std::string& onc_type) {
187  if (onc_type == ::onc::network_type::kEthernet)
188    return shill::kTypeEthernet;
189  std::string shill_type;
190  onc::TranslateStringToShill(onc::kNetworkTypeTable, onc_type, &shill_type);
191  return shill_type;
192}
193
194}  // namespace network_util
195}  // namespace chromeos
196