Google Git
Sign in
android / platform / external / chromium_org / 0a1b11dee8e5cb2520121c300858fea6138e3c54 / . / chrome / browser / chromeos / cros / network_library.cc
blob: 0a709fde01e5488413f2850d435459b0fc0d2953 [file] [log] [blame]
// Copyright (c) 2012 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 "chrome/browser/chromeos/cros/network_library.h"
#include "base/chromeos/chromeos_version.h"
#include "base/i18n/icu_encoding_detection.h"
#include "base/i18n/icu_string_conversions.h"
#include "base/i18n/time_formatting.h"
#include "base/json/json_writer.h" // for debug output only.
#include "base/strings/string_number_conversions.h"
#include "base/strings/utf_string_conversion_utils.h"
#include "chrome/browser/chromeos/cros/native_network_constants.h"
#include "chrome/browser/chromeos/cros/native_network_parser.h"
#include "chrome/browser/chromeos/cros/network_library_impl_cros.h"
#include "chrome/browser/chromeos/cros/network_library_impl_stub.h"
#include "chrome/browser/chromeos/enrollment_dialog_view.h"
#include "chrome/common/net/x509_certificate_model.h"
#include "chromeos/network/certificate_pattern.h"
#include "chromeos/network/client_cert_util.h"
#include "chromeos/network/cros_network_functions.h"
#include "chromeos/network/network_state_handler.h"
#include "chromeos/network/onc/onc_utils.h"
#include "content/public/browser/browser_thread.h"
#include "grit/ash_strings.h"
#include "grit/generated_resources.h"
#include "net/base/url_util.h"
#include "third_party/cros_system_api/dbus/service_constants.h"
#include "ui/base/l10n/l10n_util.h"
using content::BrowserThread;
////////////////////////////////////////////////////////////////////////////////
// Implementation notes.
// NetworkLibraryImpl manages a series of classes that describe network devices
// and services:
//
// NetworkDevice: e.g. ethernet, wifi modem, cellular modem
// device_map_: canonical map<path, NetworkDevice*> for devices
//
// Network: a network service ("network").
// network_map_: canonical map<path, Network*> for all visible networks.
// EthernetNetwork
// ethernet_: EthernetNetwork* to the active ethernet network in network_map_.
// WirelessNetwork: a WiFi or Cellular Network.
// WifiNetwork
// active_wifi_: WifiNetwork* to the active wifi network in network_map_.
// wifi_networks_: ordered vector of WifiNetwork* entries in network_map_,
// in descending order of importance.
// CellularNetwork
// active_cellular_: Cellular version of wifi_.
// cellular_networks_: Cellular version of wifi_.
// network_unique_id_map_: map<unique_id, Network*> for all visible networks.
// remembered_network_map_: a canonical map<path, Network*> for all networks
// remembered in the active Profile ("favorites").
// remembered_network_unique_id_map_: map<unique_id, Network*> for all
// remembered networks.
// remembered_wifi_networks_: ordered vector of WifiNetwork* entries in
// remembered_network_map_, in descending order of preference.
// remembered_virtual_networks_: ordered vector of VirtualNetwork* entries in
// remembered_network_map_, in descending order of preference.
//
// network_manager_monitor_: a handle to the libcros network Manager handler.
// NetworkManagerStatusChanged: This handles all messages from the Manager.
// Messages are parsed here and the appropriate updates are then requested.
//
// UpdateNetworkServiceList: This is the primary Manager handler. It handles
// the "Services" message which list all visible networks. The handler
// rebuilds the network lists without destroying existing Network structures,
// then requests neccessary updates to be fetched asynchronously from
// libcros (RequestNetworkServiceProperties).
//
// TODO(stevenjb): Document cellular data plan handlers.
//
// AddNetworkObserver: Adds an observer for a specific network.
// UpdateNetworkStatus: This handles changes to a monitored service, typically
// changes to transient states like Strength. (Note: also updates State).
//
// AddNetworkDeviceObserver: Adds an observer for a specific device.
// Will be called on any device property change.
// UpdateNetworkDeviceStatus: Handles changes to a monitored device, like
// SIM lock state and updates device state.
//
// All *Pin(...) methods use internal callback that would update cellular
// device state once async call is completed and notify all device observers.
//
////////////////////////////////////////////////////////////////////////////////
namespace chromeos {
namespace {
static NetworkLibrary* g_network_library = NULL;
// Default value of the SIM unlock retries count. It is updated to the real
// retries count once cellular device with SIM card is initialized.
// If cellular device doesn't have SIM card, then retries are never used.
const int kDefaultSimUnlockRetriesCount = 999;
////////////////////////////////////////////////////////////////////////////////
// Misc.
// Erase the memory used by a string, then clear it.
void WipeString(std::string* str) {
str->assign(str->size(), '\0');
str->clear();
}
bool EnsureRunningOnChromeOS() {
if (!base::chromeos::IsRunningOnChromeOS()) {
return false;
} else {
CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI))
<< "chromeos_network calls made from non UI thread!";
return true;
}
}
void ValidateUTF8(const std::string& str, std::string* output) {
output->clear();
for (int32 index = 0; index < static_cast<int32>(str.size()); ++index) {
uint32 code_point_out;
bool is_unicode_char = base::ReadUnicodeCharacter(str.c_str(), str.size(),
&index, &code_point_out);
if (is_unicode_char && (code_point_out >= 0x20))
base::WriteUnicodeCharacter(code_point_out, output);
else
// Puts REPLACEMENT CHARACTER (U+FFFD) if character is not readable UTF-8
base::WriteUnicodeCharacter(0xFFFD, output);
}
}
std::string ConnectionStateString(ConnectionState state) {
switch (state) {
case STATE_UNKNOWN:
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_STATE_UNKNOWN);
case STATE_IDLE:
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_STATE_IDLE);
case STATE_CARRIER:
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_STATE_CARRIER);
case STATE_ASSOCIATION:
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_STATE_ASSOCIATION);
case STATE_CONFIGURATION:
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_STATE_CONFIGURATION);
case STATE_READY:
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_STATE_READY);
case STATE_DISCONNECT:
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_STATE_DISCONNECT);
case STATE_FAILURE:
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_STATE_FAILURE);
case STATE_ACTIVATION_FAILURE:
return l10n_util::GetStringUTF8(
IDS_CHROMEOS_NETWORK_STATE_ACTIVATION_FAILURE);
case STATE_PORTAL:
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_STATE_PORTAL);
case STATE_ONLINE:
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_STATE_ONLINE);
case STATE_CONNECT_REQUESTED:
return l10n_util::GetStringUTF8(
IDS_CHROMEOS_NETWORK_STATE_CONNECT_REQUESTED);
}
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_STATE_UNRECOGNIZED);
}
} // namespace
////////////////////////////////////////////////////////////////////////////////
// FoundCellularNetwork
FoundCellularNetwork::FoundCellularNetwork() {}
FoundCellularNetwork::~FoundCellularNetwork() {}
////////////////////////////////////////////////////////////////////////////////
// NetworkDevice
NetworkDevice::NetworkDevice(const std::string& device_path)
: device_path_(device_path),
type_(TYPE_UNKNOWN),
scanning_(false),
sim_lock_state_(SIM_UNKNOWN),
sim_retries_left_(kDefaultSimUnlockRetriesCount),
sim_pin_required_(SIM_PIN_REQUIRE_UNKNOWN),
sim_present_(false),
powered_(false),
prl_version_(0),
data_roaming_allowed_(false),
support_network_scan_(false),
device_parser_(new NativeNetworkDeviceParser) {
}
NetworkDevice::~NetworkDevice() {}
void NetworkDevice::SetNetworkDeviceParser(NetworkDeviceParser* parser) {
device_parser_.reset(parser);
}
void NetworkDevice::ParseInfo(const DictionaryValue& info) {
if (device_parser_.get())
device_parser_->UpdateDeviceFromInfo(info, this);
}
bool NetworkDevice::UpdateStatus(const std::string& key,
const base::Value& value,
PropertyIndex* index) {
if (device_parser_.get())
return device_parser_->UpdateStatus(key, value, this, index);
return false;
}
////////////////////////////////////////////////////////////////////////////////
// Network
Network::Network(const std::string& service_path,
ConnectionType type)
: state_(STATE_UNKNOWN),
error_(ERROR_NO_ERROR),
connectable_(true),
user_connect_state_(USER_CONNECT_NONE),
is_active_(false),
priority_(kPriorityNotSet),
auto_connect_(false),
save_credentials_(false),
priority_order_(0),
added_(false),
notify_failure_(false),
profile_type_(PROFILE_NONE),
service_path_(service_path),
type_(type) {
}
Network::~Network() {
}
void Network::SetNetworkParser(NetworkParser* parser) {
network_parser_.reset(parser);
}
// static
Network* Network::CreateForTesting(ConnectionType type) {
return new Network("fake_service_path", type);
}
void Network::SetState(ConnectionState new_state) {
if (new_state == state_)
return;
if (state_ == STATE_CONNECT_REQUESTED && new_state == STATE_IDLE) {
// CONNECT_REQUESTED is set internally. Shill does not update the
// state immediately, so ignore any Idle state updates sent while a
// connection attempt is in progress.
VLOG(2) << "Ignoring idle state change after connection request.";
return;
}
ConnectionState old_state = state_;
VLOG(2) << "Entering new state: " << ConnectionStateString(new_state);
state_ = new_state;
if (new_state == STATE_FAILURE) {
VLOG(1) << service_path() << ": Detected Failure state.";
if (old_state != STATE_UNKNOWN && old_state != STATE_IDLE &&
(type() != TYPE_CELLULAR ||
user_connect_state() == USER_CONNECT_STARTED)) {
// New failure, the user needs to be notified.
// Transition STATE_IDLE -> STATE_FAILURE sometimes happens on resume
// but is not an actual failure as network device is not ready yet.
// For Cellular we only show failure notifications if user initiated.
notify_failure_ = true;
// Normally error_ should be set, but if it is not we need to set it to
// something here so that the retry logic will be triggered.
if (error_ == ERROR_NO_ERROR) {
VLOG(2) << "Detected NO_ERROR error state. Setting to UNKNOWN.";
error_ = ERROR_UNKNOWN;
}
}
if (user_connect_state() == USER_CONNECT_STARTED)
set_user_connect_state(USER_CONNECT_FAILED);
} else if (new_state == STATE_IDLE && IsConnectingState(old_state) &&
user_connect_state() == USER_CONNECT_STARTED) {
// If we requested a connect and never went through a connected state,
// treat it as a failure.
VLOG(1) << service_path() << ": Inferring Failure state.";
notify_failure_ = true;
error_ = ERROR_UNKNOWN;
if (user_connect_state() == USER_CONNECT_STARTED)
set_user_connect_state(USER_CONNECT_FAILED);
} else if (new_state != STATE_UNKNOWN) {
notify_failure_ = false;
// State changed, so refresh IP address.
InitIPAddress();
if (user_connect_state() == USER_CONNECT_STARTED) {
if (IsConnectedState(new_state)) {
set_user_connect_state(USER_CONNECT_CONNECTED);
} else if (!IsConnectingState(new_state)) {
LOG(WARNING) << "Connection started and State -> " << GetStateString();
set_user_connect_state(USER_CONNECT_FAILED);
}
}
}
VLOG(1) << name() << ".State [" << service_path() << "]: " << GetStateString()
<< " (was: " << ConnectionStateString(old_state) << ")";
}
void Network::SetError(ConnectionError error) {
error_ = error;
if (error == ERROR_NO_ERROR)
notify_failure_ = false;
}
void Network::SetName(const std::string& name) {
std::string name_utf8;
ValidateUTF8(name, &name_utf8);
set_name(name_utf8);
}
void Network::ParseInfo(const DictionaryValue& info) {
if (network_parser_.get())
network_parser_->UpdateNetworkFromInfo(info, this);
}
void Network::EraseCredentials() {
}
void Network::CalculateUniqueId() {
unique_id_ = name_;
}
bool Network::RequiresUserProfile() const {
return false;
}
void Network::CopyCredentialsFromRemembered(Network* remembered) {
}
void Network::SetEnrollmentDelegate(EnrollmentDelegate* delegate) {
enrollment_delegate_.reset(delegate);
}
void Network::SetValueProperty(const char* prop, const base::Value& value) {
DCHECK(prop);
if (!EnsureRunningOnChromeOS())
return;
CrosSetNetworkServiceProperty(service_path_, prop, value);
// Ensure NetworkStateHandler properties are up-to-date.
if (NetworkHandler::IsInitialized()) {
NetworkHandler::Get()->network_state_handler()->RequestUpdateForNetwork(
service_path());
}
}
void Network::ClearProperty(const char* prop) {
DCHECK(prop);
if (!EnsureRunningOnChromeOS())
return;
CrosClearNetworkServiceProperty(service_path_, prop);
// Ensure NetworkStateHandler properties are up-to-date.
if (NetworkHandler::IsInitialized()) {
NetworkHandler::Get()->network_state_handler()->RequestUpdateForNetwork(
service_path());
}
}
void Network::SetStringProperty(
const char* prop, const std::string& str, std::string* dest) {
if (dest)
*dest = str;
SetValueProperty(prop, base::StringValue(str));
}
void Network::SetOrClearStringProperty(const char* prop,
const std::string& str,
std::string* dest) {
if (str.empty()) {
ClearProperty(prop);
if (dest)
dest->clear();
} else {
SetStringProperty(prop, str, dest);
}
}
void Network::SetBooleanProperty(const char* prop, bool b, bool* dest) {
if (dest)
*dest = b;
SetValueProperty(prop, base::FundamentalValue(b));
}
void Network::SetIntegerProperty(const char* prop, int i, int* dest) {
if (dest)
*dest = i;
SetValueProperty(prop, base::FundamentalValue(i));
}
void Network::SetPreferred(bool preferred) {
if (preferred) {
SetIntegerProperty(
flimflam::kPriorityProperty, kPriorityPreferred, &priority_);
} else {
ClearProperty(flimflam::kPriorityProperty);
priority_ = kPriorityNotSet;
}
}
void Network::SetAutoConnect(bool auto_connect) {
SetBooleanProperty(
flimflam::kAutoConnectProperty, auto_connect, &auto_connect_);
}
void Network::SetSaveCredentials(bool save_credentials) {
SetBooleanProperty(
flimflam::kSaveCredentialsProperty, save_credentials, &save_credentials_);
}
void Network::ClearUIData() {
ui_data_ = NetworkUIData();
ClearProperty(flimflam::kUIDataProperty);
}
void Network::AttemptConnection(const base::Closure& closure) {
// By default, just invoke the closure right away. Some subclasses
// (Wifi, VPN, etc.) override to do more work.
closure.Run();
}
void Network::set_connecting() {
state_ = STATE_CONNECT_REQUESTED;
}
void Network::SetProfilePath(const std::string& profile_path) {
VLOG(1) << "Setting profile for: " << name_ << " to: " << profile_path;
SetOrClearStringProperty(
flimflam::kProfileProperty, profile_path, &profile_path_);
}
std::string Network::GetStateString() const {
return ConnectionStateString(state_);
}
std::string Network::GetErrorString() const {
switch (error_) {
case ERROR_NO_ERROR:
// TODO(nkostylev): Introduce new error message "None" instead.
return std::string();
case ERROR_OUT_OF_RANGE:
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_ERROR_OUT_OF_RANGE);
case ERROR_PIN_MISSING:
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_ERROR_PIN_MISSING);
case ERROR_DHCP_FAILED:
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_ERROR_DHCP_FAILED);
case ERROR_CONNECT_FAILED:
return l10n_util::GetStringUTF8(
IDS_CHROMEOS_NETWORK_ERROR_CONNECT_FAILED);
case ERROR_BAD_PASSPHRASE:
return l10n_util::GetStringUTF8(
IDS_CHROMEOS_NETWORK_ERROR_BAD_PASSPHRASE);
case ERROR_BAD_WEPKEY:
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_ERROR_BAD_WEPKEY);
case ERROR_ACTIVATION_FAILED:
return l10n_util::GetStringUTF8(
IDS_CHROMEOS_NETWORK_ERROR_ACTIVATION_FAILED);
case ERROR_NEED_EVDO:
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_ERROR_NEED_EVDO);
case ERROR_NEED_HOME_NETWORK:
return l10n_util::GetStringUTF8(
IDS_CHROMEOS_NETWORK_ERROR_NEED_HOME_NETWORK);
case ERROR_OTASP_FAILED:
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_ERROR_OTASP_FAILED);
case ERROR_AAA_FAILED:
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_ERROR_AAA_FAILED);
case ERROR_INTERNAL:
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_ERROR_INTERNAL);
case ERROR_DNS_LOOKUP_FAILED:
return l10n_util::GetStringUTF8(
IDS_CHROMEOS_NETWORK_ERROR_DNS_LOOKUP_FAILED);
case ERROR_HTTP_GET_FAILED:
return l10n_util::GetStringUTF8(
IDS_CHROMEOS_NETWORK_ERROR_HTTP_GET_FAILED);
case ERROR_IPSEC_PSK_AUTH_FAILED:
return l10n_util::GetStringUTF8(
IDS_CHROMEOS_NETWORK_ERROR_IPSEC_PSK_AUTH_FAILED);
case ERROR_IPSEC_CERT_AUTH_FAILED:
return l10n_util::GetStringUTF8(
IDS_CHROMEOS_NETWORK_ERROR_CERT_AUTH_FAILED);
case ERROR_PPP_AUTH_FAILED:
case ERROR_EAP_AUTHENTICATION_FAILED:
case ERROR_EAP_LOCAL_TLS_FAILED:
case ERROR_EAP_REMOTE_TLS_FAILED:
return l10n_util::GetStringUTF8(
IDS_CHROMEOS_NETWORK_ERROR_PPP_AUTH_FAILED);
case ERROR_UNKNOWN:
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_ERROR_UNKNOWN);
}
return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_STATE_UNRECOGNIZED);
}
void Network::InitIPAddress() {
ip_address_.clear();
if (!EnsureRunningOnChromeOS())
return;
// If connected, get IPConfig.
if (connected() && !device_path_.empty()) {
CrosListIPConfigs(device_path_,
base::Bind(&Network::InitIPAddressCallback,
service_path_));
}
}
// static
void Network::InitIPAddressCallback(
const std::string& service_path,
const NetworkIPConfigVector& ip_configs,
const std::string& hardware_address) {
Network* network =
NetworkLibrary::Get()->FindNetworkByPath(service_path);
if (!network)
return;
for (size_t i = 0; i < ip_configs.size(); ++i) {
const NetworkIPConfig& ipconfig = ip_configs[i];
if (ipconfig.address.size() > 0) {
network->ip_address_ = ipconfig.address;
break;
}
}
}
bool Network::UpdateStatus(const std::string& key,
const Value& value,
PropertyIndex* index) {
if (network_parser_.get())
return network_parser_->UpdateStatus(key, value, this, index);
return false;
}
////////////////////////////////////////////////////////////////////////////////
// EthernetNetwork
EthernetNetwork::EthernetNetwork(const std::string& service_path)
: Network(service_path, TYPE_ETHERNET) {
}
////////////////////////////////////////////////////////////////////////////////
// VirtualNetwork
VirtualNetwork::VirtualNetwork(const std::string& service_path)
: Network(service_path, TYPE_VPN),
provider_type_(PROVIDER_TYPE_L2TP_IPSEC_PSK),
// Assume PSK and user passphrase are not available initially
psk_passphrase_required_(true),
user_passphrase_required_(true),
weak_pointer_factory_(this) {
}
VirtualNetwork::~VirtualNetwork() {}
void VirtualNetwork::EraseCredentials() {
WipeString(&ca_cert_pem_);
WipeString(&psk_passphrase_);
WipeString(&client_cert_id_);
WipeString(&user_passphrase_);
}
void VirtualNetwork::CalculateUniqueId() {
std::string provider_type(ProviderTypeToString(provider_type_));
set_unique_id(provider_type + "|" + server_hostname_);
}
bool VirtualNetwork::RequiresUserProfile() const {
return true;
}
void VirtualNetwork::AttemptConnection(const base::Closure& connect) {
if (client_cert_type() == CLIENT_CERT_TYPE_PATTERN) {
MatchCertificatePattern(true, connect);
} else {
connect.Run();
}
}
void VirtualNetwork::CopyCredentialsFromRemembered(Network* remembered) {
CHECK_EQ(remembered->type(), TYPE_VPN);
VirtualNetwork* remembered_vpn = static_cast<VirtualNetwork*>(remembered);
VLOG(1) << "Copy VPN credentials: " << name()
<< " username: " << remembered_vpn->username();
if (ca_cert_pem_.empty())
ca_cert_pem_ = remembered_vpn->ca_cert_pem();
if (psk_passphrase_.empty())
psk_passphrase_ = remembered_vpn->psk_passphrase();
if (client_cert_id_.empty())
client_cert_id_ = remembered_vpn->client_cert_id();
if (username_.empty())
username_ = remembered_vpn->username();
if (user_passphrase_.empty())
user_passphrase_ = remembered_vpn->user_passphrase();
}
bool VirtualNetwork::NeedMoreInfoToConnect() const {
if (server_hostname_.empty()) {
VLOG(1) << "server_hostname_.empty()";
return true;
}
if (username_.empty()) {
VLOG(1) << "username_.empty()";
return true;
}
if (IsUserPassphraseRequired()) {
VLOG(1) << "User Passphrase Required";
return true;
}
if (error() != ERROR_NO_ERROR) {
VLOG(1) << "Error: " << error();
return true;
}
switch (provider_type_) {
case PROVIDER_TYPE_L2TP_IPSEC_PSK:
if (IsPSKPassphraseRequired()) {
VLOG(1) << "PSK Passphrase Required";
return true;
}
break;
case PROVIDER_TYPE_L2TP_IPSEC_USER_CERT:
if (client_cert_id_.empty() &&
client_cert_type() != CLIENT_CERT_TYPE_PATTERN) {
VLOG(1) << "Certificate Required";
return true;
}
break;
case PROVIDER_TYPE_OPEN_VPN:
if (client_cert_id_.empty()) {
VLOG(1) << "client_cert_id_.empty()";
return true;
}
// For now we always need additional info for OpenVPN.
// TODO(stevenjb): Check connectable() once shill sets that state
// properly, or define another mechanism to determine when additional
// credentials are required.
VLOG(1) << "OpenVPN requires credentials, connectable: "
<< connectable();
return true;
break;
case PROVIDER_TYPE_MAX:
NOTREACHED();
break;
}
return false;
}
std::string VirtualNetwork::GetProviderTypeString() const {
switch (provider_type_) {
case PROVIDER_TYPE_L2TP_IPSEC_PSK:
return l10n_util::GetStringUTF8(
IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_L2TP_IPSEC_PSK);
break;
case PROVIDER_TYPE_L2TP_IPSEC_USER_CERT:
return l10n_util::GetStringUTF8(
IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_L2TP_IPSEC_USER_CERT);
break;
case PROVIDER_TYPE_OPEN_VPN:
return l10n_util::GetStringUTF8(
IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_OPEN_VPN);
break;
default:
return l10n_util::GetStringUTF8(
IDS_CHROMEOS_NETWORK_ERROR_UNKNOWN);
break;
}
}
bool VirtualNetwork::IsPSKPassphraseRequired() const {
return psk_passphrase_required_ && psk_passphrase_.empty();
}
bool VirtualNetwork::IsUserPassphraseRequired() const {
return user_passphrase_required_ && user_passphrase_.empty();
}
void VirtualNetwork::SetCACertPEM(const std::string& ca_cert_pem) {
VLOG(1) << "SetCACertPEM " << ca_cert_pem;
if (provider_type_ == PROVIDER_TYPE_OPEN_VPN) {
ca_cert_pem_ = ca_cert_pem;
base::ListValue pem_list;
pem_list.AppendString(ca_cert_pem_);
SetValueProperty(shill::kOpenVPNCaCertPemProperty, pem_list);
} else {
SetStringProperty(
shill::kL2tpIpsecCaCertPemProperty, ca_cert_pem, &ca_cert_pem_);
}
}
void VirtualNetwork::SetL2TPIPsecPSKCredentials(
const std::string& psk_passphrase,
const std::string& username,
const std::string& user_passphrase,
const std::string& group_name) {
if (!psk_passphrase.empty()) {
SetStringProperty(flimflam::kL2tpIpsecPskProperty,
psk_passphrase, &psk_passphrase_);
}
SetStringProperty(flimflam::kL2tpIpsecUserProperty, username, &username_);
if (!user_passphrase.empty()) {
SetStringProperty(flimflam::kL2tpIpsecPasswordProperty,
user_passphrase, &user_passphrase_);
}
SetStringProperty(shill::kL2tpIpsecTunnelGroupProperty,
group_name, &group_name_);
}
void VirtualNetwork::SetL2TPIPsecCertCredentials(
const std::string& client_cert_id,
const std::string& username,
const std::string& user_passphrase,
const std::string& group_name) {
SetStringProperty(flimflam::kL2tpIpsecClientCertIdProperty,
client_cert_id, &client_cert_id_);
SetStringProperty(flimflam::kL2tpIpsecUserProperty, username, &username_);
if (!user_passphrase.empty()) {
SetStringProperty(flimflam::kL2tpIpsecPasswordProperty,
user_passphrase, &user_passphrase_);
}
SetStringProperty(shill::kL2tpIpsecTunnelGroupProperty,
group_name, &group_name_);
}
void VirtualNetwork::SetOpenVPNCredentials(
const std::string& client_cert_id,
const std::string& username,
const std::string& user_passphrase,
const std::string& otp) {
SetStringProperty(flimflam::kOpenVPNClientCertIdProperty,
client_cert_id, &client_cert_id_);
SetStringProperty(flimflam::kOpenVPNUserProperty, username, &username_);
if (!user_passphrase.empty()) {
SetStringProperty(flimflam::kOpenVPNPasswordProperty,
user_passphrase, &user_passphrase_);
}
SetStringProperty(flimflam::kOpenVPNOTPProperty, otp, NULL);
}
void VirtualNetwork::SetServerHostname(const std::string& server_hostname) {
SetStringProperty(flimflam::kProviderHostProperty,
server_hostname, &server_hostname_);
}
void VirtualNetwork::SetCertificateSlotAndPin(
const std::string& slot, const std::string& pin) {
if (provider_type() == PROVIDER_TYPE_OPEN_VPN) {
SetOrClearStringProperty(flimflam::kOpenVPNClientCertSlotProperty,
slot, NULL);
SetOrClearStringProperty(flimflam::kOpenVPNPinProperty, pin, NULL);
} else {
SetOrClearStringProperty(flimflam::kL2tpIpsecClientCertSlotProperty,
slot, NULL);
SetOrClearStringProperty(flimflam::kL2tpIpsecPinProperty, pin, NULL);
}
}
void VirtualNetwork::MatchCertificatePattern(bool allow_enroll,
const base::Closure& connect) {
DCHECK(client_cert_type() == CLIENT_CERT_TYPE_PATTERN);
DCHECK(!client_cert_pattern().Empty());
// We skip certificate patterns for device policy ONC so that an unmanaged
// user can't get to the place where a cert is presented for them
// involuntarily.
if (client_cert_pattern().Empty() ||
ui_data().onc_source() == onc::ONC_SOURCE_DEVICE_POLICY) {
connect.Run();
return;
}
scoped_refptr<net::X509Certificate> matching_cert =
client_cert::GetCertificateMatch(client_cert_pattern());
if (matching_cert.get()) {
std::string client_cert_id =
x509_certificate_model::GetPkcs11Id(matching_cert->os_cert_handle());
if (provider_type() == PROVIDER_TYPE_OPEN_VPN) {
SetStringProperty(flimflam::kOpenVPNClientCertIdProperty,
client_cert_id, &client_cert_id_);
} else {
SetStringProperty(flimflam::kL2tpIpsecClientCertIdProperty,
client_cert_id, &client_cert_id_);
}
} else {
if (allow_enroll && enrollment_delegate()) {
// Wrap the closure in another callback so that we can retry the
// certificate match again before actually connecting.
base::Closure wrapped_connect =
base::Bind(&VirtualNetwork::MatchCertificatePattern,
weak_pointer_factory_.GetWeakPtr(),
false,
connect);
enrollment_delegate()->Enroll(client_cert_pattern().enrollment_uri_list(),
wrapped_connect);
// Enrollment delegate will take care of running the closure at the
// appropriate time, if the user doesn't cancel.
return;
}
}
connect.Run();
}
////////////////////////////////////////////////////////////////////////////////
// WirelessNetwork
////////////////////////////////////////////////////////////////////////////////
// CellTower
CellTower::CellTower() {}
////////////////////////////////////////////////////////////////////////////////
// CellularApn
CellularApn::CellularApn() {}
CellularApn::CellularApn(
const std::string& apn, const std::string& network_id,
const std::string& username, const std::string& password)
: apn(apn), network_id(network_id),
username(username), password(password) {
}
CellularApn::~CellularApn() {}
void CellularApn::Set(const DictionaryValue& dict) {
if (!dict.GetStringWithoutPathExpansion(flimflam::kApnProperty, &apn))
apn.clear();
if (!dict.GetStringWithoutPathExpansion(flimflam::kApnNetworkIdProperty,
&network_id))
network_id.clear();
if (!dict.GetStringWithoutPathExpansion(flimflam::kApnUsernameProperty,
&username))
username.clear();
if (!dict.GetStringWithoutPathExpansion(flimflam::kApnPasswordProperty,
&password))
password.clear();
if (!dict.GetStringWithoutPathExpansion(flimflam::kApnNameProperty, &name))
name.clear();
if (!dict.GetStringWithoutPathExpansion(flimflam::kApnLocalizedNameProperty,
&localized_name))
localized_name.clear();
if (!dict.GetStringWithoutPathExpansion(flimflam::kApnLanguageProperty,
&language))
language.clear();
}
////////////////////////////////////////////////////////////////////////////////
// CellularNetwork
CellularNetwork::CellularNetwork(const std::string& service_path)
: WirelessNetwork(service_path, TYPE_CELLULAR),
activate_over_non_cellular_network_(false),
out_of_credits_(false),
activation_state_(ACTIVATION_STATE_UNKNOWN),
network_technology_(NETWORK_TECHNOLOGY_UNKNOWN),
roaming_state_(ROAMING_STATE_UNKNOWN),
using_post_(false) {
}
CellularNetwork::~CellularNetwork() {
}
bool CellularNetwork::StartActivation() {
if (!EnsureRunningOnChromeOS())
return false;
if (!CrosActivateCellularModem(service_path(), ""))
return false;
// Don't wait for shill to tell us that we are really activating since
// other notifications in the message loop might cause us to think that
// the process hasn't started yet.
activation_state_ = ACTIVATION_STATE_ACTIVATING;
return true;
}
void CellularNetwork::CompleteActivation() {
if (!EnsureRunningOnChromeOS())
return;
CrosCompleteCellularActivation(service_path());
}
void CellularNetwork::SetApn(const CellularApn& apn) {
if (!apn.apn.empty()) {
DictionaryValue value;
// Only use the fields that are needed for establishing
// connections, and ignore the rest.
value.SetString(flimflam::kApnProperty, apn.apn);
value.SetString(flimflam::kApnNetworkIdProperty, apn.network_id);
value.SetString(flimflam::kApnUsernameProperty, apn.username);
value.SetString(flimflam::kApnPasswordProperty, apn.password);
SetValueProperty(flimflam::kCellularApnProperty, value);
} else {
ClearProperty(flimflam::kCellularApnProperty);
}
}
bool CellularNetwork::SupportsActivation() const {
return !usage_url().empty() || !payment_url().empty();
}
bool CellularNetwork::NeedsActivation() const {
return (activation_state() == ACTIVATION_STATE_NOT_ACTIVATED ||
activation_state() == ACTIVATION_STATE_PARTIALLY_ACTIVATED);
}
std::string CellularNetwork::GetNetworkTechnologyString() const {
// No need to localize these cellular technology abbreviations.
switch (network_technology_) {
case NETWORK_TECHNOLOGY_1XRTT:
return "1xRTT";
break;
case NETWORK_TECHNOLOGY_EVDO:
return "EVDO";
break;
case NETWORK_TECHNOLOGY_GPRS:
return "GPRS";
break;
case NETWORK_TECHNOLOGY_EDGE:
return "EDGE";
break;
case NETWORK_TECHNOLOGY_UMTS:
return "UMTS";
break;
case NETWORK_TECHNOLOGY_HSPA:
return "HSPA";
break;
case NETWORK_TECHNOLOGY_HSPA_PLUS:
return "HSPA Plus";
break;
case NETWORK_TECHNOLOGY_LTE:
return "LTE";
break;
case NETWORK_TECHNOLOGY_LTE_ADVANCED:
return "LTE Advanced";
break;
case NETWORK_TECHNOLOGY_GSM:
return "GSM";
break;
default:
return l10n_util::GetStringUTF8(
IDS_CHROMEOS_NETWORK_CELLULAR_TECHNOLOGY_UNKNOWN);
break;
}
}
std::string CellularNetwork::ActivationStateToString(
ActivationState activation_state) {
switch (activation_state) {
case ACTIVATION_STATE_ACTIVATED:
return l10n_util::GetStringUTF8(
IDS_CHROMEOS_NETWORK_ACTIVATION_STATE_ACTIVATED);
break;
case ACTIVATION_STATE_ACTIVATING:
return l10n_util::GetStringUTF8(
IDS_CHROMEOS_NETWORK_ACTIVATION_STATE_ACTIVATING);
break;
case ACTIVATION_STATE_NOT_ACTIVATED:
return l10n_util::GetStringUTF8(
IDS_CHROMEOS_NETWORK_ACTIVATION_STATE_NOT_ACTIVATED);
break;
case ACTIVATION_STATE_PARTIALLY_ACTIVATED:
return l10n_util::GetStringUTF8(
IDS_CHROMEOS_NETWORK_ACTIVATION_STATE_PARTIALLY_ACTIVATED);
break;
default:
return l10n_util::GetStringUTF8(
IDS_CHROMEOS_NETWORK_ACTIVATION_STATE_UNKNOWN);
break;
}
}
std::string CellularNetwork::GetActivationStateString() const {
return ActivationStateToString(this->activation_state_);
}
std::string CellularNetwork::GetRoamingStateString() const {
switch (this->roaming_state_) {
case ROAMING_STATE_HOME:
return l10n_util::GetStringUTF8(
IDS_CHROMEOS_NETWORK_ROAMING_STATE_HOME);
break;
case ROAMING_STATE_ROAMING:
return l10n_util::GetStringUTF8(
IDS_CHROMEOS_NETWORK_ROAMING_STATE_ROAMING);
break;
default:
return l10n_util::GetStringUTF8(
IDS_CHROMEOS_NETWORK_ROAMING_STATE_UNKNOWN);
break;
}
}
////////////////////////////////////////////////////////////////////////////////
// WifiNetwork
WifiNetwork::WifiNetwork(const std::string& service_path)
: WirelessNetwork(service_path, TYPE_WIFI),
encryption_(SECURITY_NONE),
passphrase_required_(false),
hidden_ssid_(false),
frequency_(0),
eap_method_(EAP_METHOD_UNKNOWN),
eap_phase_2_auth_(EAP_PHASE_2_AUTH_AUTO),
eap_use_system_cas_(true),
eap_save_credentials_(false),
weak_pointer_factory_(this) {
}
WifiNetwork::~WifiNetwork() {}
void WifiNetwork::CalculateUniqueId() {
ConnectionSecurity encryption = encryption_;
// Shill treats wpa and rsn as psk internally, so convert those types
// to psk for unique naming.
if (encryption == SECURITY_WPA || encryption == SECURITY_RSN)
encryption = SECURITY_PSK;
std::string security = std::string(SecurityToString(encryption));
set_unique_id(security + "|" + name());
}
bool WifiNetwork::SetSsid(const std::string& ssid) {
// Detects encoding and convert to UTF-8.
std::string ssid_utf8;
if (!IsStringUTF8(ssid)) {
std::string encoding;
if (base::DetectEncoding(ssid, &encoding)) {
if (!base::ConvertToUtf8AndNormalize(ssid, encoding, &ssid_utf8)) {
ssid_utf8.clear();
}
}
}
if (ssid_utf8.empty())
SetName(ssid);
else
SetName(ssid_utf8);
return true;
}
bool WifiNetwork::SetHexSsid(const std::string& ssid_hex) {
// Converts ascii hex dump (eg. "49656c6c6f") to string (eg. "Hello").
std::vector<uint8> ssid_raw;
if (!base::HexStringToBytes(ssid_hex, &ssid_raw)) {
LOG(ERROR) << "Illegal hex char is found in WiFi.HexSSID.";
ssid_raw.clear();
return false;
}
return SetSsid(std::string(ssid_raw.begin(), ssid_raw.end()));
}
const std::string& WifiNetwork::GetPassphrase() const {
if (!user_passphrase_.empty())
return user_passphrase_;
return passphrase_;
}
void WifiNetwork::SetPassphrase(const std::string& passphrase) {
// Set the user_passphrase_ only; passphrase_ stores the shill value.
// If the user sets an empty passphrase, restore it to the passphrase
// remembered by shill.
if (!passphrase.empty()) {
user_passphrase_ = passphrase;
passphrase_ = passphrase;
} else {
user_passphrase_ = passphrase_;
}
// Send the change to shill. If the format is valid, it will propagate to
// passphrase_ with a service update.
SetOrClearStringProperty(flimflam::kPassphraseProperty, passphrase, NULL);
}
// See src/third_party/shill/doc/service-api.txt for properties that
// shill will forget when SaveCredentials is false.
void WifiNetwork::EraseCredentials() {
WipeString(&passphrase_);
WipeString(&user_passphrase_);
WipeString(&eap_server_ca_cert_pem_);
WipeString(&eap_client_cert_pkcs11_id_);
WipeString(&eap_identity_);
WipeString(&eap_anonymous_identity_);
WipeString(&eap_passphrase_);
}
void WifiNetwork::SetEAPMethod(EAPMethod method) {
eap_method_ = method;
switch (method) {
case EAP_METHOD_PEAP:
SetStringProperty(
flimflam::kEapMethodProperty, flimflam::kEapMethodPEAP, NULL);
break;
case EAP_METHOD_TLS:
SetStringProperty(
flimflam::kEapMethodProperty, flimflam::kEapMethodTLS, NULL);
break;
case EAP_METHOD_TTLS:
SetStringProperty(
flimflam::kEapMethodProperty, flimflam::kEapMethodTTLS, NULL);
break;
case EAP_METHOD_LEAP:
SetStringProperty(
flimflam::kEapMethodProperty, flimflam::kEapMethodLEAP, NULL);
break;
default:
ClearProperty(flimflam::kEapMethodProperty);
break;
}
}
void WifiNetwork::SetEAPPhase2Auth(EAPPhase2Auth auth) {
eap_phase_2_auth_ = auth;
bool is_peap = (eap_method_ == EAP_METHOD_PEAP);
switch (auth) {
case EAP_PHASE_2_AUTH_AUTO:
ClearProperty(flimflam::kEapPhase2AuthProperty);
break;
case EAP_PHASE_2_AUTH_MD5:
SetStringProperty(flimflam::kEapPhase2AuthProperty,
is_peap ? flimflam::kEapPhase2AuthPEAPMD5
: flimflam::kEapPhase2AuthTTLSMD5,
NULL);
break;
case EAP_PHASE_2_AUTH_MSCHAPV2:
SetStringProperty(flimflam::kEapPhase2AuthProperty,
is_peap ? flimflam::kEapPhase2AuthPEAPMSCHAPV2
: flimflam::kEapPhase2AuthTTLSMSCHAPV2,
NULL);
break;
case EAP_PHASE_2_AUTH_MSCHAP:
SetStringProperty(flimflam::kEapPhase2AuthProperty,
flimflam::kEapPhase2AuthTTLSMSCHAP, NULL);
break;
case EAP_PHASE_2_AUTH_PAP:
SetStringProperty(flimflam::kEapPhase2AuthProperty,
flimflam::kEapPhase2AuthTTLSPAP, NULL);
break;
case EAP_PHASE_2_AUTH_CHAP:
SetStringProperty(flimflam::kEapPhase2AuthProperty,
flimflam::kEapPhase2AuthTTLSCHAP, NULL);
break;
}
}
void WifiNetwork::SetEAPServerCaCertPEM(
const std::string& ca_cert_pem) {
VLOG(1) << "SetEAPServerCaCertPEM " << ca_cert_pem;
eap_server_ca_cert_pem_ = ca_cert_pem;
base::ListValue pem_list;
pem_list.AppendString(ca_cert_pem);
SetValueProperty(shill::kEapCaCertPemProperty, pem_list);
}
void WifiNetwork::SetEAPClientCertPkcs11Id(const std::string& pkcs11_id) {
VLOG(1) << "SetEAPClientCertPkcs11Id " << pkcs11_id;
SetOrClearStringProperty(
flimflam::kEapCertIdProperty, pkcs11_id, &eap_client_cert_pkcs11_id_);
// shill requires both CertID and KeyID for TLS connections, despite
// the fact that by convention they are the same ID.
SetOrClearStringProperty(flimflam::kEapKeyIdProperty, pkcs11_id, NULL);
}
void WifiNetwork::SetEAPUseSystemCAs(bool use_system_cas) {
SetBooleanProperty(flimflam::kEapUseSystemCasProperty, use_system_cas,
&eap_use_system_cas_);
}
void WifiNetwork::SetEAPIdentity(const std::string& identity) {
SetOrClearStringProperty(
flimflam::kEapIdentityProperty, identity, &eap_identity_);
}
void WifiNetwork::SetEAPAnonymousIdentity(const std::string& identity) {
SetOrClearStringProperty(flimflam::kEapAnonymousIdentityProperty, identity,
&eap_anonymous_identity_);
}
void WifiNetwork::SetEAPPassphrase(const std::string& passphrase) {
SetOrClearStringProperty(
flimflam::kEapPasswordProperty, passphrase, &eap_passphrase_);
}
std::string WifiNetwork::GetEncryptionString() const {
switch (encryption_) {
case SECURITY_UNKNOWN:
break;
case SECURITY_NONE:
return "";
case SECURITY_WEP:
return "WEP";
case SECURITY_WPA:
return "WPA";
case SECURITY_RSN:
return "RSN";
case SECURITY_8021X: {
std::string result("8021X");
switch (eap_method_) {
case EAP_METHOD_PEAP:
result += "+PEAP";
break;
case EAP_METHOD_TLS:
result += "+TLS";
break;
case EAP_METHOD_TTLS:
result += "+TTLS";
break;
case EAP_METHOD_LEAP:
result += "+LEAP";
break;
default:
break;
}
return result;
}
case SECURITY_PSK:
return "PSK";
}
return "Unknown";
}
bool WifiNetwork::IsPassphraseRequired() const {
if (encryption_ == SECURITY_NONE)
return false;
// A connection failure might be due to a bad passphrase.
if (error() == ERROR_BAD_PASSPHRASE ||
error() == ERROR_BAD_WEPKEY ||
error() == ERROR_PPP_AUTH_FAILED ||
error() == ERROR_EAP_LOCAL_TLS_FAILED ||
error() == ERROR_EAP_REMOTE_TLS_FAILED ||
error() == ERROR_EAP_AUTHENTICATION_FAILED ||
error() == ERROR_CONNECT_FAILED ||
error() == ERROR_UNKNOWN) {
VLOG(1) << "Authentication Error: " << GetErrorString();
return true;
}
// If the user initiated a connection and it failed, request credentials in
// case it is a credentials error and Shill was unable to detect it.
if (user_connect_state() == USER_CONNECT_FAILED)
return true;
// WEP/WPA/RSN and PSK networks rely on the PassphraseRequired property.
if (encryption_ != SECURITY_8021X)
return passphrase_required_;
// For 802.1x networks, if we are using a certificate pattern we do not
// need any credentials.
if (eap_method_ == EAP_METHOD_TLS &&
client_cert_type() == CLIENT_CERT_TYPE_PATTERN) {
return false;
}
// Connectable will be false if 802.1x credentials are not set
return !connectable();
}
bool WifiNetwork::RequiresUserProfile() const {
// 8021X requires certificates which are only stored for individual users.
if (encryption_ != SECURITY_8021X)
return false;
if (eap_method_ != EAP_METHOD_TLS)
return false;
if (eap_client_cert_pkcs11_id().empty() &&
client_cert_type() != CLIENT_CERT_TYPE_PATTERN)
return false;
return true;
}
void WifiNetwork::AttemptConnection(const base::Closure& connect) {
if (client_cert_type() == CLIENT_CERT_TYPE_PATTERN) {
MatchCertificatePattern(true, connect);
} else {
connect.Run();
}
}
void WifiNetwork::SetCertificatePin(const std::string& pin) {
SetOrClearStringProperty(flimflam::kEapPinProperty, pin, NULL);
}
void WifiNetwork::MatchCertificatePattern(bool allow_enroll,
const base::Closure& connect) {
DCHECK(client_cert_type() == CLIENT_CERT_TYPE_PATTERN);
DCHECK(!client_cert_pattern().Empty());
if (client_cert_pattern().Empty()) {
connect.Run();
return;
}
scoped_refptr<net::X509Certificate> matching_cert =
client_cert::GetCertificateMatch(client_cert_pattern());
if (matching_cert.get()) {
SetEAPClientCertPkcs11Id(
x509_certificate_model::GetPkcs11Id(matching_cert->os_cert_handle()));
} else {
if (allow_enroll && enrollment_delegate()) {
// Wrap the closure in another callback so that we can retry the
// certificate match again before actually connecting.
base::Closure wrapped_connect =
base::Bind(&WifiNetwork::MatchCertificatePattern,
weak_pointer_factory_.GetWeakPtr(),
false,
connect);
enrollment_delegate()->Enroll(client_cert_pattern().enrollment_uri_list(),
wrapped_connect);
// Enrollment delegate should take care of running the closure at the
// appropriate time, if the user doesn't cancel.
return;
}
}
connect.Run();
}
////////////////////////////////////////////////////////////////////////////////
// WimaxNetwork
WimaxNetwork::WimaxNetwork(const std::string& service_path)
: WirelessNetwork(service_path, TYPE_WIMAX),
passphrase_required_(false) {
}
WimaxNetwork::~WimaxNetwork() {
}
void WimaxNetwork::EraseCredentials() {
WipeString(&eap_passphrase_);
WipeString(&eap_identity_);
}
void WimaxNetwork::SetEAPPassphrase(const std::string& passphrase) {
SetOrClearStringProperty(
flimflam::kEapPasswordProperty, passphrase, &eap_passphrase_);
}
void WimaxNetwork::SetEAPIdentity(const std::string& identity) {
SetOrClearStringProperty(
flimflam::kEapIdentityProperty, identity, &eap_identity_);
}
void WimaxNetwork::CalculateUniqueId() {
set_unique_id(name() + "|" + eap_identity());
}
NetworkLibrary::EAPConfigData::EAPConfigData()
: method(EAP_METHOD_UNKNOWN),
auth(EAP_PHASE_2_AUTH_AUTO),
use_system_cas(true) {
}
NetworkLibrary::EAPConfigData::~EAPConfigData() {}
NetworkLibrary::VPNConfigData::VPNConfigData()
: save_credentials(false) {
}
NetworkLibrary::VPNConfigData::~VPNConfigData() {}
// static
NetworkLibrary* NetworkLibrary::GetImpl(bool stub) {
NetworkLibrary* impl;
if (stub)
impl = new NetworkLibraryImplStub();
else
impl = new NetworkLibraryImplCros();
impl->Init();
return impl;
}
// static
void NetworkLibrary::Initialize(bool use_stub) {
CHECK(!g_network_library)
<< "NetworkLibrary: Multiple calls to Initialize().";
g_network_library = NetworkLibrary::GetImpl(use_stub);
VLOG_IF(1, use_stub) << "NetworkLibrary Initialized with Stub Impl.";
}
// static
void NetworkLibrary::Shutdown() {
VLOG(1) << "NetworkLibrary Shutting down...";
delete g_network_library;
g_network_library = NULL;
VLOG(1) << " NetworkLibrary Shutdown completed.";
}
// static
NetworkLibrary* NetworkLibrary::Get() {
return g_network_library;
}
// static
void NetworkLibrary::SetForTesting(NetworkLibrary* library) {
if (g_network_library)
delete g_network_library;
g_network_library = library;
}
} // namespace chromeos