blob: baab6204024cf5dcc5d10ca5edc1738fd0764844 [file] [log] [blame]
// 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.
#ifdef UNSAFE_BUFFERS_BUILD
// TODO(crbug.com/351564777): Remove this and convert code to safer constructs.
#pragma allow_unsafe_buffers
#endif
#include "dbus/property.h"
#include <stddef.h>
#include <memory>
#include "base/functional/bind.h"
#include "base/logging.h"
#include "dbus/message.h"
#include "dbus/object_path.h"
#include "dbus/object_proxy.h"
namespace dbus {
//
// PropertyBase implementation.
//
PropertyBase::PropertyBase() : property_set_(nullptr), is_valid_(false) {}
PropertyBase::~PropertyBase() = default;
void PropertyBase::Init(PropertySet* property_set, const std::string& name) {
DCHECK(!property_set_);
property_set_ = property_set;
is_valid_ = false;
name_ = name;
}
//
// PropertySet implementation.
//
PropertySet::PropertySet(
ObjectProxy* object_proxy,
const std::string& interface,
const PropertyChangedCallback& property_changed_callback)
: object_proxy_(object_proxy),
interface_(interface),
property_changed_callback_(property_changed_callback) {}
PropertySet::~PropertySet() = default;
void PropertySet::RegisterProperty(const std::string& name,
PropertyBase* property) {
property->Init(this, name);
properties_map_[name] = property;
}
void PropertySet::ConnectSignals() {
DCHECK(object_proxy_);
object_proxy_->ConnectToSignal(
kPropertiesInterface, kPropertiesChanged,
base::BindRepeating(&PropertySet::ChangedReceived,
weak_ptr_factory_.GetWeakPtr()),
base::BindOnce(&PropertySet::ChangedConnected,
weak_ptr_factory_.GetWeakPtr()));
}
void PropertySet::ChangedReceived(Signal* signal) {
DCHECK(signal);
MessageReader reader(signal);
std::string interface;
if (!reader.PopString(&interface)) {
LOG(WARNING) << "Property changed signal has wrong parameters: "
<< "expected interface name: " << signal->ToString();
return;
}
if (interface != this->interface())
return;
if (!UpdatePropertiesFromReader(&reader)) {
LOG(WARNING) << "Property changed signal has wrong parameters: "
<< "expected dictionary: " << signal->ToString();
}
if (!InvalidatePropertiesFromReader(&reader)) {
LOG(WARNING) << "Property changed signal has wrong parameters: "
<< "expected array to invalidate: " << signal->ToString();
}
}
void PropertySet::ChangedConnected(const std::string& interface_name,
const std::string& signal_name,
bool success) {
LOG_IF(WARNING, !success) << "Failed to connect to " << signal_name
<< "signal.";
}
void PropertySet::Get(PropertyBase* property, GetCallback callback) {
MethodCall method_call(kPropertiesInterface, kPropertiesGet);
MessageWriter writer(&method_call);
writer.AppendString(interface());
writer.AppendString(property->name());
DCHECK(object_proxy_);
object_proxy_->CallMethod(&method_call, ObjectProxy::TIMEOUT_USE_DEFAULT,
base::BindOnce(&PropertySet::OnGet, GetWeakPtr(),
property, std::move(callback)));
}
void PropertySet::OnGet(PropertyBase* property, GetCallback callback,
Response* response) {
if (!response) {
LOG(WARNING) << property->name() << ": Get: failed.";
return;
}
MessageReader reader(response);
if (property->PopValueFromReader(&reader)) {
property->set_valid(true);
NotifyPropertyChanged(property->name());
} else {
if (property->is_valid()) {
property->set_valid(false);
NotifyPropertyChanged(property->name());
}
}
if (!callback.is_null())
std::move(callback).Run(response);
}
bool PropertySet::GetAndBlock(PropertyBase* property) {
MethodCall method_call(kPropertiesInterface, kPropertiesGet);
MessageWriter writer(&method_call);
writer.AppendString(interface());
writer.AppendString(property->name());
DCHECK(object_proxy_);
auto result = object_proxy_->CallMethodAndBlock(
&method_call, ObjectProxy::TIMEOUT_USE_DEFAULT);
if (!result.has_value()) {
LOG(WARNING) << property->name() << ": GetAndBlock: failed.";
return false;
}
MessageReader reader(result->get());
if (property->PopValueFromReader(&reader)) {
property->set_valid(true);
NotifyPropertyChanged(property->name());
} else {
if (property->is_valid()) {
property->set_valid(false);
NotifyPropertyChanged(property->name());
}
}
return true;
}
void PropertySet::GetAll() {
MethodCall method_call(kPropertiesInterface, kPropertiesGetAll);
MessageWriter writer(&method_call);
writer.AppendString(interface());
DCHECK(object_proxy_);
object_proxy_->CallMethod(
&method_call, ObjectProxy::TIMEOUT_USE_DEFAULT,
base::BindOnce(&PropertySet::OnGetAll, weak_ptr_factory_.GetWeakPtr()));
}
void PropertySet::OnGetAll(Response* response) {
if (!response) {
LOG(WARNING) << "GetAll request failed for: " << interface_;
return;
}
MessageReader reader(response);
if (!UpdatePropertiesFromReader(&reader)) {
LOG(WARNING) << "GetAll response has wrong parameters: "
<< "expected dictionary: " << response->ToString();
}
}
void PropertySet::Set(PropertyBase* property, SetCallback callback) {
MethodCall method_call(kPropertiesInterface, kPropertiesSet);
MessageWriter writer(&method_call);
writer.AppendString(interface());
writer.AppendString(property->name());
property->AppendSetValueToWriter(&writer);
DCHECK(object_proxy_);
object_proxy_->CallMethod(&method_call, ObjectProxy::TIMEOUT_USE_DEFAULT,
base::BindOnce(&PropertySet::OnSet, GetWeakPtr(),
property, std::move(callback)));
}
bool PropertySet::SetAndBlock(PropertyBase* property) {
MethodCall method_call(kPropertiesInterface, kPropertiesSet);
MessageWriter writer(&method_call);
writer.AppendString(interface());
writer.AppendString(property->name());
property->AppendSetValueToWriter(&writer);
DCHECK(object_proxy_);
return object_proxy_
->CallMethodAndBlock(&method_call, ObjectProxy::TIMEOUT_USE_DEFAULT)
.has_value();
}
void PropertySet::OnSet(PropertyBase* property,
SetCallback callback,
Response* response) {
LOG_IF(WARNING, !response) << property->name() << ": Set: failed.";
if (!callback.is_null())
std::move(callback).Run(response);
}
bool PropertySet::UpdatePropertiesFromReader(MessageReader* reader) {
DCHECK(reader);
MessageReader array_reader(nullptr);
if (!reader->PopArray(&array_reader))
return false;
while (array_reader.HasMoreData()) {
MessageReader dict_entry_reader(nullptr);
if (array_reader.PopDictEntry(&dict_entry_reader))
UpdatePropertyFromReader(&dict_entry_reader);
}
return true;
}
bool PropertySet::UpdatePropertyFromReader(MessageReader* reader) {
DCHECK(reader);
std::string name;
if (!reader->PopString(&name))
return false;
PropertiesMap::iterator it = properties_map_.find(name);
if (it == properties_map_.end())
return false;
PropertyBase* property = it->second;
if (property->PopValueFromReader(reader)) {
property->set_valid(true);
NotifyPropertyChanged(name);
return true;
} else {
if (property->is_valid()) {
property->set_valid(false);
NotifyPropertyChanged(property->name());
}
return false;
}
}
bool PropertySet::InvalidatePropertiesFromReader(MessageReader* reader) {
DCHECK(reader);
MessageReader array_reader(nullptr);
if (!reader->PopArray(&array_reader))
return false;
while (array_reader.HasMoreData()) {
std::string name;
if (!array_reader.PopString(&name))
return false;
PropertiesMap::iterator it = properties_map_.find(name);
if (it == properties_map_.end())
continue;
PropertyBase* property = it->second;
if (property->is_valid()) {
property->set_valid(false);
NotifyPropertyChanged(property->name());
}
}
return true;
}
void PropertySet::NotifyPropertyChanged(const std::string& name) {
if (!property_changed_callback_.is_null())
property_changed_callback_.Run(name);
}
//
// Property<Byte> specialization.
//
template <>
Property<uint8_t>::Property()
: value_(0) {}
template <>
bool Property<uint8_t>::PopValueFromReader(MessageReader* reader) {
return reader->PopVariantOfByte(&value_);
}
template <>
void Property<uint8_t>::AppendSetValueToWriter(MessageWriter* writer) {
writer->AppendVariantOfByte(set_value_);
}
//
// Property<bool> specialization.
//
template <>
Property<bool>::Property() : value_(false) {
}
template <>
bool Property<bool>::PopValueFromReader(MessageReader* reader) {
return reader->PopVariantOfBool(&value_);
}
template <>
void Property<bool>::AppendSetValueToWriter(MessageWriter* writer) {
writer->AppendVariantOfBool(set_value_);
}
//
// Property<int16_t> specialization.
//
template <>
Property<int16_t>::Property()
: value_(0) {}
template <>
bool Property<int16_t>::PopValueFromReader(MessageReader* reader) {
return reader->PopVariantOfInt16(&value_);
}
template <>
void Property<int16_t>::AppendSetValueToWriter(MessageWriter* writer) {
writer->AppendVariantOfInt16(set_value_);
}
//
// Property<uint16_t> specialization.
//
template <>
Property<uint16_t>::Property()
: value_(0) {}
template <>
bool Property<uint16_t>::PopValueFromReader(MessageReader* reader) {
return reader->PopVariantOfUint16(&value_);
}
template <>
void Property<uint16_t>::AppendSetValueToWriter(MessageWriter* writer) {
writer->AppendVariantOfUint16(set_value_);
}
//
// Property<int32_t> specialization.
//
template <>
Property<int32_t>::Property()
: value_(0) {}
template <>
bool Property<int32_t>::PopValueFromReader(MessageReader* reader) {
return reader->PopVariantOfInt32(&value_);
}
template <>
void Property<int32_t>::AppendSetValueToWriter(MessageWriter* writer) {
writer->AppendVariantOfInt32(set_value_);
}
//
// Property<uint32_t> specialization.
//
template <>
Property<uint32_t>::Property()
: value_(0) {}
template <>
bool Property<uint32_t>::PopValueFromReader(MessageReader* reader) {
return reader->PopVariantOfUint32(&value_);
}
template <>
void Property<uint32_t>::AppendSetValueToWriter(MessageWriter* writer) {
writer->AppendVariantOfUint32(set_value_);
}
//
// Property<int64_t> specialization.
//
template <>
Property<int64_t>::Property()
: value_(0), set_value_(0) {}
template <>
bool Property<int64_t>::PopValueFromReader(MessageReader* reader) {
return reader->PopVariantOfInt64(&value_);
}
template <>
void Property<int64_t>::AppendSetValueToWriter(MessageWriter* writer) {
writer->AppendVariantOfInt64(set_value_);
}
//
// Property<uint64_t> specialization.
//
template <>
Property<uint64_t>::Property()
: value_(0) {}
template <>
bool Property<uint64_t>::PopValueFromReader(MessageReader* reader) {
return reader->PopVariantOfUint64(&value_);
}
template <>
void Property<uint64_t>::AppendSetValueToWriter(MessageWriter* writer) {
writer->AppendVariantOfUint64(set_value_);
}
//
// Property<double> specialization.
//
template <>
Property<double>::Property() : value_(0.0) {
}
template <>
bool Property<double>::PopValueFromReader(MessageReader* reader) {
return reader->PopVariantOfDouble(&value_);
}
template <>
void Property<double>::AppendSetValueToWriter(MessageWriter* writer) {
writer->AppendVariantOfDouble(set_value_);
}
//
// Property<std::string> specialization.
//
template <>
bool Property<std::string>::PopValueFromReader(MessageReader* reader) {
return reader->PopVariantOfString(&value_);
}
template <>
void Property<std::string>::AppendSetValueToWriter(MessageWriter* writer) {
writer->AppendVariantOfString(set_value_);
}
//
// Property<ObjectPath> specialization.
//
template <>
bool Property<ObjectPath>::PopValueFromReader(MessageReader* reader) {
return reader->PopVariantOfObjectPath(&value_);
}
template <>
void Property<ObjectPath>::AppendSetValueToWriter(MessageWriter* writer) {
writer->AppendVariantOfObjectPath(set_value_);
}
//
// Property<std::vector<std::string>> specialization.
//
template <>
bool Property<std::vector<std::string>>::PopValueFromReader(
MessageReader* reader) {
MessageReader variant_reader(nullptr);
if (!reader->PopVariant(&variant_reader))
return false;
value_.clear();
return variant_reader.PopArrayOfStrings(&value_);
}
template <>
void Property<std::vector<std::string>>::AppendSetValueToWriter(
MessageWriter* writer) {
MessageWriter variant_writer(nullptr);
writer->OpenVariant("as", &variant_writer);
variant_writer.AppendArrayOfStrings(set_value_);
writer->CloseContainer(&variant_writer);
}
//
// Property<std::vector<ObjectPath>> specialization.
//
template <>
bool Property<std::vector<ObjectPath>>::PopValueFromReader(
MessageReader* reader) {
MessageReader variant_reader(nullptr);
if (!reader->PopVariant(&variant_reader))
return false;
value_.clear();
return variant_reader.PopArrayOfObjectPaths(&value_);
}
template <>
void Property<std::vector<ObjectPath>>::AppendSetValueToWriter(
MessageWriter* writer) {
MessageWriter variant_writer(nullptr);
writer->OpenVariant("ao", &variant_writer);
variant_writer.AppendArrayOfObjectPaths(set_value_);
writer->CloseContainer(&variant_writer);
}
//
// Property<std::vector<uint8_t>> specialization.
//
template <>
bool Property<std::vector<uint8_t>>::PopValueFromReader(MessageReader* reader) {
MessageReader variant_reader(nullptr);
if (!reader->PopVariant(&variant_reader))
return false;
value_.clear();
const uint8_t* bytes = nullptr;
size_t length = 0;
if (!variant_reader.PopArrayOfBytes(&bytes, &length))
return false;
value_.assign(bytes, bytes + length);
return true;
}
template <>
void Property<std::vector<uint8_t>>::AppendSetValueToWriter(
MessageWriter* writer) {
MessageWriter variant_writer(nullptr);
writer->OpenVariant("ay", &variant_writer);
variant_writer.AppendArrayOfBytes(set_value_);
writer->CloseContainer(&variant_writer);
}
//
// Property<std::map<std::string, std::string>> specialization.
//
template <>
bool Property<std::map<std::string, std::string>>::PopValueFromReader(
MessageReader* reader) {
MessageReader variant_reader(nullptr);
MessageReader array_reader(nullptr);
if (!reader->PopVariant(&variant_reader) ||
!variant_reader.PopArray(&array_reader))
return false;
value_.clear();
while (array_reader.HasMoreData()) {
dbus::MessageReader dict_entry_reader(nullptr);
if (!array_reader.PopDictEntry(&dict_entry_reader))
return false;
std::string key;
std::string value;
if (!dict_entry_reader.PopString(&key) ||
!dict_entry_reader.PopString(&value))
return false;
value_[key] = value;
}
return true;
}
template <>
void Property<std::map<std::string, std::string>>::AppendSetValueToWriter(
MessageWriter* writer) {
MessageWriter variant_writer(nullptr);
MessageWriter dict_writer(nullptr);
writer->OpenVariant("a{ss}", &variant_writer);
variant_writer.OpenArray("{ss}", &dict_writer);
for (const auto& pair : set_value_) {
dbus::MessageWriter entry_writer(nullptr);
dict_writer.OpenDictEntry(&entry_writer);
entry_writer.AppendString(pair.first);
entry_writer.AppendString(pair.second);
dict_writer.CloseContainer(&entry_writer);
}
variant_writer.CloseContainer(&dict_writer);
writer->CloseContainer(&variant_writer);
}
//
// Property<std::vector<std::pair<std::vector<uint8_t>, uint16_t>>>
// specialization.
//
template <>
bool Property<std::vector<std::pair<std::vector<uint8_t>, uint16_t>>>::
PopValueFromReader(MessageReader* reader) {
MessageReader variant_reader(nullptr);
MessageReader array_reader(nullptr);
if (!reader->PopVariant(&variant_reader) ||
!variant_reader.PopArray(&array_reader))
return false;
value_.clear();
while (array_reader.HasMoreData()) {
dbus::MessageReader struct_reader(nullptr);
if (!array_reader.PopStruct(&struct_reader))
return false;
std::pair<std::vector<uint8_t>, uint16_t> entry;
const uint8_t* bytes = nullptr;
size_t length = 0;
if (!struct_reader.PopArrayOfBytes(&bytes, &length))
return false;
entry.first.assign(bytes, bytes + length);
if (!struct_reader.PopUint16(&entry.second))
return false;
value_.push_back(entry);
}
return true;
}
template <>
void Property<std::vector<std::pair<std::vector<uint8_t>, uint16_t>>>::
AppendSetValueToWriter(MessageWriter* writer) {
MessageWriter variant_writer(nullptr);
MessageWriter array_writer(nullptr);
writer->OpenVariant("a(ayq)", &variant_writer);
variant_writer.OpenArray("(ayq)", &array_writer);
for (const auto& pair : set_value_) {
dbus::MessageWriter struct_writer(nullptr);
array_writer.OpenStruct(&struct_writer);
struct_writer.AppendArrayOfBytes(std::get<0>(pair));
struct_writer.AppendUint16(std::get<1>(pair));
array_writer.CloseContainer(&struct_writer);
}
variant_writer.CloseContainer(&array_writer);
writer->CloseContainer(&variant_writer);
}
//
// Property<std::map<std::string, std::vector<uint8_t>>>
// specialization.
//
template <>
bool Property<std::map<std::string, std::vector<uint8_t>>>::PopValueFromReader(
MessageReader* reader) {
MessageReader variant_reader(nullptr);
MessageReader dict_reader(nullptr);
if (!reader->PopVariant(&variant_reader) ||
!variant_reader.PopArray(&dict_reader))
return false;
value_.clear();
while (dict_reader.HasMoreData()) {
MessageReader entry_reader(nullptr);
if (!dict_reader.PopDictEntry(&entry_reader))
return false;
std::string key;
if (!entry_reader.PopString(&key))
return false;
const uint8_t* bytes = nullptr;
size_t length = 0;
if (entry_reader.GetDataType() == Message::VARIANT) {
// Make BlueZ happy since it wraps the array of bytes with a variant.
MessageReader value_variant_reader(nullptr);
if (!entry_reader.PopVariant(&value_variant_reader))
return false;
if (!value_variant_reader.PopArrayOfBytes(&bytes, &length))
return false;
} else {
if (!entry_reader.PopArrayOfBytes(&bytes, &length))
return false;
}
value_[key].assign(bytes, bytes + length);
}
return true;
}
template <>
void Property<std::map<std::string, std::vector<uint8_t>>>::
AppendSetValueToWriter(MessageWriter* writer) {
MessageWriter variant_writer(nullptr);
MessageWriter dict_writer(nullptr);
writer->OpenVariant("a{sv}", &variant_writer);
variant_writer.OpenArray("{sv}", &dict_writer);
for (const auto& pair : set_value_) {
MessageWriter entry_writer(nullptr);
dict_writer.OpenDictEntry(&entry_writer);
entry_writer.AppendString(pair.first);
MessageWriter value_varient_writer(nullptr);
entry_writer.OpenVariant("ay", &value_varient_writer);
value_varient_writer.AppendArrayOfBytes(pair.second);
entry_writer.CloseContainer(&value_varient_writer);
dict_writer.CloseContainer(&entry_writer);
}
variant_writer.CloseContainer(&dict_writer);
writer->CloseContainer(&variant_writer);
}
//
// Property<std::map<uint16_t, std::vector<uint8_t>>>
// specialization.
//
template <>
bool Property<std::map<uint16_t, std::vector<uint8_t>>>::PopValueFromReader(
MessageReader* reader) {
MessageReader variant_reader(nullptr);
MessageReader dict_reader(nullptr);
if (!reader->PopVariant(&variant_reader) ||
!variant_reader.PopArray(&dict_reader))
return false;
value_.clear();
while (dict_reader.HasMoreData()) {
MessageReader entry_reader(nullptr);
if (!dict_reader.PopDictEntry(&entry_reader))
return false;
uint16_t key;
if (!entry_reader.PopUint16(&key))
return false;
const uint8_t* bytes = nullptr;
size_t length = 0;
if (entry_reader.GetDataType() == Message::VARIANT) {
// Make BlueZ happy since it wraps the array of bytes with a variant.
MessageReader value_variant_reader(nullptr);
if (!entry_reader.PopVariant(&value_variant_reader))
return false;
if (!value_variant_reader.PopArrayOfBytes(&bytes, &length))
return false;
} else {
if (!entry_reader.PopArrayOfBytes(&bytes, &length))
return false;
}
value_[key].assign(bytes, bytes + length);
}
return true;
}
template <>
void Property<std::map<uint16_t, std::vector<uint8_t>>>::AppendSetValueToWriter(
MessageWriter* writer) {
MessageWriter variant_writer(nullptr);
MessageWriter dict_writer(nullptr);
writer->OpenVariant("a{qv}", &variant_writer);
variant_writer.OpenArray("{qv}", &dict_writer);
for (const auto& pair : set_value_) {
MessageWriter entry_writer(nullptr);
dict_writer.OpenDictEntry(&entry_writer);
entry_writer.AppendUint16(pair.first);
MessageWriter value_varient_writer(nullptr);
entry_writer.OpenVariant("ay", &value_varient_writer);
value_varient_writer.AppendArrayOfBytes(pair.second);
entry_writer.CloseContainer(&value_varient_writer);
dict_writer.CloseContainer(&entry_writer);
}
variant_writer.CloseContainer(&dict_writer);
writer->CloseContainer(&variant_writer);
}
template class Property<uint8_t>;
template class Property<bool>;
template class Property<int16_t>;
template class Property<uint16_t>;
template class Property<int32_t>;
template class Property<uint32_t>;
template class Property<int64_t>;
template class Property<uint64_t>;
template class Property<double>;
template class Property<std::string>;
template class Property<ObjectPath>;
template class Property<std::vector<std::string>>;
template class Property<std::vector<ObjectPath>>;
template class Property<std::vector<uint8_t>>;
template class Property<std::map<std::string, std::string>>;
template class Property<std::vector<std::pair<std::vector<uint8_t>, uint16_t>>>;
template class Property<std::map<std::string, std::vector<uint8_t>>>;
template class Property<std::map<uint16_t, std::vector<uint8_t>>>;
} // namespace dbus