Branch data Line data Source code
1 : : /*
2 : : * WPA Supplicant / dbus-based control interface
3 : : * Copyright (c) 2006, Dan Williams <dcbw@redhat.com> and Red Hat, Inc.
4 : : * Copyright (c) 2009, Witold Sowa <witold.sowa@gmail.com>
5 : : *
6 : : * This software may be distributed under the terms of the BSD license.
7 : : * See README for more details.
8 : : */
9 : :
10 : : #include "utils/includes.h"
11 : :
12 : : #include "utils/common.h"
13 : : #include "utils/eloop.h"
14 : : #include "dbus_common.h"
15 : : #include "dbus_common_i.h"
16 : : #include "dbus_new.h"
17 : : #include "dbus_new_helpers.h"
18 : : #include "dbus_dict_helpers.h"
19 : :
20 : :
21 : 0 : static dbus_bool_t fill_dict_with_properties(
22 : : DBusMessageIter *dict_iter,
23 : : const struct wpa_dbus_property_desc *props,
24 : : const char *interface, void *user_data, DBusError *error)
25 : : {
26 : : DBusMessageIter entry_iter;
27 : : const struct wpa_dbus_property_desc *dsc;
28 : :
29 [ # # ][ # # ]: 0 : for (dsc = props; dsc && dsc->dbus_property; dsc++) {
30 : : /* Only return properties for the requested D-Bus interface */
31 [ # # ]: 0 : if (os_strncmp(dsc->dbus_interface, interface,
32 : : WPAS_DBUS_INTERFACE_MAX) != 0)
33 : 0 : continue;
34 : :
35 : : /* Skip write-only properties */
36 [ # # ]: 0 : if (dsc->getter == NULL)
37 : 0 : continue;
38 : :
39 [ # # ]: 0 : if (!dbus_message_iter_open_container(dict_iter,
40 : : DBUS_TYPE_DICT_ENTRY,
41 : : NULL, &entry_iter)) {
42 : 0 : dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY,
43 : : "no memory");
44 : 0 : return FALSE;
45 : : }
46 [ # # ]: 0 : if (!dbus_message_iter_append_basic(&entry_iter,
47 : : DBUS_TYPE_STRING,
48 : 0 : &dsc->dbus_property)) {
49 : 0 : dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY,
50 : : "no memory");
51 : 0 : return FALSE;
52 : : }
53 : :
54 : : /* An error getting a property fails the request entirely */
55 [ # # ]: 0 : if (!dsc->getter(&entry_iter, error, user_data))
56 : 0 : return FALSE;
57 : :
58 : 0 : dbus_message_iter_close_container(dict_iter, &entry_iter);
59 : : }
60 : :
61 : 0 : return TRUE;
62 : : }
63 : :
64 : :
65 : : /**
66 : : * get_all_properties - Responds for GetAll properties calls on object
67 : : * @message: Message with GetAll call
68 : : * @interface: interface name which properties will be returned
69 : : * @property_dsc: list of object's properties
70 : : * Returns: Message with dict of variants as argument with properties values
71 : : *
72 : : * Iterates over all properties registered with object and execute getters
73 : : * of those, which are readable and which interface matches interface
74 : : * specified as argument. Returned message contains one dict argument
75 : : * with properties names as keys and theirs values as values.
76 : : */
77 : 0 : static DBusMessage * get_all_properties(DBusMessage *message, char *interface,
78 : : struct wpa_dbus_object_desc *obj_dsc)
79 : : {
80 : : DBusMessage *reply;
81 : : DBusMessageIter iter, dict_iter;
82 : : DBusError error;
83 : :
84 : 0 : reply = dbus_message_new_method_return(message);
85 [ # # ]: 0 : if (reply == NULL) {
86 : 0 : wpa_printf(MSG_ERROR, "%s: out of memory creating dbus reply",
87 : : __func__);
88 : 0 : return NULL;
89 : : }
90 : :
91 : 0 : dbus_message_iter_init_append(reply, &iter);
92 [ # # ]: 0 : if (!wpa_dbus_dict_open_write(&iter, &dict_iter)) {
93 : 0 : wpa_printf(MSG_ERROR, "%s: out of memory creating reply",
94 : : __func__);
95 : 0 : dbus_message_unref(reply);
96 : 0 : reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
97 : : "out of memory");
98 : 0 : return reply;
99 : : }
100 : :
101 : 0 : dbus_error_init(&error);
102 [ # # ]: 0 : if (!fill_dict_with_properties(&dict_iter, obj_dsc->properties,
103 : : interface, obj_dsc->user_data, &error))
104 : : {
105 : 0 : dbus_message_unref(reply);
106 : 0 : reply = wpas_dbus_reply_new_from_error(message, &error,
107 : : DBUS_ERROR_INVALID_ARGS,
108 : : "No readable properties"
109 : : " in this interface");
110 : 0 : dbus_error_free(&error);
111 : 0 : return reply;
112 : : }
113 : :
114 : 0 : wpa_dbus_dict_close_write(&iter, &dict_iter);
115 : 0 : return reply;
116 : : }
117 : :
118 : :
119 : 0 : static int is_signature_correct(DBusMessage *message,
120 : : const struct wpa_dbus_method_desc *method_dsc)
121 : : {
122 : : /* According to DBus documentation max length of signature is 255 */
123 : : #define MAX_SIG_LEN 256
124 : : char registered_sig[MAX_SIG_LEN], *pos;
125 : 0 : const char *sig = dbus_message_get_signature(message);
126 : : int ret;
127 : : const struct wpa_dbus_argument *arg;
128 : :
129 : 0 : pos = registered_sig;
130 : 0 : *pos = '\0';
131 : :
132 [ # # ][ # # ]: 0 : for (arg = method_dsc->args; arg && arg->name; arg++) {
133 [ # # ]: 0 : if (arg->dir == ARG_IN) {
134 : 0 : size_t blen = registered_sig + MAX_SIG_LEN - pos;
135 : 0 : ret = os_snprintf(pos, blen, "%s", arg->type);
136 [ # # ][ # # ]: 0 : if (ret < 0 || (size_t) ret >= blen)
137 : 0 : return 0;
138 : 0 : pos += ret;
139 : : }
140 : : }
141 : :
142 : 0 : return !os_strncmp(registered_sig, sig, MAX_SIG_LEN);
143 : : }
144 : :
145 : :
146 : 0 : static DBusMessage * properties_get_all(DBusMessage *message, char *interface,
147 : : struct wpa_dbus_object_desc *obj_dsc)
148 : : {
149 [ # # ]: 0 : if (os_strcmp(dbus_message_get_signature(message), "s") != 0)
150 : 0 : return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
151 : : NULL);
152 : :
153 : 0 : return get_all_properties(message, interface, obj_dsc);
154 : : }
155 : :
156 : :
157 : 0 : static DBusMessage * properties_get(DBusMessage *message,
158 : : const struct wpa_dbus_property_desc *dsc,
159 : : void *user_data)
160 : : {
161 : : DBusMessage *reply;
162 : : DBusMessageIter iter;
163 : : DBusError error;
164 : :
165 [ # # ]: 0 : if (os_strcmp(dbus_message_get_signature(message), "ss")) {
166 : 0 : return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
167 : : NULL);
168 : : }
169 : :
170 [ # # ]: 0 : if (dsc->getter == NULL) {
171 : 0 : return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
172 : : "Property is write-only");
173 : : }
174 : :
175 : 0 : reply = dbus_message_new_method_return(message);
176 : 0 : dbus_message_iter_init_append(reply, &iter);
177 : :
178 : 0 : dbus_error_init(&error);
179 [ # # ]: 0 : if (dsc->getter(&iter, &error, user_data) == FALSE) {
180 : 0 : dbus_message_unref(reply);
181 : 0 : reply = wpas_dbus_reply_new_from_error(
182 : : message, &error, DBUS_ERROR_FAILED,
183 : : "Failed to read property");
184 : 0 : dbus_error_free(&error);
185 : : }
186 : :
187 : 0 : return reply;
188 : : }
189 : :
190 : :
191 : 0 : static DBusMessage * properties_set(DBusMessage *message,
192 : : const struct wpa_dbus_property_desc *dsc,
193 : : void *user_data)
194 : : {
195 : : DBusMessage *reply;
196 : : DBusMessageIter iter;
197 : : DBusError error;
198 : :
199 [ # # ]: 0 : if (os_strcmp(dbus_message_get_signature(message), "ssv")) {
200 : 0 : return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
201 : : NULL);
202 : : }
203 : :
204 [ # # ]: 0 : if (dsc->setter == NULL) {
205 : 0 : return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
206 : : "Property is read-only");
207 : : }
208 : :
209 : 0 : dbus_message_iter_init(message, &iter);
210 : : /* Skip the interface name and the property name */
211 : 0 : dbus_message_iter_next(&iter);
212 : 0 : dbus_message_iter_next(&iter);
213 : :
214 : : /* Iter will now point to the property's new value */
215 : 0 : dbus_error_init(&error);
216 [ # # ]: 0 : if (dsc->setter(&iter, &error, user_data) == TRUE) {
217 : : /* Success */
218 : 0 : reply = dbus_message_new_method_return(message);
219 : : } else {
220 : 0 : reply = wpas_dbus_reply_new_from_error(
221 : : message, &error, DBUS_ERROR_FAILED,
222 : : "Failed to set property");
223 : 0 : dbus_error_free(&error);
224 : : }
225 : :
226 : 0 : return reply;
227 : : }
228 : :
229 : :
230 : : static DBusMessage *
231 : 0 : properties_get_or_set(DBusMessage *message, DBusMessageIter *iter,
232 : : char *interface,
233 : : struct wpa_dbus_object_desc *obj_dsc)
234 : : {
235 : : const struct wpa_dbus_property_desc *property_dsc;
236 : : char *property;
237 : : const char *method;
238 : :
239 : 0 : method = dbus_message_get_member(message);
240 : 0 : property_dsc = obj_dsc->properties;
241 : :
242 : : /* Second argument: property name (DBUS_TYPE_STRING) */
243 [ # # # # ]: 0 : if (!dbus_message_iter_next(iter) ||
244 : 0 : dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_STRING) {
245 : 0 : return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
246 : : NULL);
247 : : }
248 : 0 : dbus_message_iter_get_basic(iter, &property);
249 : :
250 [ # # ][ # # ]: 0 : while (property_dsc && property_dsc->dbus_property) {
251 : : /* compare property names and
252 : : * interfaces */
253 [ # # ]: 0 : if (!os_strncmp(property_dsc->dbus_property, property,
254 [ # # ]: 0 : WPAS_DBUS_METHOD_SIGNAL_PROP_MAX) &&
255 : 0 : !os_strncmp(property_dsc->dbus_interface, interface,
256 : : WPAS_DBUS_INTERFACE_MAX))
257 : 0 : break;
258 : :
259 : 0 : property_dsc++;
260 : : }
261 [ # # ][ # # ]: 0 : if (property_dsc == NULL || property_dsc->dbus_property == NULL) {
262 : 0 : wpa_printf(MSG_DEBUG, "no property handler for %s.%s on %s",
263 : : interface, property,
264 : : dbus_message_get_path(message));
265 : 0 : return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
266 : : "No such property");
267 : : }
268 : :
269 [ # # ]: 0 : if (os_strncmp(WPA_DBUS_PROPERTIES_GET, method,
270 : : WPAS_DBUS_METHOD_SIGNAL_PROP_MAX) == 0)
271 : 0 : return properties_get(message, property_dsc,
272 : : obj_dsc->user_data);
273 : :
274 : 0 : return properties_set(message, property_dsc, obj_dsc->user_data);
275 : : }
276 : :
277 : :
278 : 0 : static DBusMessage * properties_handler(DBusMessage *message,
279 : : struct wpa_dbus_object_desc *obj_dsc)
280 : : {
281 : : DBusMessageIter iter;
282 : : char *interface;
283 : : const char *method;
284 : :
285 : 0 : method = dbus_message_get_member(message);
286 : 0 : dbus_message_iter_init(message, &iter);
287 : :
288 [ # # ]: 0 : if (!os_strncmp(WPA_DBUS_PROPERTIES_GET, method,
289 [ # # ]: 0 : WPAS_DBUS_METHOD_SIGNAL_PROP_MAX) ||
290 : 0 : !os_strncmp(WPA_DBUS_PROPERTIES_SET, method,
291 [ # # ]: 0 : WPAS_DBUS_METHOD_SIGNAL_PROP_MAX) ||
292 : 0 : !os_strncmp(WPA_DBUS_PROPERTIES_GETALL, method,
293 : : WPAS_DBUS_METHOD_SIGNAL_PROP_MAX)) {
294 : : /* First argument: interface name (DBUS_TYPE_STRING) */
295 [ # # ]: 0 : if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
296 : : {
297 : 0 : return dbus_message_new_error(message,
298 : : DBUS_ERROR_INVALID_ARGS,
299 : : NULL);
300 : : }
301 : :
302 : 0 : dbus_message_iter_get_basic(&iter, &interface);
303 : :
304 [ # # ]: 0 : if (!os_strncmp(WPA_DBUS_PROPERTIES_GETALL, method,
305 : : WPAS_DBUS_METHOD_SIGNAL_PROP_MAX)) {
306 : : /* GetAll */
307 : 0 : return properties_get_all(message, interface, obj_dsc);
308 : : }
309 : : /* Get or Set */
310 : 0 : return properties_get_or_set(message, &iter, interface,
311 : : obj_dsc);
312 : : }
313 : 0 : return dbus_message_new_error(message, DBUS_ERROR_UNKNOWN_METHOD,
314 : : NULL);
315 : : }
316 : :
317 : :
318 : 0 : static DBusMessage * msg_method_handler(DBusMessage *message,
319 : : struct wpa_dbus_object_desc *obj_dsc)
320 : : {
321 : 0 : const struct wpa_dbus_method_desc *method_dsc = obj_dsc->methods;
322 : : const char *method;
323 : : const char *msg_interface;
324 : :
325 : 0 : method = dbus_message_get_member(message);
326 : 0 : msg_interface = dbus_message_get_interface(message);
327 : :
328 : : /* try match call to any registered method */
329 [ # # ][ # # ]: 0 : while (method_dsc && method_dsc->dbus_method) {
330 : : /* compare method names and interfaces */
331 [ # # ]: 0 : if (!os_strncmp(method_dsc->dbus_method, method,
332 [ # # ]: 0 : WPAS_DBUS_METHOD_SIGNAL_PROP_MAX) &&
333 : 0 : !os_strncmp(method_dsc->dbus_interface, msg_interface,
334 : : WPAS_DBUS_INTERFACE_MAX))
335 : 0 : break;
336 : :
337 : 0 : method_dsc++;
338 : : }
339 [ # # ][ # # ]: 0 : if (method_dsc == NULL || method_dsc->dbus_method == NULL) {
340 : 0 : wpa_printf(MSG_DEBUG, "no method handler for %s.%s on %s",
341 : : msg_interface, method,
342 : : dbus_message_get_path(message));
343 : 0 : return dbus_message_new_error(message,
344 : : DBUS_ERROR_UNKNOWN_METHOD, NULL);
345 : : }
346 : :
347 [ # # ]: 0 : if (!is_signature_correct(message, method_dsc)) {
348 : 0 : return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
349 : : NULL);
350 : : }
351 : :
352 : 0 : return method_dsc->method_handler(message,
353 : : obj_dsc->user_data);
354 : : }
355 : :
356 : :
357 : : /**
358 : : * message_handler - Handles incoming DBus messages
359 : : * @connection: DBus connection on which message was received
360 : : * @message: Received message
361 : : * @user_data: pointer to description of object to which message was sent
362 : : * Returns: Returns information whether message was handled or not
363 : : *
364 : : * Reads message interface and method name, then checks if they matches one
365 : : * of the special cases i.e. introspection call or properties get/getall/set
366 : : * methods and handles it. Else it iterates over registered methods list
367 : : * and tries to match method's name and interface to those read from message
368 : : * If appropriate method was found its handler function is called and
369 : : * response is sent. Otherwise, the DBUS_ERROR_UNKNOWN_METHOD error message
370 : : * will be sent.
371 : : */
372 : 0 : static DBusHandlerResult message_handler(DBusConnection *connection,
373 : : DBusMessage *message, void *user_data)
374 : : {
375 : 0 : struct wpa_dbus_object_desc *obj_dsc = user_data;
376 : : const char *method;
377 : : const char *path;
378 : : const char *msg_interface;
379 : : DBusMessage *reply;
380 : :
381 : : /* get method, interface and path the message is addressed to */
382 : 0 : method = dbus_message_get_member(message);
383 : 0 : path = dbus_message_get_path(message);
384 : 0 : msg_interface = dbus_message_get_interface(message);
385 [ # # ][ # # ]: 0 : if (!method || !path || !msg_interface)
[ # # ]
386 : 0 : return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
387 : :
388 : 0 : wpa_printf(MSG_MSGDUMP, "dbus: %s.%s (%s)",
389 : : msg_interface, method, path);
390 : :
391 : : /* if message is introspection method call */
392 [ # # ]: 0 : if (!os_strncmp(WPA_DBUS_INTROSPECTION_METHOD, method,
393 [ # # ]: 0 : WPAS_DBUS_METHOD_SIGNAL_PROP_MAX) &&
394 : 0 : !os_strncmp(WPA_DBUS_INTROSPECTION_INTERFACE, msg_interface,
395 : : WPAS_DBUS_INTERFACE_MAX)) {
396 : : #ifdef CONFIG_CTRL_IFACE_DBUS_INTRO
397 : 0 : reply = wpa_dbus_introspect(message, obj_dsc);
398 : : #else /* CONFIG_CTRL_IFACE_DBUS_INTRO */
399 : : reply = dbus_message_new_error(
400 : : message, DBUS_ERROR_UNKNOWN_METHOD,
401 : : "wpa_supplicant was compiled without "
402 : : "introspection support.");
403 : : #endif /* CONFIG_CTRL_IFACE_DBUS_INTRO */
404 [ # # ]: 0 : } else if (!os_strncmp(WPA_DBUS_PROPERTIES_INTERFACE, msg_interface,
405 : : WPAS_DBUS_INTERFACE_MAX)) {
406 : : /* if message is properties method call */
407 : 0 : reply = properties_handler(message, obj_dsc);
408 : : } else {
409 : 0 : reply = msg_method_handler(message, obj_dsc);
410 : : }
411 : :
412 : : /* If handler succeed returning NULL, reply empty message */
413 [ # # ]: 0 : if (!reply)
414 : 0 : reply = dbus_message_new_method_return(message);
415 [ # # ]: 0 : if (reply) {
416 [ # # ]: 0 : if (!dbus_message_get_no_reply(message))
417 : 0 : dbus_connection_send(connection, reply, NULL);
418 : 0 : dbus_message_unref(reply);
419 : : }
420 : :
421 : 0 : wpa_dbus_flush_all_changed_properties(connection);
422 : :
423 : 0 : return DBUS_HANDLER_RESULT_HANDLED;
424 : : }
425 : :
426 : :
427 : : /**
428 : : * free_dbus_object_desc - Frees object description data structure
429 : : * @connection: DBus connection
430 : : * @obj_dsc: Object description to free
431 : : *
432 : : * Frees each of properties, methods and signals description lists and
433 : : * the object description structure itself.
434 : : */
435 : 0 : void free_dbus_object_desc(struct wpa_dbus_object_desc *obj_dsc)
436 : : {
437 [ # # ]: 0 : if (!obj_dsc)
438 : 0 : return;
439 : :
440 : : /* free handler's argument */
441 [ # # ]: 0 : if (obj_dsc->user_data_free_func)
442 : 0 : obj_dsc->user_data_free_func(obj_dsc->user_data);
443 : :
444 : 0 : os_free(obj_dsc->path);
445 : 0 : os_free(obj_dsc->prop_changed_flags);
446 : 0 : os_free(obj_dsc);
447 : : }
448 : :
449 : :
450 : 0 : static void free_dbus_object_desc_cb(DBusConnection *connection, void *obj_dsc)
451 : : {
452 : 0 : free_dbus_object_desc(obj_dsc);
453 : 0 : }
454 : :
455 : : /**
456 : : * wpa_dbus_ctrl_iface_init - Initialize dbus control interface
457 : : * @application_data: Pointer to application specific data structure
458 : : * @dbus_path: DBus path to interface object
459 : : * @dbus_service: DBus service name to register with
460 : : * @messageHandler: a pointer to function which will handle dbus messages
461 : : * coming on interface
462 : : * Returns: 0 on success, -1 on failure
463 : : *
464 : : * Initialize the dbus control interface and start receiving commands from
465 : : * external programs over the bus.
466 : : */
467 : 0 : int wpa_dbus_ctrl_iface_init(struct wpas_dbus_priv *iface,
468 : : char *dbus_path, char *dbus_service,
469 : : struct wpa_dbus_object_desc *obj_desc)
470 : : {
471 : : DBusError error;
472 : 0 : int ret = -1;
473 : 0 : DBusObjectPathVTable wpa_vtable = {
474 : : &free_dbus_object_desc_cb, &message_handler,
475 : : NULL, NULL, NULL, NULL
476 : : };
477 : :
478 : 0 : obj_desc->connection = iface->con;
479 : 0 : obj_desc->path = os_strdup(dbus_path);
480 : :
481 : : /* Register the message handler for the global dbus interface */
482 [ # # ]: 0 : if (!dbus_connection_register_object_path(iface->con,
483 : : dbus_path, &wpa_vtable,
484 : : obj_desc)) {
485 : 0 : wpa_printf(MSG_ERROR, "dbus: Could not set up message "
486 : : "handler");
487 : 0 : return -1;
488 : : }
489 : :
490 : : /* Register our service with the message bus */
491 : 0 : dbus_error_init(&error);
492 [ # # # ]: 0 : switch (dbus_bus_request_name(iface->con, dbus_service,
493 : : 0, &error)) {
494 : : case DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER:
495 : 0 : ret = 0;
496 : 0 : break;
497 : : case DBUS_REQUEST_NAME_REPLY_EXISTS:
498 : : case DBUS_REQUEST_NAME_REPLY_IN_QUEUE:
499 : : case DBUS_REQUEST_NAME_REPLY_ALREADY_OWNER:
500 : 0 : wpa_printf(MSG_ERROR, "dbus: Could not request service name: "
501 : : "already registered");
502 : 0 : break;
503 : : default:
504 : 0 : wpa_printf(MSG_ERROR, "dbus: Could not request service name: "
505 : : "%s %s", error.name, error.message);
506 : 0 : break;
507 : : }
508 : 0 : dbus_error_free(&error);
509 : :
510 [ # # ]: 0 : if (ret != 0)
511 : 0 : return -1;
512 : :
513 : 0 : wpa_printf(MSG_DEBUG, "Providing DBus service '%s'.", dbus_service);
514 : :
515 : 0 : return 0;
516 : : }
517 : :
518 : :
519 : : /**
520 : : * wpa_dbus_register_object_per_iface - Register a new object with dbus
521 : : * @ctrl_iface: pointer to dbus private data
522 : : * @path: DBus path to object
523 : : * @ifname: interface name
524 : : * @obj_desc: description of object's methods, signals and properties
525 : : * Returns: 0 on success, -1 on error
526 : : *
527 : : * Registers a new interface with dbus and assigns it a dbus object path.
528 : : */
529 : 0 : int wpa_dbus_register_object_per_iface(
530 : : struct wpas_dbus_priv *ctrl_iface,
531 : : const char *path, const char *ifname,
532 : : struct wpa_dbus_object_desc *obj_desc)
533 : : {
534 : : DBusConnection *con;
535 : : DBusError error;
536 : :
537 : 0 : DBusObjectPathVTable vtable = {
538 : : &free_dbus_object_desc_cb, &message_handler,
539 : : NULL, NULL, NULL, NULL
540 : : };
541 : :
542 : : /* Do nothing if the control interface is not turned on */
543 [ # # ]: 0 : if (ctrl_iface == NULL)
544 : 0 : return 0;
545 : :
546 : 0 : con = ctrl_iface->con;
547 : 0 : obj_desc->connection = con;
548 : 0 : obj_desc->path = os_strdup(path);
549 : :
550 : 0 : dbus_error_init(&error);
551 : : /* Register the message handler for the interface functions */
552 [ # # ]: 0 : if (!dbus_connection_try_register_object_path(con, path, &vtable,
553 : : obj_desc, &error)) {
554 [ # # ]: 0 : if (!os_strcmp(error.name, DBUS_ERROR_OBJECT_PATH_IN_USE)) {
555 : 0 : wpa_printf(MSG_DEBUG, "dbus: %s", error.message);
556 : : } else {
557 : 0 : wpa_printf(MSG_ERROR, "dbus: Could not set up message "
558 : : "handler for interface %s object %s",
559 : : ifname, path);
560 : 0 : wpa_printf(MSG_ERROR, "dbus error: %s", error.name);
561 : 0 : wpa_printf(MSG_ERROR, "dbus: %s", error.message);
562 : : }
563 : 0 : dbus_error_free(&error);
564 : 0 : return -1;
565 : : }
566 : :
567 : 0 : dbus_error_free(&error);
568 : 0 : return 0;
569 : : }
570 : :
571 : :
572 : : static void flush_object_timeout_handler(void *eloop_ctx, void *timeout_ctx);
573 : :
574 : :
575 : : /**
576 : : * wpa_dbus_unregister_object_per_iface - Unregisters DBus object
577 : : * @ctrl_iface: Pointer to dbus private data
578 : : * @path: DBus path to object which will be unregistered
579 : : * Returns: Zero on success and -1 on failure
580 : : *
581 : : * Unregisters DBus object given by its path
582 : : */
583 : 0 : int wpa_dbus_unregister_object_per_iface(
584 : : struct wpas_dbus_priv *ctrl_iface, const char *path)
585 : : {
586 : 0 : DBusConnection *con = ctrl_iface->con;
587 : 0 : struct wpa_dbus_object_desc *obj_desc = NULL;
588 : :
589 : 0 : dbus_connection_get_object_path_data(con, path, (void **) &obj_desc);
590 [ # # ]: 0 : if (!obj_desc) {
591 : 0 : wpa_printf(MSG_ERROR, "dbus: %s: Could not obtain object's "
592 : : "private data: %s", __func__, path);
593 : 0 : return 0;
594 : : }
595 : :
596 : 0 : eloop_cancel_timeout(flush_object_timeout_handler, con, obj_desc);
597 : :
598 [ # # ]: 0 : if (!dbus_connection_unregister_object_path(con, path))
599 : 0 : return -1;
600 : :
601 : 0 : return 0;
602 : : }
603 : :
604 : :
605 : 0 : static dbus_bool_t put_changed_properties(
606 : : const struct wpa_dbus_object_desc *obj_dsc, const char *interface,
607 : : DBusMessageIter *dict_iter, int clear_changed)
608 : : {
609 : : DBusMessageIter entry_iter;
610 : : const struct wpa_dbus_property_desc *dsc;
611 : : int i;
612 : : DBusError error;
613 : :
614 [ # # ][ # # ]: 0 : for (dsc = obj_dsc->properties, i = 0; dsc && dsc->dbus_property;
615 : 0 : dsc++, i++) {
616 [ # # ][ # # ]: 0 : if (obj_dsc->prop_changed_flags == NULL ||
617 : 0 : !obj_dsc->prop_changed_flags[i])
618 : 0 : continue;
619 [ # # ]: 0 : if (os_strcmp(dsc->dbus_interface, interface) != 0)
620 : 0 : continue;
621 [ # # ]: 0 : if (clear_changed)
622 : 0 : obj_dsc->prop_changed_flags[i] = 0;
623 : :
624 [ # # ]: 0 : if (!dbus_message_iter_open_container(dict_iter,
625 : : DBUS_TYPE_DICT_ENTRY,
626 : : NULL, &entry_iter))
627 : 0 : return FALSE;
628 : :
629 [ # # ]: 0 : if (!dbus_message_iter_append_basic(&entry_iter,
630 : : DBUS_TYPE_STRING,
631 : 0 : &dsc->dbus_property))
632 : 0 : return FALSE;
633 : :
634 : 0 : dbus_error_init(&error);
635 [ # # ]: 0 : if (!dsc->getter(&entry_iter, &error, obj_dsc->user_data)) {
636 [ # # ]: 0 : if (dbus_error_is_set (&error)) {
637 : 0 : wpa_printf(MSG_ERROR, "dbus: %s: Cannot get "
638 : : "new value of property %s: (%s) %s",
639 : : __func__, dsc->dbus_property,
640 : : error.name, error.message);
641 : : } else {
642 : 0 : wpa_printf(MSG_ERROR, "dbus: %s: Cannot get "
643 : : "new value of property %s",
644 : : __func__, dsc->dbus_property);
645 : : }
646 : 0 : dbus_error_free(&error);
647 : 0 : return FALSE;
648 : : }
649 : :
650 [ # # ]: 0 : if (!dbus_message_iter_close_container(dict_iter, &entry_iter))
651 : 0 : return FALSE;
652 : : }
653 : :
654 : 0 : return TRUE;
655 : : }
656 : :
657 : :
658 : 0 : static void do_send_prop_changed_signal(
659 : : DBusConnection *con, const char *path, const char *interface,
660 : : const struct wpa_dbus_object_desc *obj_dsc)
661 : : {
662 : : DBusMessage *msg;
663 : : DBusMessageIter signal_iter, dict_iter;
664 : :
665 : 0 : msg = dbus_message_new_signal(path, DBUS_INTERFACE_PROPERTIES,
666 : : "PropertiesChanged");
667 [ # # ]: 0 : if (msg == NULL)
668 : 0 : return;
669 : :
670 : 0 : dbus_message_iter_init_append(msg, &signal_iter);
671 : :
672 [ # # ]: 0 : if (!dbus_message_iter_append_basic(&signal_iter, DBUS_TYPE_STRING,
673 : : &interface))
674 : 0 : goto err;
675 : :
676 : : /* Changed properties dict */
677 [ # # ]: 0 : if (!dbus_message_iter_open_container(&signal_iter, DBUS_TYPE_ARRAY,
678 : : "{sv}", &dict_iter))
679 : 0 : goto err;
680 : :
681 [ # # ]: 0 : if (!put_changed_properties(obj_dsc, interface, &dict_iter, 0))
682 : 0 : goto err;
683 : :
684 [ # # ]: 0 : if (!dbus_message_iter_close_container(&signal_iter, &dict_iter))
685 : 0 : goto err;
686 : :
687 : : /* Invalidated properties array (empty) */
688 [ # # ]: 0 : if (!dbus_message_iter_open_container(&signal_iter, DBUS_TYPE_ARRAY,
689 : : "s", &dict_iter))
690 : 0 : goto err;
691 : :
692 [ # # ]: 0 : if (!dbus_message_iter_close_container(&signal_iter, &dict_iter))
693 : 0 : goto err;
694 : :
695 : 0 : dbus_connection_send(con, msg, NULL);
696 : :
697 : : out:
698 : 0 : dbus_message_unref(msg);
699 : 0 : return;
700 : :
701 : : err:
702 : 0 : wpa_printf(MSG_DEBUG, "dbus: %s: Failed to construct signal",
703 : : __func__);
704 : 0 : goto out;
705 : : }
706 : :
707 : :
708 : 0 : static void do_send_deprecated_prop_changed_signal(
709 : : DBusConnection *con, const char *path, const char *interface,
710 : : const struct wpa_dbus_object_desc *obj_dsc)
711 : : {
712 : : DBusMessage *msg;
713 : : DBusMessageIter signal_iter, dict_iter;
714 : :
715 : 0 : msg = dbus_message_new_signal(path, interface, "PropertiesChanged");
716 [ # # ]: 0 : if (msg == NULL)
717 : 0 : return;
718 : :
719 : 0 : dbus_message_iter_init_append(msg, &signal_iter);
720 : :
721 [ # # ]: 0 : if (!dbus_message_iter_open_container(&signal_iter, DBUS_TYPE_ARRAY,
722 : : "{sv}", &dict_iter))
723 : 0 : goto err;
724 : :
725 [ # # ]: 0 : if (!put_changed_properties(obj_dsc, interface, &dict_iter, 1))
726 : 0 : goto err;
727 : :
728 [ # # ]: 0 : if (!dbus_message_iter_close_container(&signal_iter, &dict_iter))
729 : 0 : goto err;
730 : :
731 : 0 : dbus_connection_send(con, msg, NULL);
732 : :
733 : : out:
734 : 0 : dbus_message_unref(msg);
735 : 0 : return;
736 : :
737 : : err:
738 : 0 : wpa_printf(MSG_DEBUG, "dbus: %s: Failed to construct signal",
739 : : __func__);
740 : 0 : goto out;
741 : : }
742 : :
743 : :
744 : 0 : static void send_prop_changed_signal(
745 : : DBusConnection *con, const char *path, const char *interface,
746 : : const struct wpa_dbus_object_desc *obj_dsc)
747 : : {
748 : : /*
749 : : * First, send property change notification on the standardized
750 : : * org.freedesktop.DBus.Properties interface. This call will not
751 : : * clear the property change bits, so that they are preserved for
752 : : * the call that follows.
753 : : */
754 : 0 : do_send_prop_changed_signal(con, path, interface, obj_dsc);
755 : :
756 : : /*
757 : : * Now send PropertiesChanged on our own interface for backwards
758 : : * compatibility. This is deprecated and will be removed in a future
759 : : * release.
760 : : */
761 : 0 : do_send_deprecated_prop_changed_signal(con, path, interface, obj_dsc);
762 : :
763 : : /* Property change bits have now been cleared. */
764 : 0 : }
765 : :
766 : :
767 : 0 : static void flush_object_timeout_handler(void *eloop_ctx, void *timeout_ctx)
768 : : {
769 : 0 : DBusConnection *con = eloop_ctx;
770 : 0 : struct wpa_dbus_object_desc *obj_desc = timeout_ctx;
771 : :
772 : 0 : wpa_printf(MSG_DEBUG, "dbus: %s: Timeout - sending changed properties "
773 : : "of object %s", __func__, obj_desc->path);
774 : 0 : wpa_dbus_flush_object_changed_properties(con, obj_desc->path);
775 : 0 : }
776 : :
777 : :
778 : 0 : static void recursive_flush_changed_properties(DBusConnection *con,
779 : : const char *path)
780 : : {
781 : 0 : char **objects = NULL;
782 : : char subobj_path[WPAS_DBUS_OBJECT_PATH_MAX];
783 : : int i;
784 : :
785 : 0 : wpa_dbus_flush_object_changed_properties(con, path);
786 : :
787 [ # # ]: 0 : if (!dbus_connection_list_registered(con, path, &objects))
788 : 0 : goto out;
789 : :
790 [ # # ]: 0 : for (i = 0; objects[i]; i++) {
791 : 0 : os_snprintf(subobj_path, WPAS_DBUS_OBJECT_PATH_MAX,
792 : 0 : "%s/%s", path, objects[i]);
793 : 0 : recursive_flush_changed_properties(con, subobj_path);
794 : : }
795 : :
796 : : out:
797 : 0 : dbus_free_string_array(objects);
798 : 0 : }
799 : :
800 : :
801 : : /**
802 : : * wpa_dbus_flush_all_changed_properties - Send all PropertiesChanged signals
803 : : * @con: DBus connection
804 : : *
805 : : * Traverses through all registered objects and sends PropertiesChanged for
806 : : * each properties.
807 : : */
808 : 0 : void wpa_dbus_flush_all_changed_properties(DBusConnection *con)
809 : : {
810 : 0 : recursive_flush_changed_properties(con, WPAS_DBUS_NEW_PATH);
811 : 0 : }
812 : :
813 : :
814 : : /**
815 : : * wpa_dbus_flush_object_changed_properties - Send PropertiesChanged for object
816 : : * @con: DBus connection
817 : : * @path: path to a DBus object for which PropertiesChanged will be sent.
818 : : *
819 : : * Iterates over all properties registered with object and for each interface
820 : : * containing properties marked as changed, sends a PropertiesChanged signal
821 : : * containing names and new values of properties that have changed.
822 : : *
823 : : * You need to call this function after wpa_dbus_mark_property_changed()
824 : : * if you want to send PropertiesChanged signal immediately (i.e., without
825 : : * waiting timeout to expire). PropertiesChanged signal for an object is sent
826 : : * automatically short time after first marking property as changed. All
827 : : * PropertiesChanged signals are sent automatically after responding on DBus
828 : : * message, so if you marked a property changed as a result of DBus call
829 : : * (e.g., param setter), you usually do not need to call this function.
830 : : */
831 : 0 : void wpa_dbus_flush_object_changed_properties(DBusConnection *con,
832 : : const char *path)
833 : : {
834 : 0 : struct wpa_dbus_object_desc *obj_desc = NULL;
835 : : const struct wpa_dbus_property_desc *dsc;
836 : : int i;
837 : :
838 : 0 : dbus_connection_get_object_path_data(con, path, (void **) &obj_desc);
839 [ # # ]: 0 : if (!obj_desc)
840 : 0 : return;
841 : 0 : eloop_cancel_timeout(flush_object_timeout_handler, con, obj_desc);
842 : :
843 : 0 : dsc = obj_desc->properties;
844 [ # # ][ # # ]: 0 : for (dsc = obj_desc->properties, i = 0; dsc && dsc->dbus_property;
845 : 0 : dsc++, i++) {
846 [ # # ][ # # ]: 0 : if (obj_desc->prop_changed_flags == NULL ||
847 : 0 : !obj_desc->prop_changed_flags[i])
848 : 0 : continue;
849 : 0 : send_prop_changed_signal(con, path, dsc->dbus_interface,
850 : : obj_desc);
851 : : }
852 : : }
853 : :
854 : :
855 : : #define WPA_DBUS_SEND_PROP_CHANGED_TIMEOUT 5000
856 : :
857 : :
858 : : /**
859 : : * wpa_dbus_mark_property_changed - Mark a property as changed and
860 : : * @iface: dbus priv struct
861 : : * @path: path to DBus object which property has changed
862 : : * @interface: interface containing changed property
863 : : * @property: property name which has changed
864 : : *
865 : : * Iterates over all properties registered with an object and marks the one
866 : : * given in parameters as changed. All parameters registered for an object
867 : : * within a single interface will be aggregated together and sent in one
868 : : * PropertiesChanged signal when function
869 : : * wpa_dbus_flush_object_changed_properties() is called.
870 : : */
871 : 292 : void wpa_dbus_mark_property_changed(struct wpas_dbus_priv *iface,
872 : : const char *path, const char *interface,
873 : : const char *property)
874 : : {
875 : 292 : struct wpa_dbus_object_desc *obj_desc = NULL;
876 : : const struct wpa_dbus_property_desc *dsc;
877 : 292 : int i = 0;
878 : :
879 [ + - ]: 292 : if (iface == NULL)
880 : 292 : return;
881 : :
882 : 0 : dbus_connection_get_object_path_data(iface->con, path,
883 : : (void **) &obj_desc);
884 [ # # ]: 0 : if (!obj_desc) {
885 : 0 : wpa_printf(MSG_ERROR, "dbus: wpa_dbus_property_changed: "
886 : : "could not obtain object's private data: %s", path);
887 : 0 : return;
888 : : }
889 : :
890 [ # # ][ # # ]: 0 : for (dsc = obj_desc->properties; dsc && dsc->dbus_property; dsc++, i++)
891 [ # # ][ # # ]: 0 : if (os_strcmp(property, dsc->dbus_property) == 0 &&
892 : 0 : os_strcmp(interface, dsc->dbus_interface) == 0) {
893 [ # # ]: 0 : if (obj_desc->prop_changed_flags)
894 : 0 : obj_desc->prop_changed_flags[i] = 1;
895 : 0 : break;
896 : : }
897 : :
898 [ # # ][ # # ]: 0 : if (!dsc || !dsc->dbus_property) {
899 : 0 : wpa_printf(MSG_ERROR, "dbus: wpa_dbus_property_changed: "
900 : : "no property %s in object %s", property, path);
901 : 0 : return;
902 : : }
903 : :
904 [ # # ]: 0 : if (!eloop_is_timeout_registered(flush_object_timeout_handler,
905 : 0 : iface->con, obj_desc->path)) {
906 : 292 : eloop_register_timeout(0, WPA_DBUS_SEND_PROP_CHANGED_TIMEOUT,
907 : : flush_object_timeout_handler,
908 : 0 : iface->con, obj_desc);
909 : : }
910 : : }
911 : :
912 : :
913 : : /**
914 : : * wpa_dbus_get_object_properties - Put object's properties into dictionary
915 : : * @iface: dbus priv struct
916 : : * @path: path to DBus object which properties will be obtained
917 : : * @interface: interface name which properties will be obtained
918 : : * @iter: DBus message iter at which to append property dictionary.
919 : : *
920 : : * Iterates over all properties registered with object and execute getters
921 : : * of those, which are readable and which interface matches interface
922 : : * specified as argument. Obtained properties values are stored in
923 : : * dict_iter dictionary.
924 : : */
925 : 0 : dbus_bool_t wpa_dbus_get_object_properties(struct wpas_dbus_priv *iface,
926 : : const char *path,
927 : : const char *interface,
928 : : DBusMessageIter *iter)
929 : : {
930 : 0 : struct wpa_dbus_object_desc *obj_desc = NULL;
931 : : DBusMessageIter dict_iter;
932 : : DBusError error;
933 : :
934 : 0 : dbus_connection_get_object_path_data(iface->con, path,
935 : : (void **) &obj_desc);
936 [ # # ]: 0 : if (!obj_desc) {
937 : 0 : wpa_printf(MSG_ERROR, "dbus: %s: could not obtain object's "
938 : : "private data: %s", __func__, path);
939 : 0 : return FALSE;
940 : : }
941 : :
942 [ # # ]: 0 : if (!wpa_dbus_dict_open_write(iter, &dict_iter)) {
943 : 0 : wpa_printf(MSG_ERROR, "dbus: %s: failed to open message dict",
944 : : __func__);
945 : 0 : return FALSE;
946 : : }
947 : :
948 : 0 : dbus_error_init(&error);
949 [ # # ]: 0 : if (!fill_dict_with_properties(&dict_iter, obj_desc->properties,
950 : 0 : interface, obj_desc->user_data,
951 : : &error)) {
952 [ # # ][ # # ]: 0 : wpa_printf(MSG_ERROR, "dbus: %s: failed to get object"
953 : : " properties: (%s) %s", __func__,
954 : 0 : dbus_error_is_set(&error) ? error.name : "none",
955 : 0 : dbus_error_is_set(&error) ? error.message : "none");
956 : 0 : dbus_error_free(&error);
957 : 0 : return FALSE;
958 : : }
959 : :
960 : 0 : return wpa_dbus_dict_close_write(iter, &dict_iter);
961 : : }
962 : :
963 : : /**
964 : : * wpas_dbus_new_decompose_object_path - Decompose an interface object path into parts
965 : : * @path: The dbus object path
966 : : * @p2p_persistent_group: indicates whether to parse the path as a P2P
967 : : * persistent group object
968 : : * @network: (out) the configured network this object path refers to, if any
969 : : * @bssid: (out) the scanned bssid this object path refers to, if any
970 : : * Returns: The object path of the network interface this path refers to
971 : : *
972 : : * For a given object path, decomposes the object path into object id, network,
973 : : * and BSSID parts, if those parts exist.
974 : : */
975 : 0 : char *wpas_dbus_new_decompose_object_path(const char *path,
976 : : int p2p_persistent_group,
977 : : char **network,
978 : : char **bssid)
979 : : {
980 : 0 : const unsigned int dev_path_prefix_len =
981 : : os_strlen(WPAS_DBUS_NEW_PATH_INTERFACES "/");
982 : : char *obj_path_only;
983 : : char *next_sep;
984 : :
985 : : /* Be a bit paranoid about path */
986 [ # # ][ # # ]: 0 : if (!path || os_strncmp(path, WPAS_DBUS_NEW_PATH_INTERFACES "/",
987 : : dev_path_prefix_len))
988 : 0 : return NULL;
989 : :
990 : : /* Ensure there's something at the end of the path */
991 [ # # ]: 0 : if ((path + dev_path_prefix_len)[0] == '\0')
992 : 0 : return NULL;
993 : :
994 : 0 : obj_path_only = os_strdup(path);
995 [ # # ]: 0 : if (obj_path_only == NULL)
996 : 0 : return NULL;
997 : :
998 : 0 : next_sep = os_strchr(obj_path_only + dev_path_prefix_len, '/');
999 [ # # ]: 0 : if (next_sep != NULL) {
1000 [ # # ]: 0 : const char *net_part = os_strstr(
1001 : : next_sep, p2p_persistent_group ?
1002 : : WPAS_DBUS_NEW_PERSISTENT_GROUPS_PART "/" :
1003 : : WPAS_DBUS_NEW_NETWORKS_PART "/");
1004 : 0 : const char *bssid_part = os_strstr(
1005 : : next_sep, WPAS_DBUS_NEW_BSSIDS_PART "/");
1006 : :
1007 [ # # ][ # # ]: 0 : if (network && net_part) {
1008 : : /* Deal with a request for a configured network */
1009 [ # # ]: 0 : const char *net_name = net_part +
1010 : : os_strlen(p2p_persistent_group ?
1011 : : WPAS_DBUS_NEW_PERSISTENT_GROUPS_PART
1012 : : "/" :
1013 : : WPAS_DBUS_NEW_NETWORKS_PART "/");
1014 : 0 : *network = NULL;
1015 [ # # ]: 0 : if (os_strlen(net_name))
1016 : 0 : *network = os_strdup(net_name);
1017 [ # # ][ # # ]: 0 : } else if (bssid && bssid_part) {
1018 : : /* Deal with a request for a scanned BSSID */
1019 : 0 : const char *bssid_name = bssid_part +
1020 : : os_strlen(WPAS_DBUS_NEW_BSSIDS_PART "/");
1021 [ # # ]: 0 : if (os_strlen(bssid_name))
1022 : 0 : *bssid = os_strdup(bssid_name);
1023 : : else
1024 : 0 : *bssid = NULL;
1025 : : }
1026 : :
1027 : : /* Cut off interface object path before "/" */
1028 : 0 : *next_sep = '\0';
1029 : : }
1030 : :
1031 : 0 : return obj_path_only;
1032 : : }
1033 : :
1034 : :
1035 : : /**
1036 : : * wpas_dbus_reply_new_from_error - Create a new D-Bus error message from a
1037 : : * dbus error structure
1038 : : * @message: The original request message for which the error is a reply
1039 : : * @error: The error containing a name and a descriptive error cause
1040 : : * @fallback_name: A generic error name if @error was not set
1041 : : * @fallback_string: A generic error string if @error was not set
1042 : : * Returns: A new D-Bus error message
1043 : : *
1044 : : * Given a DBusMessage structure, creates a new D-Bus error message using
1045 : : * the error name and string contained in that structure.
1046 : : */
1047 : 0 : DBusMessage * wpas_dbus_reply_new_from_error(DBusMessage *message,
1048 : : DBusError *error,
1049 : : const char *fallback_name,
1050 : : const char *fallback_string)
1051 : : {
1052 [ # # ][ # # ]: 0 : if (error && error->name && error->message) {
[ # # ]
1053 : 0 : return dbus_message_new_error(message, error->name,
1054 : : error->message);
1055 : : }
1056 [ # # ][ # # ]: 0 : if (fallback_name && fallback_string) {
1057 : 0 : return dbus_message_new_error(message, fallback_name,
1058 : : fallback_string);
1059 : : }
1060 : 0 : return NULL;
1061 : : }
|
