Home | History | Annotate | Download | only in dbus 
      1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "dbus/object_manager.h"
      6 
      7 #include "base/bind.h"
      8 #include "base/location.h"
      9 #include "base/logging.h"
     10 #include "base/metrics/histogram.h"
     11 #include "base/strings/stringprintf.h"
     12 #include "base/task_runner_util.h"
     13 #include "dbus/bus.h"
     14 #include "dbus/dbus_statistics.h"
     15 #include "dbus/message.h"
     16 #include "dbus/object_proxy.h"
     17 #include "dbus/property.h"
     18 #include "dbus/scoped_dbus_error.h"
     19 #include "dbus/util.h"
     20 
     21 namespace dbus {
     22 
     23 ObjectManager::Object::Object()
     24   : object_proxy(NULL) {
     25 }
     26 
     27 ObjectManager::Object::~Object() {
     28 }
     29 
     30 ObjectManager::ObjectManager(Bus* bus,
     31                              const std::string& service_name,
     32                              const ObjectPath& object_path)
     33     : bus_(bus),
     34       service_name_(service_name),
     35       object_path_(object_path),
     36       setup_success_(false),
     37       cleanup_called_(false),
     38       weak_ptr_factory_(this) {
     39   DVLOG(1) << "Creating ObjectManager for " << service_name_
     40            << " " << object_path_.value();
     41   DCHECK(bus_);
     42   bus_->AssertOnOriginThread();
     43   object_proxy_ = bus_->GetObjectProxy(service_name_, object_path_);
     44   object_proxy_->SetNameOwnerChangedCallback(
     45       base::Bind(&ObjectManager::NameOwnerChanged,
     46                  weak_ptr_factory_.GetWeakPtr()));
     47 
     48   // Set up a match rule and a filter function to handle PropertiesChanged
     49   // signals from the service. This is important to avoid any race conditions
     50   // that might cause us to miss PropertiesChanged signals once all objects are
     51   // initialized via GetManagedObjects.
     52   base::PostTaskAndReplyWithResult(
     53       bus_->GetDBusTaskRunner(),
     54       FROM_HERE,
     55       base::Bind(&ObjectManager::SetupMatchRuleAndFilter, this),
     56       base::Bind(&ObjectManager::OnSetupMatchRuleAndFilterComplete, this));
     57 }
     58 
     59 ObjectManager::~ObjectManager() {
     60   // Clean up Object structures
     61   for (ObjectMap::iterator iter = object_map_.begin();
     62        iter != object_map_.end(); ++iter) {
     63     Object* object = iter->second;
     64 
     65     for (Object::PropertiesMap::iterator piter = object->properties_map.begin();
     66          piter != object->properties_map.end(); ++piter) {
     67       PropertySet* properties = piter->second;
     68       delete properties;
     69     }
     70 
     71     delete object;
     72   }
     73 }
     74 
     75 void ObjectManager::RegisterInterface(const std::string& interface_name,
     76                                       Interface* interface) {
     77   interface_map_[interface_name] = interface;
     78 }
     79 
     80 void ObjectManager::UnregisterInterface(const std::string& interface_name) {
     81   InterfaceMap::iterator iter = interface_map_.find(interface_name);
     82   if (iter != interface_map_.end())
     83     interface_map_.erase(iter);
     84 }
     85 
     86 std::vector<ObjectPath> ObjectManager::GetObjects() {
     87   std::vector<ObjectPath> object_paths;
     88 
     89   for (ObjectMap::iterator iter = object_map_.begin();
     90        iter != object_map_.end(); ++iter)
     91     object_paths.push_back(iter->first);
     92 
     93   return object_paths;
     94 }
     95 
     96 std::vector<ObjectPath> ObjectManager::GetObjectsWithInterface(
     97       const std::string& interface_name) {
     98   std::vector<ObjectPath> object_paths;
     99 
    100   for (ObjectMap::iterator oiter = object_map_.begin();
    101        oiter != object_map_.end(); ++oiter) {
    102     Object* object = oiter->second;
    103 
    104     Object::PropertiesMap::iterator piter =
    105         object->properties_map.find(interface_name);
    106     if (piter != object->properties_map.end())
    107       object_paths.push_back(oiter->first);
    108   }
    109 
    110   return object_paths;
    111 }
    112 
    113 ObjectProxy* ObjectManager::GetObjectProxy(const ObjectPath& object_path) {
    114   ObjectMap::iterator iter = object_map_.find(object_path);
    115   if (iter == object_map_.end())
    116     return NULL;
    117 
    118   Object* object = iter->second;
    119   return object->object_proxy;
    120 }
    121 
    122 PropertySet* ObjectManager::GetProperties(const ObjectPath& object_path,
    123                                           const std::string& interface_name) {
    124   ObjectMap::iterator iter = object_map_.find(object_path);
    125   if (iter == object_map_.end())
    126     return NULL;
    127 
    128   Object* object = iter->second;
    129   Object::PropertiesMap::iterator piter =
    130       object->properties_map.find(interface_name);
    131   if (piter == object->properties_map.end())
    132     return NULL;
    133 
    134   return piter->second;
    135 }
    136 
    137 void ObjectManager::GetManagedObjects() {
    138   MethodCall method_call(kObjectManagerInterface,
    139                          kObjectManagerGetManagedObjects);
    140 
    141   object_proxy_->CallMethod(
    142       &method_call,
    143       ObjectProxy::TIMEOUT_USE_DEFAULT,
    144       base::Bind(&ObjectManager::OnGetManagedObjects,
    145                  weak_ptr_factory_.GetWeakPtr()));
    146 }
    147 
    148 void ObjectManager::CleanUp() {
    149   DCHECK(bus_);
    150   bus_->AssertOnDBusThread();
    151   DCHECK(!cleanup_called_);
    152 
    153   cleanup_called_ = true;
    154 
    155   if (!setup_success_)
    156     return;
    157 
    158   if (!bus_->RemoveFilterFunction(&ObjectManager::HandleMessageThunk, this))
    159     LOG(ERROR) << "Failed to remove filter function";
    160 
    161   ScopedDBusError error;
    162   bus_->RemoveMatch(match_rule_, error.get());
    163   if (error.is_set())
    164     LOG(ERROR) << "Failed to remove match rule: " << match_rule_;
    165 
    166   match_rule_.clear();
    167 }
    168 
    169 void ObjectManager::InitializeObjects() {
    170   DCHECK(bus_);
    171   DCHECK(object_proxy_);
    172   DCHECK(setup_success_);
    173 
    174   // |object_proxy_| is no longer valid if the Bus was shut down before this
    175   // call. Don't initiate any other action from the origin thread.
    176   if (cleanup_called_)
    177     return;
    178 
    179   object_proxy_->ConnectToSignal(
    180       kObjectManagerInterface,
    181       kObjectManagerInterfacesAdded,
    182       base::Bind(&ObjectManager::InterfacesAddedReceived,
    183                  weak_ptr_factory_.GetWeakPtr()),
    184       base::Bind(&ObjectManager::InterfacesAddedConnected,
    185                  weak_ptr_factory_.GetWeakPtr()));
    186 
    187   object_proxy_->ConnectToSignal(
    188       kObjectManagerInterface,
    189       kObjectManagerInterfacesRemoved,
    190       base::Bind(&ObjectManager::InterfacesRemovedReceived,
    191                  weak_ptr_factory_.GetWeakPtr()),
    192       base::Bind(&ObjectManager::InterfacesRemovedConnected,
    193                  weak_ptr_factory_.GetWeakPtr()));
    194 
    195   GetManagedObjects();
    196 }
    197 
    198 bool ObjectManager::SetupMatchRuleAndFilter() {
    199   DCHECK(bus_);
    200   DCHECK(!setup_success_);
    201   bus_->AssertOnDBusThread();
    202 
    203   if (cleanup_called_)
    204     return false;
    205 
    206   if (!bus_->Connect() || !bus_->SetUpAsyncOperations())
    207     return false;
    208 
    209   service_name_owner_ =
    210       bus_->GetServiceOwnerAndBlock(service_name_, Bus::SUPPRESS_ERRORS);
    211 
    212   const std::string match_rule =
    213       base::StringPrintf(
    214           "type='signal', sender='%s', interface='%s', member='%s'",
    215           service_name_.c_str(),
    216           kPropertiesInterface,
    217           kPropertiesChanged);
    218 
    219   if (!bus_->AddFilterFunction(&ObjectManager::HandleMessageThunk, this)) {
    220     LOG(ERROR) << "ObjectManager failed to add filter function";
    221     return false;
    222   }
    223 
    224   ScopedDBusError error;
    225   bus_->AddMatch(match_rule, error.get());
    226   if (error.is_set()) {
    227     LOG(ERROR) << "ObjectManager failed to add match rule \"" << match_rule
    228                << "\". Got " << error.name() << ": " << error.message();
    229     bus_->RemoveFilterFunction(&ObjectManager::HandleMessageThunk, this);
    230     return false;
    231   }
    232 
    233   match_rule_ = match_rule;
    234   setup_success_ = true;
    235 
    236   return true;
    237 }
    238 
    239 void ObjectManager::OnSetupMatchRuleAndFilterComplete(bool success) {
    240   LOG_IF(WARNING, !success) << service_name_ << " " << object_path_.value()
    241                             << ": Failed to set up match rule.";
    242   if (success)
    243     InitializeObjects();
    244 }
    245 
    246 // static
    247 DBusHandlerResult ObjectManager::HandleMessageThunk(DBusConnection* connection,
    248                                                     DBusMessage* raw_message,
    249                                                     void* user_data) {
    250   ObjectManager* self = reinterpret_cast<ObjectManager*>(user_data);
    251   return self->HandleMessage(connection, raw_message);
    252 }
    253 
    254 DBusHandlerResult ObjectManager::HandleMessage(DBusConnection* connection,
    255                                                DBusMessage* raw_message) {
    256   DCHECK(bus_);
    257   bus_->AssertOnDBusThread();
    258 
    259   if (dbus_message_get_type(raw_message) != DBUS_MESSAGE_TYPE_SIGNAL)
    260     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
    261 
    262   // raw_message will be unrefed on exit of the function. Increment the
    263   // reference so we can use it in Signal.
    264   dbus_message_ref(raw_message);
    265   scoped_ptr<Signal> signal(
    266       Signal::FromRawMessage(raw_message));
    267 
    268   const std::string interface = signal->GetInterface();
    269   const std::string member = signal->GetMember();
    270 
    271   statistics::AddReceivedSignal(service_name_, interface, member);
    272 
    273   // Only handle the PropertiesChanged signal.
    274   const std::string absolute_signal_name =
    275       GetAbsoluteMemberName(interface, member);
    276   const std::string properties_changed_signal_name =
    277       GetAbsoluteMemberName(kPropertiesInterface, kPropertiesChanged);
    278   if (absolute_signal_name != properties_changed_signal_name)
    279     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
    280 
    281   VLOG(1) << "Signal received: " << signal->ToString();
    282 
    283   // Make sure that the signal originated from the correct sender.
    284   std::string sender = signal->GetSender();
    285   if (service_name_owner_ != sender) {
    286     LOG(ERROR) << "Rejecting a message from a wrong sender.";
    287     UMA_HISTOGRAM_COUNTS("DBus.RejectedSignalCount", 1);
    288     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
    289   }
    290 
    291   const ObjectPath path = signal->GetPath();
    292 
    293   if (bus_->HasDBusThread()) {
    294     // Post a task to run the method in the origin thread. Transfer ownership of
    295     // |signal| to NotifyPropertiesChanged, which will handle the clean up.
    296     Signal* released_signal = signal.release();
    297     bus_->GetOriginTaskRunner()->PostTask(
    298         FROM_HERE,
    299         base::Bind(&ObjectManager::NotifyPropertiesChanged,
    300                    this, path,
    301                    released_signal));
    302   } else {
    303     // If the D-Bus thread is not used, just call the callback on the
    304     // current thread. Transfer the ownership of |signal| to
    305     // NotifyPropertiesChanged.
    306     NotifyPropertiesChanged(path, signal.release());
    307   }
    308 
    309   // We don't return DBUS_HANDLER_RESULT_HANDLED for signals because other
    310   // objects may be interested in them. (e.g. Signals from org.freedesktop.DBus)
    311   return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
    312 }
    313 
    314 void ObjectManager::NotifyPropertiesChanged(
    315     const dbus::ObjectPath object_path,
    316     Signal* signal) {
    317   DCHECK(bus_);
    318   bus_->AssertOnOriginThread();
    319 
    320   NotifyPropertiesChangedHelper(object_path, signal);
    321 
    322   // Delete the message on the D-Bus thread. See comments in HandleMessage.
    323   bus_->GetDBusTaskRunner()->PostTask(
    324       FROM_HERE,
    325       base::Bind(&base::DeletePointer<Signal>, signal));
    326 }
    327 
    328 void ObjectManager::NotifyPropertiesChangedHelper(
    329     const dbus::ObjectPath object_path,
    330     Signal* signal) {
    331   DCHECK(bus_);
    332   bus_->AssertOnOriginThread();
    333 
    334   MessageReader reader(signal);
    335   std::string interface;
    336   if (!reader.PopString(&interface)) {
    337     LOG(WARNING) << "Property changed signal has wrong parameters: "
    338                  << "expected interface name: " << signal->ToString();
    339     return;
    340   }
    341 
    342   PropertySet* properties = GetProperties(object_path, interface);
    343   if (properties)
    344     properties->ChangedReceived(signal);
    345 }
    346 
    347 void ObjectManager::OnGetManagedObjects(Response* response) {
    348   if (response != NULL) {
    349     MessageReader reader(response);
    350     MessageReader array_reader(NULL);
    351     if (!reader.PopArray(&array_reader))
    352       return;
    353 
    354     while (array_reader.HasMoreData()) {
    355       MessageReader dict_entry_reader(NULL);
    356       ObjectPath object_path;
    357       if (!array_reader.PopDictEntry(&dict_entry_reader) ||
    358           !dict_entry_reader.PopObjectPath(&object_path))
    359         continue;
    360 
    361       UpdateObject(object_path, &dict_entry_reader);
    362     }
    363 
    364   } else {
    365     LOG(WARNING) << service_name_ << " " << object_path_.value()
    366                  << ": Failed to get managed objects";
    367   }
    368 }
    369 
    370 void ObjectManager::InterfacesAddedReceived(Signal* signal) {
    371   DCHECK(signal);
    372   MessageReader reader(signal);
    373   ObjectPath object_path;
    374   if (!reader.PopObjectPath(&object_path)) {
    375     LOG(WARNING) << service_name_ << " " << object_path_.value()
    376                  << ": InterfacesAdded signal has incorrect parameters: "
    377                  << signal->ToString();
    378     return;
    379   }
    380 
    381   UpdateObject(object_path, &reader);
    382 }
    383 
    384 void ObjectManager::InterfacesAddedConnected(const std::string& interface_name,
    385                                              const std::string& signal_name,
    386                                              bool success) {
    387   LOG_IF(WARNING, !success) << service_name_ << " " << object_path_.value()
    388                             << ": Failed to connect to InterfacesAdded signal.";
    389 }
    390 
    391 void ObjectManager::InterfacesRemovedReceived(Signal* signal) {
    392   DCHECK(signal);
    393   MessageReader reader(signal);
    394   ObjectPath object_path;
    395   std::vector<std::string> interface_names;
    396   if (!reader.PopObjectPath(&object_path) ||
    397       !reader.PopArrayOfStrings(&interface_names)) {
    398     LOG(WARNING) << service_name_ << " " << object_path_.value()
    399                  << ": InterfacesRemoved signal has incorrect parameters: "
    400                  << signal->ToString();
    401     return;
    402   }
    403 
    404   for (size_t i = 0; i < interface_names.size(); ++i)
    405     RemoveInterface(object_path, interface_names[i]);
    406 }
    407 
    408 void ObjectManager::InterfacesRemovedConnected(
    409     const std::string& interface_name,
    410     const std::string& signal_name,
    411     bool success) {
    412   LOG_IF(WARNING, !success) << service_name_ << " " << object_path_.value()
    413                             << ": Failed to connect to "
    414                             << "InterfacesRemoved signal.";
    415 }
    416 
    417 void ObjectManager::UpdateObject(const ObjectPath& object_path,
    418                                  MessageReader* reader) {
    419   DCHECK(reader);
    420   MessageReader array_reader(NULL);
    421   if (!reader->PopArray(&array_reader))
    422     return;
    423 
    424   while (array_reader.HasMoreData()) {
    425     MessageReader dict_entry_reader(NULL);
    426     std::string interface_name;
    427     if (!array_reader.PopDictEntry(&dict_entry_reader) ||
    428         !dict_entry_reader.PopString(&interface_name))
    429       continue;
    430 
    431     AddInterface(object_path, interface_name, &dict_entry_reader);
    432   }
    433 }
    434 
    435 
    436 void ObjectManager::AddInterface(const ObjectPath& object_path,
    437                                  const std::string& interface_name,
    438                                  MessageReader* reader) {
    439   InterfaceMap::iterator iiter = interface_map_.find(interface_name);
    440   if (iiter == interface_map_.end())
    441     return;
    442   Interface* interface = iiter->second;
    443 
    444   ObjectMap::iterator oiter = object_map_.find(object_path);
    445   Object* object;
    446   if (oiter == object_map_.end()) {
    447     object = object_map_[object_path] = new Object;
    448     object->object_proxy = bus_->GetObjectProxy(service_name_, object_path);
    449   } else
    450     object = oiter->second;
    451 
    452   Object::PropertiesMap::iterator piter =
    453       object->properties_map.find(interface_name);
    454   PropertySet* property_set;
    455   const bool interface_added = (piter == object->properties_map.end());
    456   if (interface_added) {
    457     property_set = object->properties_map[interface_name] =
    458         interface->CreateProperties(object->object_proxy,
    459                                     object_path, interface_name);
    460   } else
    461     property_set = piter->second;
    462 
    463   property_set->UpdatePropertiesFromReader(reader);
    464 
    465   if (interface_added)
    466     interface->ObjectAdded(object_path, interface_name);
    467 }
    468 
    469 void ObjectManager::RemoveInterface(const ObjectPath& object_path,
    470                                     const std::string& interface_name) {
    471   ObjectMap::iterator oiter = object_map_.find(object_path);
    472   if (oiter == object_map_.end())
    473     return;
    474   Object* object = oiter->second;
    475 
    476   Object::PropertiesMap::iterator piter =
    477       object->properties_map.find(interface_name);
    478   if (piter == object->properties_map.end())
    479     return;
    480 
    481   // Inform the interface before removing the properties structure or object
    482   // in case it needs details from them to make its own decisions.
    483   InterfaceMap::iterator iiter = interface_map_.find(interface_name);
    484   if (iiter != interface_map_.end()) {
    485     Interface* interface = iiter->second;
    486     interface->ObjectRemoved(object_path, interface_name);
    487   }
    488 
    489   object->properties_map.erase(piter);
    490 
    491   if (object->properties_map.empty()) {
    492     object_map_.erase(oiter);
    493     delete object;
    494   }
    495 }
    496 
    497 void ObjectManager::NameOwnerChanged(const std::string& old_owner,
    498                                      const std::string& new_owner) {
    499   service_name_owner_ = new_owner;
    500 
    501   if (!old_owner.empty()) {
    502     ObjectMap::iterator iter = object_map_.begin();
    503     while (iter != object_map_.end()) {
    504       ObjectMap::iterator tmp = iter;
    505       ++iter;
    506 
    507       // PropertiesMap is mutated by RemoveInterface, and also Object is
    508       // destroyed; easier to collect the object path and interface names
    509       // and remove them safely.
    510       const dbus::ObjectPath object_path = tmp->first;
    511       Object* object = tmp->second;
    512       std::vector<std::string> interfaces;
    513 
    514       for (Object::PropertiesMap::iterator piter =
    515               object->properties_map.begin();
    516            piter != object->properties_map.end(); ++piter)
    517         interfaces.push_back(piter->first);
    518 
    519       for (std::vector<std::string>::iterator iiter = interfaces.begin();
    520            iiter != interfaces.end(); ++iiter)
    521         RemoveInterface(object_path, *iiter);
    522     }
    523 
    524   }
    525 
    526   if (!new_owner.empty())
    527     GetManagedObjects();
    528 }
    529 
    530 }  // namespace dbus
    531