// Copyright 2021 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "ash/system/diagnostics/networking_log.h"
#include <sstream>
#include <utility>
#include "base/check.h"
#include "base/check_is_test.h"
#include "base/containers/contains.h"
#include "base/i18n/time_formatting.h"
#include "base/notreached.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_util.h"
#include "base/strings/stringprintf.h"
#include "base/strings/utf_string_conversions.h"
#include "base/time/time.h"
namespace ash {
namespace diagnostics {
namespace {
const char kNewline[] = "\n";
// NetworkingInfo constants:
const char kNetworkingInfoSectionName[] = "--- Network Info ---";
const char kNetworkEventsSectionName[] = "--- Network Events ---";
const char kNetworkNameTitle[] = "Name: ";
const char kNetworkTypeTitle[] = "Type: ";
const char kNetworkStateTitle[] = "State: ";
const char kActiveTitle[] = "Active: ";
const char kMacAddressTitle[] = "MAC Address: ";
// CellularStateProperties constants:
const char kCellularIccidTitle[] = "ICCID: ";
const char kCellularEidTitle[] = "EID: ";
const char kCellularNetworkTechnologyTitle[] = "Technology: ";
const char kCellularRoamingTitle[] = "Roaming: ";
const char kCellularRoamingStateTitle[] = "Roaming State: ";
const char kCellularSignalStrengthTitle[] = "Signal Strength: ";
const char kCellularSimLockedTitle[] = "SIM Locked: ";
const char kCellularLockTypeTitle[] = "SIM Lock Type: ";
// EthernetStateProperties constants:
const char kEthernetAuthenticationTitle[] = "Authentication: ";
// WiFiStateProperties constants:
const char kWifiSignalStrengthTitle[] = "Signal Strength: ";
const char kWifiFrequencyTitle[] = "Frequency: ";
const char kWifiSsidTitle[] = "SSID: ";
const char kWifiBssidTitle[] = "BSSID: ";
const char kSecurityTitle[] = "Security: ";
// IpConfigProperties constants:
const char kNameServersTitle[] = "Name Servers: ";
const char kGatewayTitle[] = "Gateway: ";
const char kIPAddressTitle[] = "IP Address: ";
const char kSubnetMaskTitle[] = "Subnet Mask: ";
// Event log entries
const char kEventLogFilename[] = "network_events.log";
const char kNetworkAddedEventTemplate[] =
"%s network [%s] started in state %s\n";
const char kNetworkRemovedEventTemplate[] = "%s network [%s] removed\n";
const char kNetworkStateChangedEventTemplate[] =
"%s network [%s] changed state from %s to %s\n";
const char kJoinedWiFiEventTemplate[] =
"%s network [%s] joined SSID '%s' on access point [%s]\n";
const char kLeftWiFiEventTemplate[] = "%s network [%s] left SSID '%s'\n";
const char kAccessPointRoamingEventTemplate[] =
"%s network [%s] on SSID '%s' roamed from access point [%s] to [%s]\n";
std::string GetSubnetMask(int prefix) {
uint32_t mask = (0xFFFFFFFF << (32 - prefix)) & 0xFFFFFFFF;
std::vector<uint32_t> pieces = {mask >> 24, (mask >> 16) & 0xFF,
(mask >> 8) & 0xFF, mask & 0xFF};
std::vector<std::string> vec;
for (const auto& piece : pieces) {
vec.push_back(base::NumberToString(piece));
}
return base::JoinString(vec, ".");
}
std::string GetSecurityType(mojom::SecurityType type) {
switch (type) {
case mojom::SecurityType::kNone:
return "None";
case mojom::SecurityType::kWep8021x:
case mojom::SecurityType::kWpaEap:
return "EAP";
case mojom::SecurityType::kWepPsk:
return "WEP";
case mojom::SecurityType::kWpaPsk:
return "PSK (WPA or RSN)";
}
}
std::string GetSsid(const mojom::NetworkPtr& network) {
DCHECK(network->type == mojom::NetworkType::kWiFi);
return network->type_properties ? network->type_properties->get_wifi()->ssid
: "";
}
std::string GetBssid(const mojom::NetworkPtr& network) {
DCHECK(network->type == mojom::NetworkType::kWiFi);
return network->type_properties ? network->type_properties->get_wifi()->bssid
: "";
}
bool HasJoinedWiFiNetwork(const mojom::NetworkPtr& old_state,
const mojom::NetworkPtr& new_state) {
const std::string old_ssid = GetSsid(old_state);
return old_ssid.empty() && (old_ssid != GetSsid(new_state));
}
bool HasLeftWiFiNetwork(const mojom::NetworkPtr& old_state,
const mojom::NetworkPtr& new_state) {
const std::string new_ssid = GetSsid(new_state);
return new_ssid.empty() && (new_ssid != GetSsid(old_state));
}
bool HasRoamedAccessPoint(const mojom::NetworkPtr& old_state,
const mojom::NetworkPtr& new_state) {
const std::string new_ssid = GetSsid(new_state);
return !new_ssid.empty() && (new_ssid == GetSsid(old_state)) &&
(GetBssid(old_state) != GetBssid(new_state));
}
void AddWifiInfoToLog(const mojom::NetworkTypeProperties& type_props,
std::stringstream& output) {
output << kWifiSignalStrengthTitle << type_props.get_wifi()->signal_strength
<< kNewline << kWifiFrequencyTitle << type_props.get_wifi()->frequency
<< kNewline << kWifiSsidTitle << type_props.get_wifi()->ssid
<< kNewline << kWifiBssidTitle << type_props.get_wifi()->bssid
<< kNewline << kSecurityTitle
<< GetSecurityType(type_props.get_wifi()->security) << kNewline;
}
std::string GetBoolAsString(bool value) {
return value ? "True" : "False";
}
std::string GetCellularRoamingState(mojom::RoamingState state) {
switch (state) {
case mojom::RoamingState::kNone:
return "None";
case mojom::RoamingState::kHome:
return "Home";
case mojom::RoamingState::kRoaming:
return "Roaming";
}
}
std::string GetCellularLockType(mojom::LockType lock_type) {
switch (lock_type) {
case mojom::LockType::kNone:
return "None";
case mojom::LockType::kSimPin:
return "sim-pin";
case mojom::LockType::kSimPuk:
return "sim-puk";
case mojom::LockType::kNetworkPin:
return "network-pin";
}
}
void AddCellularInfoToLog(const mojom::NetworkTypeProperties& type_props,
std::stringstream& output) {
output << kCellularIccidTitle << type_props.get_cellular()->iccid << kNewline
<< kCellularEidTitle << type_props.get_cellular()->eid << kNewline
<< kCellularNetworkTechnologyTitle
<< type_props.get_cellular()->network_technology << kNewline
<< kCellularRoamingTitle
<< GetBoolAsString(type_props.get_cellular()->roaming) << kNewline
<< kCellularRoamingStateTitle
<< GetCellularRoamingState(type_props.get_cellular()->roaming_state)
<< kNewline << kCellularSignalStrengthTitle
<< type_props.get_cellular()->signal_strength << kNewline
<< kCellularSimLockedTitle
<< GetBoolAsString(type_props.get_cellular()->sim_locked) << kNewline
<< kCellularLockTypeTitle
<< GetCellularLockType(type_props.get_cellular()->lock_type)
<< kNewline;
}
std::string GetEthernetAuthenticationType(mojom::AuthenticationType type) {
switch (type) {
case mojom::AuthenticationType::kNone:
return "None";
case mojom::AuthenticationType::k8021x:
return "EAP";
}
}
void AddEthernetInfoToLog(const mojom::NetworkTypeProperties& type_props,
std::stringstream& output) {
output << kEthernetAuthenticationTitle
<< GetEthernetAuthenticationType(
type_props.get_ethernet()->authentication)
<< kNewline;
}
void AddTypePropertiesToLog(const mojom::NetworkTypeProperties& type_props,
mojom::NetworkType type,
std::stringstream& output) {
switch (type) {
case mojom::NetworkType::kWiFi:
AddWifiInfoToLog(type_props, output);
break;
case mojom::NetworkType::kCellular:
AddCellularInfoToLog(type_props, output);
break;
case mojom::NetworkType::kEthernet:
AddEthernetInfoToLog(type_props, output);
break;
case mojom::NetworkType::kUnsupported:
NOTREACHED();
}
}
void AddIPConfigPropertiesToLog(const mojom::IPConfigProperties& ip_config,
std::stringstream& output) {
output << kGatewayTitle << ip_config.gateway.value_or("") << kNewline;
output << kIPAddressTitle << ip_config.ip_address.value_or("") << kNewline;
auto name_servers = base::JoinString(
ip_config.name_servers.value_or(std::vector<std::string>()), ", ");
output << kNameServersTitle << name_servers << kNewline;
// A routing prefix can not be 0, 0 indicates an unset value.
auto subnet_mask = ip_config.routing_prefix != 0
? GetSubnetMask(ip_config.routing_prefix)
: "";
output << kSubnetMaskTitle << subnet_mask << kNewline;
}
std::string GetNetworkStateString(mojom::NetworkState state) {
switch (state) {
case mojom::NetworkState::kOnline:
return "Online";
case mojom::NetworkState::kConnected:
return "Connected";
case mojom::NetworkState::kConnecting:
return "Connecting";
case mojom::NetworkState::kNotConnected:
return "Not Connected";
case mojom::NetworkState::kDisabled:
return "Disabled";
case mojom::NetworkState::kPortal:
return "Portal";
}
}
std::string GetNetworkType(mojom::NetworkType type) {
switch (type) {
case mojom::NetworkType::kWiFi:
return "WiFi";
case mojom::NetworkType::kCellular:
return "Cellular";
case mojom::NetworkType::kEthernet:
return "Ethernet";
case mojom::NetworkType::kUnsupported:
NOTREACHED();
}
}
} // namespace
NetworkingLog::NetworkingLog(const base::FilePath& log_base_path)
: event_log_(log_base_path.Append(kEventLogFilename)) {}
NetworkingLog::~NetworkingLog() = default;
std::string NetworkingLog::GetNetworkInfo() const {
std::stringstream output;
output << kNetworkingInfoSectionName << kNewline;
for (const auto& pair : latest_network_states_) {
const mojom::NetworkPtr& network = pair.second;
output << kNewline << kNetworkNameTitle << network->name << kNewline
<< kNetworkTypeTitle << GetNetworkType(network->type) << kNewline
<< kNetworkStateTitle << GetNetworkStateString(network->state)
<< kNewline << kActiveTitle
<< (network->observer_guid == active_guid_ ? "True" : "False")
<< kNewline << kMacAddressTitle << network->mac_address.value_or("")
<< kNewline;
if (network->type_properties) {
AddTypePropertiesToLog(*network->type_properties, network->type, output);
}
if (network->ip_config) {
AddIPConfigPropertiesToLog(*network->ip_config, output);
}
}
return output.str();
}
std::string NetworkingLog::GetNetworkEvents() const {
return std::string(kNetworkEventsSectionName) + kNewline + kNewline +
event_log_.GetContents();
}
void NetworkingLog::UpdateNetworkList(
const std::vector<std::string>& observer_guids,
std::string active_guid) {
// If a network is no longer valid, remove it from the map.
for (auto iter = latest_network_states_.begin();
iter != latest_network_states_.end();) {
if (!base::Contains(observer_guids, iter->first)) {
LogNetworkRemoved(iter->second);
iter = latest_network_states_.erase(iter);
continue;
}
++iter;
}
active_guid_ = active_guid;
++update_network_list_call_count_for_testing_;
}
void NetworkingLog::UpdateNetworkState(mojom::NetworkPtr network) {
if (network.is_null()) {
LOG(ERROR) << "Network to log update is null";
return;
}
if (!base::Contains(latest_network_states_, network->observer_guid)) {
LogNetworkAdded(network);
latest_network_states_.emplace(network->observer_guid, std::move(network));
return;
}
LogNetworkChanges(network);
latest_network_states_[network->observer_guid] = std::move(network);
}
void NetworkingLog::LogEvent(const std::string& event_string) {
const std::string datetime =
base::UTF16ToUTF8(base::TimeFormatShortDateAndTime(base::Time::Now()));
event_log_.Append(datetime + " - " + event_string);
}
void NetworkingLog::LogNetworkAdded(const mojom::NetworkPtr& network) {
const std::string line = base::StringPrintf(
kNetworkAddedEventTemplate, GetNetworkType(network->type).c_str(),
network->mac_address.value_or("").c_str(),
GetNetworkStateString(network->state).c_str());
LogEvent(line);
}
void NetworkingLog::LogNetworkRemoved(const mojom::NetworkPtr& network) {
if (network.is_null()) {
LOG(ERROR) << "Network to log removal is null";
return;
}
const std::string line = base::StringPrintf(
kNetworkRemovedEventTemplate, GetNetworkType(network->type).c_str(),
network->mac_address.value_or("").c_str());
LogEvent(line);
}
void NetworkingLog::LogNetworkChanges(const mojom::NetworkPtr& new_state) {
DCHECK(base::Contains(latest_network_states_, new_state->observer_guid));
const mojom::NetworkPtr& old_state =
latest_network_states_.at(new_state->observer_guid);
if (new_state->type == mojom::NetworkType::kWiFi) {
if (HasJoinedWiFiNetwork(old_state, new_state)) {
LogJoinedWiFiNetwork(new_state);
} else if (HasLeftWiFiNetwork(old_state, new_state)) {
LogLeftWiFiNetwork(new_state, GetSsid(old_state));
} else if (HasRoamedAccessPoint(old_state, new_state)) {
LogWiFiRoamedAccessPoint(new_state, GetBssid(old_state));
}
}
if (old_state->state != new_state->state) {
LogNetworkStateChanged(old_state, new_state);
}
}
void NetworkingLog::LogNetworkStateChanged(const mojom::NetworkPtr& old_state,
const mojom::NetworkPtr& new_state) {
const std::string line =
base::StringPrintf(kNetworkStateChangedEventTemplate,
GetNetworkType(new_state->type).c_str(),
new_state->mac_address.value_or("").c_str(),
GetNetworkStateString(old_state->state).c_str(),
GetNetworkStateString(new_state->state).c_str());
LogEvent(line);
}
void NetworkingLog::LogJoinedWiFiNetwork(const mojom::NetworkPtr& network) {
const std::string line = base::StringPrintf(
kJoinedWiFiEventTemplate, GetNetworkType(network->type).c_str(),
network->mac_address.value_or("").c_str(), GetSsid(network).c_str(),
GetBssid(network).c_str());
LogEvent(line);
}
void NetworkingLog::LogLeftWiFiNetwork(const mojom::NetworkPtr& network,
const std::string& old_ssid) {
const std::string line = base::StringPrintf(
kLeftWiFiEventTemplate, GetNetworkType(network->type).c_str(),
network->mac_address.value_or("").c_str(), old_ssid.c_str());
LogEvent(line);
}
void NetworkingLog::LogWiFiRoamedAccessPoint(const mojom::NetworkPtr& network,
const std::string& old_bssid) {
const std::string line = base::StringPrintf(
kAccessPointRoamingEventTemplate, GetNetworkType(network->type).c_str(),
network->mac_address.value_or("").c_str(), GetSsid(network).c_str(),
old_bssid.c_str(), GetBssid(network).c_str());
LogEvent(line);
}
size_t NetworkingLog::update_network_list_call_count_for_testing() const {
CHECK_IS_TEST();
return update_network_list_call_count_for_testing_;
}
} // namespace diagnostics
} // namespace ash
Codebase Browser
chromium