// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chromeos/ash/components/dbus/shill/shill_client_helper.h"
#include <stddef.h>
#include <utility>
#include "base/functional/bind.h"
#include "base/functional/callback_helpers.h"
#include "base/location.h"
#include "base/task/single_thread_task_runner.h"
#include "base/values.h"
#include "components/device_event_log/device_event_log.h"
#include "dbus/message.h"
#include "dbus/object_proxy.h"
#include "dbus/values_util.h"
#include "third_party/cros_system_api/dbus/service_constants.h"
namespace ash {
// Class to hold onto a reference to a ShillClientHelper. This class
// is owned by callbacks and released once the callback completes.
// Note: Only success callbacks hold the reference. If an error callback is
// invoked instead, the success callback will still be destroyed and the
// RefHolder with it, once the callback chain completes.
class ShillClientHelper::RefHolder {
public:
explicit RefHolder(base::WeakPtr<ShillClientHelper> helper)
: helper_(helper),
origin_task_runner_(base::SingleThreadTaskRunner::GetCurrentDefault()) {
helper_->AddRef();
}
~RefHolder() {
// Release the helper on the origin thread.
base::OnceClosure closure =
base::BindOnce(&ShillClientHelper::Release, helper_);
if (origin_task_runner_->BelongsToCurrentThread()) {
std::move(closure).Run();
} else {
origin_task_runner_->PostTask(FROM_HERE, std::move(closure));
}
}
private:
base::WeakPtr<ShillClientHelper> helper_;
scoped_refptr<base::SingleThreadTaskRunner> origin_task_runner_;
};
namespace {
const char kInvalidResponseErrorName[] = ""; // No error name.
const char kInvalidResponseErrorMessage[] = "Invalid response.";
// Note: here and below, |ref_holder| is unused in the function body. It only
// exists so that it will be destroyed (and the reference released) with the
// Callback object once completed.
void OnBooleanMethodWithErrorCallback(
ShillClientHelper::RefHolder* ref_holder,
ShillClientHelper::BooleanCallback callback,
ShillClientHelper::ErrorCallback error_callback,
dbus::Response* response) {
if (!response) {
std::move(error_callback)
.Run(kInvalidResponseErrorName, kInvalidResponseErrorMessage);
return;
}
dbus::MessageReader reader(response);
bool result;
if (!reader.PopBool(&result)) {
std::move(error_callback)
.Run(kInvalidResponseErrorName, kInvalidResponseErrorMessage);
return;
}
std::move(callback).Run(result);
}
void OnStringMethodWithErrorCallback(
ShillClientHelper::RefHolder* ref_holder,
ShillClientHelper::StringCallback callback,
ShillClientHelper::ErrorCallback error_callback,
dbus::Response* response) {
if (!response) {
std::move(error_callback)
.Run(kInvalidResponseErrorName, kInvalidResponseErrorMessage);
return;
}
dbus::MessageReader reader(response);
std::string result;
if (!reader.PopString(&result)) {
std::move(error_callback)
.Run(kInvalidResponseErrorName, kInvalidResponseErrorMessage);
return;
}
std::move(callback).Run(result);
}
// Handles responses for methods without results.
void OnVoidMethod(ShillClientHelper::RefHolder* ref_holder,
chromeos::VoidDBusMethodCallback callback,
dbus::Response* response) {
std::move(callback).Run(response != nullptr);
}
// Handles responses for methods with ObjectPath results and no status.
void OnObjectPathMethodWithoutStatus(
ShillClientHelper::RefHolder* ref_holder,
chromeos::ObjectPathCallback callback,
ShillClientHelper::ErrorCallback error_callback,
dbus::Response* response) {
if (!response) {
std::move(error_callback)
.Run(kInvalidResponseErrorName, kInvalidResponseErrorMessage);
return;
}
dbus::MessageReader reader(response);
dbus::ObjectPath result;
if (!reader.PopObjectPath(&result)) {
std::move(error_callback)
.Run(kInvalidResponseErrorName, kInvalidResponseErrorMessage);
return;
}
std::move(callback).Run(result);
}
// Handles responses for methods with base::Value results.
void OnValueMethod(ShillClientHelper::RefHolder* ref_holder,
chromeos::DBusMethodCallback<base::Value> callback,
dbus::Response* response,
dbus::ErrorResponse* error_response) {
if (!response) {
if (error_response) {
dbus::MessageReader reader(error_response);
std::string error_message;
reader.PopString(&error_message);
NET_LOG(ERROR) << "DBus call failed. Error: "
<< error_response->GetErrorName()
<< " Message: " << error_message;
} else {
NET_LOG(ERROR) << "DBus call failed with no error.";
}
std::move(callback).Run(std::nullopt);
return;
}
dbus::MessageReader reader(response);
base::Value value(dbus::PopDataAsValue(&reader));
if (value.is_none()) {
std::move(callback).Run(std::nullopt);
return;
}
std::move(callback).Run(std::move(value));
}
// Handles responses for methods with base::Value::Dict results.
void OnDictValueMethod(ShillClientHelper::RefHolder* ref_holder,
chromeos::DBusMethodCallback<base::Value::Dict> callback,
dbus::Response* response,
dbus::ErrorResponse* error_response) {
if (!response) {
if (error_response) {
dbus::MessageReader reader(error_response);
std::string error_message;
reader.PopString(&error_message);
NET_LOG(ERROR) << "DBus call failed. Error: "
<< error_response->GetErrorName()
<< " Message: " << error_message;
} else {
NET_LOG(ERROR) << "DBus call failed with no error.";
}
std::move(callback).Run(std::nullopt);
return;
}
dbus::MessageReader reader(response);
base::Value value(dbus::PopDataAsValue(&reader));
if (!value.is_dict()) {
std::move(callback).Run(std::nullopt);
return;
}
std::move(callback).Run(std::move(value.GetDict()));
}
// Handles responses for methods without results.
void OnVoidMethodWithErrorCallback(ShillClientHelper::RefHolder* ref_holder,
base::OnceClosure callback,
dbus::Response* response) {
std::move(callback).Run();
}
// Handles responses for methods with base::Value::Dict results.
// Used by CallDictValueMethodWithErrorCallback().
void OnDictValueMethodWithErrorCallback(
ShillClientHelper::RefHolder* ref_holder,
base::OnceCallback<void(base::Value::Dict result)> callback,
ShillClientHelper::ErrorCallback error_callback,
dbus::Response* response) {
dbus::MessageReader reader(response);
base::Value value(dbus::PopDataAsValue(&reader));
if (!value.is_dict()) {
std::move(error_callback)
.Run(kInvalidResponseErrorName, kInvalidResponseErrorMessage);
return;
}
std::move(callback).Run(std::move(value).TakeDict());
}
// Handles responses for methods with ListValue results.
void OnListValueMethodWithErrorCallback(
ShillClientHelper::RefHolder* ref_holder,
ShillClientHelper::ListValueCallback callback,
ShillClientHelper::ErrorCallback error_callback,
dbus::Response* response) {
dbus::MessageReader reader(response);
base::Value value(dbus::PopDataAsValue(&reader));
if (!value.is_list()) {
std::move(error_callback)
.Run(kInvalidResponseErrorName, kInvalidResponseErrorMessage);
return;
}
std::move(callback).Run(value.GetList());
}
// Handles running appropriate error callbacks.
void OnError(ShillClientHelper::ErrorCallback error_callback,
dbus::ErrorResponse* response) {
std::string error_name;
std::string error_message;
if (response) {
// Error message may contain the error message as string.
dbus::MessageReader reader(response);
error_name = response->GetErrorName();
reader.PopString(&error_message);
}
std::move(error_callback).Run(error_name, error_message);
}
} // namespace
ShillClientHelper::ShillClientHelper(dbus::ObjectProxy* proxy)
: proxy_(proxy), active_refs_(0) {}
ShillClientHelper::~ShillClientHelper() {
if (!observer_list_.empty())
NET_LOG(ERROR) << "ShillClientHelper destroyed with active observers";
}
void ShillClientHelper::SetReleasedCallback(ReleasedCallback callback) {
CHECK(released_callback_.is_null());
released_callback_ = std::move(callback);
}
void ShillClientHelper::AddPropertyChangedObserver(
ShillPropertyChangedObserver* observer) {
if (observer_list_.HasObserver(observer))
return;
AddRef();
// Execute all the pending MonitorPropertyChanged calls.
for (const auto& interface : interfaces_to_be_monitored_) {
MonitorPropertyChangedInternal(interface);
}
interfaces_to_be_monitored_.clear();
observer_list_.AddObserver(observer);
}
void ShillClientHelper::RemovePropertyChangedObserver(
ShillPropertyChangedObserver* observer) {
if (!observer_list_.HasObserver(observer))
return;
observer_list_.RemoveObserver(observer);
Release();
}
void ShillClientHelper::MonitorPropertyChanged(
const std::string& interface_name) {
if (!observer_list_.empty()) {
// Effectively monitor the PropertyChanged now.
MonitorPropertyChangedInternal(interface_name);
} else {
// Delay the ConnectToSignal until an observer is added.
interfaces_to_be_monitored_.push_back(interface_name);
}
}
void ShillClientHelper::MonitorPropertyChangedInternal(
const std::string& interface_name) {
// We are not using dbus::PropertySet to monitor PropertyChanged signal
// because the interface is not "org.freedesktop.DBus.Properties".
proxy_->ConnectToSignal(
interface_name, shill::kMonitorPropertyChanged,
base::BindRepeating(&ShillClientHelper::OnPropertyChanged,
weak_ptr_factory_.GetWeakPtr()),
base::BindOnce(&ShillClientHelper::OnSignalConnected,
weak_ptr_factory_.GetWeakPtr()));
}
void ShillClientHelper::CallVoidMethod(
dbus::MethodCall* method_call,
chromeos::VoidDBusMethodCallback callback) {
DCHECK(!callback.is_null());
proxy_->CallMethod(
method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
base::BindOnce(&OnVoidMethod,
base::Owned(new RefHolder(weak_ptr_factory_.GetWeakPtr())),
std::move(callback)));
}
void ShillClientHelper::CallObjectPathMethodWithErrorCallback(
dbus::MethodCall* method_call,
chromeos::ObjectPathCallback callback,
ErrorCallback error_callback) {
DCHECK(!callback.is_null());
DCHECK(!error_callback.is_null());
auto split_callback = base::SplitOnceCallback(std::move(error_callback));
proxy_->CallMethodWithErrorCallback(
method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
base::BindOnce(&OnObjectPathMethodWithoutStatus,
base::Owned(new RefHolder(weak_ptr_factory_.GetWeakPtr())),
std::move(callback), std::move(split_callback.first)),
base::BindOnce(&OnError, std::move(split_callback.second)));
}
void ShillClientHelper::CallValueMethod(
dbus::MethodCall* method_call,
chromeos::DBusMethodCallback<base::Value> callback) {
DCHECK(!callback.is_null());
proxy_->CallMethodWithErrorResponse(
method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
base::BindOnce(&OnValueMethod,
base::Owned(new RefHolder(weak_ptr_factory_.GetWeakPtr())),
std::move(callback)));
}
void ShillClientHelper::CallDictValueMethod(
dbus::MethodCall* method_call,
chromeos::DBusMethodCallback<base::Value::Dict> callback) {
DCHECK(!callback.is_null());
proxy_->CallMethodWithErrorResponse(
method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
base::BindOnce(&OnDictValueMethod,
base::Owned(new RefHolder(weak_ptr_factory_.GetWeakPtr())),
std::move(callback)));
}
void ShillClientHelper::CallVoidMethodWithErrorCallback(
dbus::MethodCall* method_call,
base::OnceClosure callback,
ErrorCallback error_callback) {
DCHECK(!callback.is_null());
DCHECK(!error_callback.is_null());
proxy_->CallMethodWithErrorCallback(
method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
base::BindOnce(&OnVoidMethodWithErrorCallback,
base::Owned(new RefHolder(weak_ptr_factory_.GetWeakPtr())),
std::move(callback)),
base::BindOnce(&OnError, std::move(error_callback)));
}
void ShillClientHelper::CallBooleanMethodWithErrorCallback(
dbus::MethodCall* method_call,
BooleanCallback callback,
ErrorCallback error_callback) {
DCHECK(!callback.is_null());
DCHECK(!error_callback.is_null());
auto split_callback = base::SplitOnceCallback(std::move(error_callback));
proxy_->CallMethodWithErrorCallback(
method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
base::BindOnce(&OnBooleanMethodWithErrorCallback,
base::Owned(new RefHolder(weak_ptr_factory_.GetWeakPtr())),
std::move(callback), std::move(split_callback.first)),
base::BindOnce(&OnError, std::move(split_callback.second)));
}
void ShillClientHelper::CallStringMethodWithErrorCallback(
dbus::MethodCall* method_call,
StringCallback callback,
ErrorCallback error_callback) {
DCHECK(!callback.is_null());
DCHECK(!error_callback.is_null());
auto split_callback = base::SplitOnceCallback(std::move(error_callback));
proxy_->CallMethodWithErrorCallback(
method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
base::BindOnce(&OnStringMethodWithErrorCallback,
base::Owned(new RefHolder(weak_ptr_factory_.GetWeakPtr())),
std::move(callback), std::move(split_callback.first)),
base::BindOnce(&OnError, std::move(split_callback.second)));
}
void ShillClientHelper::CallDictValueMethodWithErrorCallback(
dbus::MethodCall* method_call,
base::OnceCallback<void(base::Value::Dict result)> callback,
ErrorCallback error_callback) {
DCHECK(!callback.is_null());
DCHECK(!error_callback.is_null());
auto split_callback = base::SplitOnceCallback(std::move(error_callback));
proxy_->CallMethodWithErrorCallback(
method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
base::BindOnce(&OnDictValueMethodWithErrorCallback,
base::Owned(new RefHolder(weak_ptr_factory_.GetWeakPtr())),
std::move(callback), std::move(split_callback.first)),
base::BindOnce(&OnError, std::move(split_callback.second)));
}
void ShillClientHelper::CallListValueMethodWithErrorCallback(
dbus::MethodCall* method_call,
ListValueCallback callback,
ErrorCallback error_callback) {
DCHECK(!callback.is_null());
DCHECK(!error_callback.is_null());
auto split_callback = base::SplitOnceCallback(std::move(error_callback));
proxy_->CallMethodWithErrorCallback(
method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
base::BindOnce(&OnListValueMethodWithErrorCallback,
base::Owned(new RefHolder(weak_ptr_factory_.GetWeakPtr())),
std::move(callback), std::move(split_callback.first)),
base::BindOnce(&OnError, std::move(split_callback.second)));
}
namespace {
enum DictionaryType { DICTIONARY_TYPE_VARIANT, DICTIONARY_TYPE_STRING };
// Appends an a{ss} dictionary to |writer|. |dictionary| must only contain
// strings.
void AppendStringDictionary(const base::Value::Dict& dictionary,
dbus::MessageWriter* writer) {
dbus::MessageWriter array_writer(nullptr);
writer->OpenArray("{ss}", &array_writer);
for (const auto it : dictionary) {
dbus::MessageWriter entry_writer(nullptr);
array_writer.OpenDictEntry(&entry_writer);
entry_writer.AppendString(it.first);
const base::Value& value = it.second;
std::string value_string;
if (value.is_string()) {
value_string = value.GetString();
} else {
NET_LOG(ERROR) << "Dictionary value not a string: " << it.first;
}
entry_writer.AppendString(value_string);
array_writer.CloseContainer(&entry_writer);
}
writer->CloseContainer(&array_writer);
}
void AppendValueDataAsVariantInternal(dbus::MessageWriter* writer,
const std::string& name,
const base::Value& value,
DictionaryType dictionary_type) {
// Support basic types and string-to-string dictionary.
switch (value.type()) {
case base::Value::Type::DICT: {
if (dictionary_type == DICTIONARY_TYPE_STRING) {
// AppendStringDictionary uses a{ss} to support Cellular.APN which
// expects a string -> string dictionary.
dbus::MessageWriter variant_writer(nullptr);
writer->OpenVariant("a{ss}", &variant_writer);
AppendStringDictionary(value.GetDict(), &variant_writer);
writer->CloseContainer(&variant_writer);
} else {
dbus::MessageWriter variant_writer(nullptr);
writer->OpenVariant("a{sv}", &variant_writer);
ShillClientHelper::AppendServiceProperties(&variant_writer,
value.GetDict());
writer->CloseContainer(&variant_writer);
}
break;
}
case base::Value::Type::LIST: {
// Support list of string and list of string-to-string dictionary.
// For properties that might receive an empty list of dictionaries, always
// use aa{ss}.
const auto& list_view = value.GetList();
if ((list_view.size() > 0 && list_view.front().is_dict()) ||
name == shill::kCellularCustomApnListProperty) {
// aa{ss} to support WireGuard.Peers
dbus::MessageWriter variant_writer(nullptr);
writer->OpenVariant("aa{ss}", &variant_writer);
dbus::MessageWriter array_writer(nullptr);
variant_writer.OpenArray("a{ss}", &array_writer);
for (const auto& item : list_view) {
AppendStringDictionary(item.GetDict(), &array_writer);
}
variant_writer.CloseContainer(&array_writer);
writer->CloseContainer(&variant_writer);
break;
}
dbus::MessageWriter variant_writer(nullptr);
writer->OpenVariant("as", &variant_writer);
dbus::MessageWriter array_writer(nullptr);
variant_writer.OpenArray("s", &array_writer);
for (const auto& inner_value : list_view) {
std::string value_string;
if (inner_value.is_string()) {
value_string = inner_value.GetString();
} else {
NET_LOG(ERROR) << "List value not a string: " << value;
}
array_writer.AppendString(value_string);
}
variant_writer.CloseContainer(&array_writer);
writer->CloseContainer(&variant_writer);
break;
}
case base::Value::Type::BOOLEAN:
case base::Value::Type::INTEGER:
case base::Value::Type::DOUBLE:
case base::Value::Type::STRING:
dbus::AppendBasicTypeValueDataAsVariant(writer, value);
break;
default:
NET_LOG(ERROR) << "Unexpected value type: " << value.type();
}
}
} // namespace
// static
void ShillClientHelper::AppendValueDataAsVariant(dbus::MessageWriter* writer,
const std::string& name,
const base::Value& value) {
AppendValueDataAsVariantInternal(writer, name, value,
DICTIONARY_TYPE_VARIANT);
}
// static
void ShillClientHelper::AppendServiceProperties(
dbus::MessageWriter* writer,
const base::Value::Dict& dictionary) {
dbus::MessageWriter array_writer(nullptr);
writer->OpenArray("{sv}", &array_writer);
for (auto it : dictionary) {
dbus::MessageWriter entry_writer(nullptr);
array_writer.OpenDictEntry(&entry_writer);
entry_writer.AppendString(it.first);
// Shill expects Cellular.APN to be a string dictionary, a{ss}. All other
// properties use a variant dictionary, a{sv}. TODO(stevenjb): Remove this
// hack if/when we change Shill to accept a{sv} for Cellular.APN.
DictionaryType dictionary_type = (it.first == shill::kCellularApnProperty)
? DICTIONARY_TYPE_STRING
: DICTIONARY_TYPE_VARIANT;
AppendValueDataAsVariantInternal(&entry_writer, it.first, it.second,
dictionary_type);
array_writer.CloseContainer(&entry_writer);
}
writer->CloseContainer(&array_writer);
}
void ShillClientHelper::AddRef() {
++active_refs_;
}
void ShillClientHelper::Release() {
--active_refs_;
if (active_refs_ == 0 && !released_callback_.is_null())
std::move(released_callback_).Run(this); // May delete this
}
void ShillClientHelper::OnSignalConnected(const std::string& interface,
const std::string& signal,
bool success) {
if (!success)
NET_LOG(ERROR) << "Connect to " << interface << " " << signal << " failed.";
}
void ShillClientHelper::OnPropertyChanged(dbus::Signal* signal) {
if (observer_list_.empty())
return;
dbus::MessageReader reader(signal);
std::string name;
if (!reader.PopString(&name))
return;
base::Value value(dbus::PopDataAsValue(&reader));
if (value.is_none())
return;
for (auto& observer : observer_list_)
observer.OnPropertyChanged(name, value);
}
} // namespace ash
Codebase Browser
chromium