• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // Copyright (c) 2012 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/exported_object.h"
6 
7 #include <stdint.h>
8 #include <utility>
9 
10 #include "base/bind.h"
11 #include "base/logging.h"
12 #include "base/memory/ref_counted.h"
13 #include "base/metrics/histogram_macros.h"
14 #include "base/task_runner.h"
15 #include "base/threading/thread_restrictions.h"
16 #include "base/time/time.h"
17 #include "dbus/bus.h"
18 #include "dbus/message.h"
19 #include "dbus/object_path.h"
20 #include "dbus/scoped_dbus_error.h"
21 #include "dbus/util.h"
22 
23 namespace dbus {
24 
25 namespace {
26 
27 // Used for success ratio histograms. 1 for success, 0 for failure.
28 const int kSuccessRatioHistogramMaxValue = 2;
29 
30 }  // namespace
31 
ExportedObject(Bus * bus,const ObjectPath & object_path)32 ExportedObject::ExportedObject(Bus* bus,
33                                const ObjectPath& object_path)
34     : bus_(bus),
35       object_path_(object_path),
36       object_is_registered_(false) {
37   LOG_IF(FATAL, !object_path_.IsValid()) << object_path_.value();
38 }
39 
~ExportedObject()40 ExportedObject::~ExportedObject() {
41   DCHECK(!object_is_registered_);
42 }
43 
ExportMethodAndBlock(const std::string & interface_name,const std::string & method_name,MethodCallCallback method_call_callback)44 bool ExportedObject::ExportMethodAndBlock(
45     const std::string& interface_name,
46     const std::string& method_name,
47     MethodCallCallback method_call_callback) {
48   bus_->AssertOnDBusThread();
49 
50   // Check if the method is already exported.
51   const std::string absolute_method_name =
52       GetAbsoluteMemberName(interface_name, method_name);
53   if (method_table_.find(absolute_method_name) != method_table_.end()) {
54     LOG(ERROR) << absolute_method_name << " is already exported";
55     return false;
56   }
57 
58   if (!bus_->Connect())
59     return false;
60   if (!bus_->SetUpAsyncOperations())
61     return false;
62   if (!Register())
63     return false;
64 
65   // Add the method callback to the method table.
66   method_table_[absolute_method_name] = method_call_callback;
67 
68   return true;
69 }
70 
ExportMethod(const std::string & interface_name,const std::string & method_name,MethodCallCallback method_call_callback,OnExportedCallback on_exported_calback)71 void ExportedObject::ExportMethod(const std::string& interface_name,
72                                   const std::string& method_name,
73                                   MethodCallCallback method_call_callback,
74                                   OnExportedCallback on_exported_calback) {
75   bus_->AssertOnOriginThread();
76 
77   base::Closure task = base::Bind(&ExportedObject::ExportMethodInternal,
78                                   this,
79                                   interface_name,
80                                   method_name,
81                                   method_call_callback,
82                                   on_exported_calback);
83   bus_->GetDBusTaskRunner()->PostTask(FROM_HERE, task);
84 }
85 
SendSignal(Signal * signal)86 void ExportedObject::SendSignal(Signal* signal) {
87   // For signals, the object path should be set to the path to the sender
88   // object, which is this exported object here.
89   CHECK(signal->SetPath(object_path_));
90 
91   // Increment the reference count so we can safely reference the
92   // underlying signal message until the signal sending is complete. This
93   // will be unref'ed in SendSignalInternal().
94   DBusMessage* signal_message = signal->raw_message();
95   dbus_message_ref(signal_message);
96 
97   const base::TimeTicks start_time = base::TimeTicks::Now();
98   if (bus_->GetDBusTaskRunner()->RunsTasksInCurrentSequence()) {
99     // The Chrome OS power manager doesn't use a dedicated TaskRunner for
100     // sending DBus messages.  Sending signals asynchronously can cause an
101     // inversion in the message order if the power manager calls
102     // ObjectProxy::CallMethodAndBlock() before going back to the top level of
103     // the MessageLoop: crbug.com/472361.
104     SendSignalInternal(start_time, signal_message);
105   } else {
106     bus_->GetDBusTaskRunner()->PostTask(
107         FROM_HERE,
108         base::Bind(&ExportedObject::SendSignalInternal,
109                    this,
110                    start_time,
111                    signal_message));
112   }
113 }
114 
Unregister()115 void ExportedObject::Unregister() {
116   bus_->AssertOnDBusThread();
117 
118   if (!object_is_registered_)
119     return;
120 
121   bus_->UnregisterObjectPath(object_path_);
122   object_is_registered_ = false;
123 }
124 
ExportMethodInternal(const std::string & interface_name,const std::string & method_name,MethodCallCallback method_call_callback,OnExportedCallback on_exported_calback)125 void ExportedObject::ExportMethodInternal(
126     const std::string& interface_name,
127     const std::string& method_name,
128     MethodCallCallback method_call_callback,
129     OnExportedCallback on_exported_calback) {
130   bus_->AssertOnDBusThread();
131 
132   const bool success = ExportMethodAndBlock(interface_name,
133                                             method_name,
134                                             method_call_callback);
135   bus_->GetOriginTaskRunner()->PostTask(FROM_HERE,
136                                         base::Bind(&ExportedObject::OnExported,
137                                                    this,
138                                                    on_exported_calback,
139                                                    interface_name,
140                                                    method_name,
141                                                    success));
142 }
143 
OnExported(OnExportedCallback on_exported_callback,const std::string & interface_name,const std::string & method_name,bool success)144 void ExportedObject::OnExported(OnExportedCallback on_exported_callback,
145                                 const std::string& interface_name,
146                                 const std::string& method_name,
147                                 bool success) {
148   bus_->AssertOnOriginThread();
149 
150   on_exported_callback.Run(interface_name, method_name, success);
151 }
152 
SendSignalInternal(base::TimeTicks start_time,DBusMessage * signal_message)153 void ExportedObject::SendSignalInternal(base::TimeTicks start_time,
154                                         DBusMessage* signal_message) {
155   uint32_t serial = 0;
156   bus_->Send(signal_message, &serial);
157   dbus_message_unref(signal_message);
158   // Record time spent to send the the signal. This is not accurate as the
159   // signal will actually be sent from the next run of the message loop,
160   // but we can at least tell the number of signals sent.
161   UMA_HISTOGRAM_TIMES("DBus.SignalSendTime",
162                       base::TimeTicks::Now() - start_time);
163 }
164 
Register()165 bool ExportedObject::Register() {
166   bus_->AssertOnDBusThread();
167 
168   if (object_is_registered_)
169     return true;
170 
171   ScopedDBusError error;
172 
173   DBusObjectPathVTable vtable = {};
174   vtable.message_function = &ExportedObject::HandleMessageThunk;
175   vtable.unregister_function = &ExportedObject::OnUnregisteredThunk;
176   const bool success = bus_->TryRegisterObjectPath(object_path_,
177                                                    &vtable,
178                                                    this,
179                                                    error.get());
180   if (!success) {
181     LOG(ERROR) << "Failed to register the object: " << object_path_.value()
182                << ": " << (error.is_set() ? error.message() : "");
183     return false;
184   }
185 
186   object_is_registered_ = true;
187   return true;
188 }
189 
HandleMessage(DBusConnection * connection,DBusMessage * raw_message)190 DBusHandlerResult ExportedObject::HandleMessage(
191     DBusConnection* connection,
192     DBusMessage* raw_message) {
193   bus_->AssertOnDBusThread();
194   // ExportedObject only handles method calls. Ignore other message types (e.g.
195   // signal).
196   if (dbus_message_get_type(raw_message) != DBUS_MESSAGE_TYPE_METHOD_CALL)
197     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
198 
199   // raw_message will be unrefed on exit of the function. Increment the
200   // reference so we can use it in MethodCall.
201   dbus_message_ref(raw_message);
202   std::unique_ptr<MethodCall> method_call(
203       MethodCall::FromRawMessage(raw_message));
204   const std::string interface = method_call->GetInterface();
205   const std::string member = method_call->GetMember();
206 
207   if (interface.empty()) {
208     // We don't support method calls without interface.
209     LOG(WARNING) << "Interface is missing: " << method_call->ToString();
210     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
211   }
212 
213   // Check if we know about the method.
214   const std::string absolute_method_name = GetAbsoluteMemberName(
215       interface, member);
216   MethodTable::const_iterator iter = method_table_.find(absolute_method_name);
217   if (iter == method_table_.end()) {
218     // Don't know about the method.
219     LOG(WARNING) << "Unknown method: " << method_call->ToString();
220     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
221   }
222 
223   const base::TimeTicks start_time = base::TimeTicks::Now();
224   if (bus_->HasDBusThread()) {
225     // Post a task to run the method in the origin thread.
226     bus_->GetOriginTaskRunner()->PostTask(
227         FROM_HERE,
228         base::BindOnce(&ExportedObject::RunMethod, this, iter->second,
229                        std::move(method_call), start_time));
230   } else {
231     // If the D-Bus thread is not used, just call the method directly.
232     MethodCall* method = method_call.get();
233     iter->second.Run(method,
234                      base::Bind(&ExportedObject::SendResponse,
235                                 this,
236                                 start_time,
237                                 base::Passed(&method_call)));
238   }
239 
240   // It's valid to say HANDLED here, and send a method response at a later
241   // time from OnMethodCompleted() asynchronously.
242   return DBUS_HANDLER_RESULT_HANDLED;
243 }
244 
RunMethod(MethodCallCallback method_call_callback,std::unique_ptr<MethodCall> method_call,base::TimeTicks start_time)245 void ExportedObject::RunMethod(MethodCallCallback method_call_callback,
246                                std::unique_ptr<MethodCall> method_call,
247                                base::TimeTicks start_time) {
248   bus_->AssertOnOriginThread();
249   MethodCall* method = method_call.get();
250   method_call_callback.Run(method,
251                            base::Bind(&ExportedObject::SendResponse,
252                                       this,
253                                       start_time,
254                                       base::Passed(&method_call)));
255 }
256 
SendResponse(base::TimeTicks start_time,std::unique_ptr<MethodCall> method_call,std::unique_ptr<Response> response)257 void ExportedObject::SendResponse(base::TimeTicks start_time,
258                                   std::unique_ptr<MethodCall> method_call,
259                                   std::unique_ptr<Response> response) {
260   DCHECK(method_call);
261   if (bus_->HasDBusThread()) {
262     bus_->GetDBusTaskRunner()->PostTask(
263         FROM_HERE, base::BindOnce(&ExportedObject::OnMethodCompleted, this,
264                                   std::move(method_call), std::move(response),
265                                   start_time));
266   } else {
267     OnMethodCompleted(std::move(method_call), std::move(response), start_time);
268   }
269 }
270 
OnMethodCompleted(std::unique_ptr<MethodCall> method_call,std::unique_ptr<Response> response,base::TimeTicks start_time)271 void ExportedObject::OnMethodCompleted(std::unique_ptr<MethodCall> method_call,
272                                        std::unique_ptr<Response> response,
273                                        base::TimeTicks start_time) {
274   bus_->AssertOnDBusThread();
275 
276   // Record if the method call is successful, or not. 1 if successful.
277   UMA_HISTOGRAM_ENUMERATION("DBus.ExportedMethodHandleSuccess",
278                             response ? 1 : 0,
279                             kSuccessRatioHistogramMaxValue);
280 
281   // Check if the bus is still connected. If the method takes long to
282   // complete, the bus may be shut down meanwhile.
283   if (!bus_->is_connected())
284     return;
285 
286   if (!response) {
287     // Something bad happened in the method call.
288     std::unique_ptr<ErrorResponse> error_response(ErrorResponse::FromMethodCall(
289         method_call.get(), DBUS_ERROR_FAILED,
290         "error occurred in " + method_call->GetMember()));
291     bus_->Send(error_response->raw_message(), nullptr);
292     return;
293   }
294 
295   // The method call was successful.
296   bus_->Send(response->raw_message(), nullptr);
297 
298   // Record time spent to handle the the method call. Don't include failures.
299   UMA_HISTOGRAM_TIMES("DBus.ExportedMethodHandleTime",
300                       base::TimeTicks::Now() - start_time);
301 }
302 
OnUnregistered(DBusConnection * connection)303 void ExportedObject::OnUnregistered(DBusConnection* connection) {
304 }
305 
HandleMessageThunk(DBusConnection * connection,DBusMessage * raw_message,void * user_data)306 DBusHandlerResult ExportedObject::HandleMessageThunk(
307     DBusConnection* connection,
308     DBusMessage* raw_message,
309     void* user_data) {
310   ExportedObject* self = reinterpret_cast<ExportedObject*>(user_data);
311   return self->HandleMessage(connection, raw_message);
312 }
313 
OnUnregisteredThunk(DBusConnection * connection,void * user_data)314 void ExportedObject::OnUnregisteredThunk(DBusConnection *connection,
315                                          void* user_data) {
316   ExportedObject* self = reinterpret_cast<ExportedObject*>(user_data);
317   return self->OnUnregistered(connection);
318 }
319 
320 }  // namespace dbus
321