2 * WPA Supplicant / dbus-based control interface (P2P)
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License version 2 as
6 * published by the Free Software Foundation.
8 * Alternatively, this software may be distributed under the terms of BSD
11 * See README and COPYING for more details.
16 #include "utils/includes.h"
18 #include "../config.h"
19 #include "../wpa_supplicant_i.h"
20 #include "../wps_supplicant.h"
21 #include "../notify.h"
22 #include "dbus_new_helpers.h"
24 #include "dbus_new_handlers.h"
25 #include "dbus_new_handlers_p2p.h"
26 #include "dbus_dict_helpers.h"
28 #include "common/ieee802_11_defs.h"
29 #include "ap/hostapd.h"
30 #include "ap/ap_config.h"
31 #include "ap/wps_hostapd.h"
33 #include "../p2p_supplicant.h"
36 * Parses out the mac address from the peer object path.
37 * @peer_path - object path of the form
38 * /fi/w1/wpa_supplicant1/Interfaces/n/Peers/00112233445566 (no colons)
39 * @addr - out param must be of ETH_ALEN size
40 * Returns 0 if valid (including MAC), -1 otherwise
42 static int parse_peer_object_path(char *peer_path, u8 addr[ETH_ALEN])
48 p = os_strrchr(peer_path, '/');
52 return hwaddr_compact_aton(p, addr);
57 * wpas_dbus_error_persistent_group_unknown - Return a new PersistentGroupUnknown
59 * @message: Pointer to incoming dbus message this error refers to
60 * Returns: a dbus error message
62 * Convenience function to create and return an invalid persistent group error.
64 static DBusMessage * wpas_dbus_error_persistent_group_unknown(
67 return dbus_message_new_error(message, WPAS_DBUS_ERROR_NETWORK_UNKNOWN,
68 "There is no such persistent group in "
73 DBusMessage * wpas_dbus_handler_p2p_find(DBusMessage *message,
74 struct wpa_supplicant *wpa_s)
76 struct wpa_dbus_dict_entry entry;
77 DBusMessage *reply = NULL;
79 DBusMessageIter iter_dict;
80 unsigned int timeout = 0;
81 enum p2p_discovery_type type = P2P_FIND_ONLY_SOCIAL;
82 int num_req_dev_types = 0;
84 u8 *req_dev_types = NULL;
86 dbus_message_iter_init(message, &iter);
89 if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
92 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
93 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
96 if (!os_strcmp(entry.key, "Timeout") &&
97 (entry.type == DBUS_TYPE_INT32)) {
98 timeout = entry.uint32_value;
99 } else if (os_strcmp(entry.key, "RequestedDeviceTypes") == 0) {
100 if ((entry.type != DBUS_TYPE_ARRAY) ||
101 (entry.array_type != WPAS_DBUS_TYPE_BINARRAY))
104 os_free(req_dev_types);
106 os_malloc(WPS_DEV_TYPE_LEN * entry.array_len);
110 for (i = 0; i < entry.array_len; i++) {
111 if (wpabuf_len(entry.binarray_value[i]) !=
114 os_memcpy(req_dev_types + i * WPS_DEV_TYPE_LEN,
115 wpabuf_head(entry.binarray_value[i]),
118 num_req_dev_types = entry.array_len;
119 } else if (!os_strcmp(entry.key, "DiscoveryType") &&
120 (entry.type == DBUS_TYPE_STRING)) {
121 if (!os_strcmp(entry.str_value, "start_with_full"))
122 type = P2P_FIND_START_WITH_FULL;
123 else if (!os_strcmp(entry.str_value, "social"))
124 type = P2P_FIND_ONLY_SOCIAL;
125 else if (!os_strcmp(entry.str_value, "progressive"))
126 type = P2P_FIND_PROGRESSIVE;
131 wpa_dbus_dict_entry_clear(&entry);
134 wpas_p2p_find(wpa_s, timeout, type, num_req_dev_types, req_dev_types,
136 os_free(req_dev_types);
140 wpa_dbus_dict_entry_clear(&entry);
142 os_free(req_dev_types);
143 reply = wpas_dbus_error_invalid_args(message, entry.key);
148 DBusMessage * wpas_dbus_handler_p2p_stop_find(DBusMessage *message,
149 struct wpa_supplicant *wpa_s)
151 wpas_p2p_stop_find(wpa_s);
156 DBusMessage * wpas_dbus_handler_p2p_rejectpeer(DBusMessage *message,
157 struct wpa_supplicant *wpa_s)
159 DBusMessageIter iter;
160 char *peer_object_path = NULL;
161 u8 peer_addr[ETH_ALEN];
163 dbus_message_iter_init(message, &iter);
164 dbus_message_iter_get_basic(&iter, &peer_object_path);
166 if (parse_peer_object_path(peer_object_path, peer_addr) < 0)
167 return wpas_dbus_error_invalid_args(message, NULL);
169 if (wpas_p2p_reject(wpa_s, peer_addr) < 0)
170 return wpas_dbus_error_unknown_error(message,
171 "Failed to call wpas_p2p_reject method.");
177 DBusMessage * wpas_dbus_handler_p2p_listen(DBusMessage *message,
178 struct wpa_supplicant *wpa_s)
180 dbus_int32_t timeout = 0;
182 if (!dbus_message_get_args(message, NULL, DBUS_TYPE_INT32, &timeout,
184 return dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
187 if (wpas_p2p_listen(wpa_s, (unsigned int)timeout))
188 return dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
195 DBusMessage * wpas_dbus_handler_p2p_extendedlisten(
196 DBusMessage *message, struct wpa_supplicant *wpa_s)
198 unsigned int period = 0, interval = 0;
199 struct wpa_dbus_dict_entry entry;
200 DBusMessageIter iter;
201 DBusMessageIter iter_dict;
203 dbus_message_iter_init(message, &iter);
206 if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
209 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
210 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
213 if (!os_strcmp(entry.key, "period") &&
214 (entry.type == DBUS_TYPE_INT32))
215 period = entry.uint32_value;
216 else if (!os_strcmp(entry.key, "interval") &&
217 (entry.type == DBUS_TYPE_INT32))
218 interval = entry.uint32_value;
221 wpa_dbus_dict_entry_clear(&entry);
224 if (wpas_p2p_ext_listen(wpa_s, period, interval))
225 return wpas_dbus_error_unknown_error(
226 message, "failed to initiate a p2p_ext_listen.");
231 wpa_dbus_dict_entry_clear(&entry);
233 return wpas_dbus_error_invalid_args(message, entry.key);
237 DBusMessage * wpas_dbus_handler_p2p_presence_request(
238 DBusMessage *message, struct wpa_supplicant *wpa_s)
240 unsigned int dur1 = 0, int1 = 0, dur2 = 0, int2 = 0;
241 struct wpa_dbus_dict_entry entry;
242 DBusMessageIter iter;
243 DBusMessageIter iter_dict;
245 dbus_message_iter_init(message, &iter);
248 if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
251 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
252 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
255 if (!os_strcmp(entry.key, "duration1") &&
256 (entry.type == DBUS_TYPE_INT32))
257 dur1 = entry.uint32_value;
258 else if (!os_strcmp(entry.key, "interval1") &&
259 entry.type == DBUS_TYPE_INT32)
260 int1 = entry.uint32_value;
261 else if (!os_strcmp(entry.key, "duration2") &&
262 entry.type == DBUS_TYPE_INT32)
263 dur2 = entry.uint32_value;
264 else if (!os_strcmp(entry.key, "interval2") &&
265 entry.type == DBUS_TYPE_INT32)
266 int2 = entry.uint32_value;
270 wpa_dbus_dict_entry_clear(&entry);
272 if (wpas_p2p_presence_req(wpa_s, dur1, int1, dur2, int2) < 0)
273 return wpas_dbus_error_unknown_error(message,
274 "Failed to invoke presence request.");
279 wpa_dbus_dict_entry_clear(&entry);
281 return wpas_dbus_error_invalid_args(message, entry.key);
285 DBusMessage * wpas_dbus_handler_p2p_group_add(DBusMessage *message,
286 struct wpa_supplicant *wpa_s)
288 DBusMessageIter iter_dict;
289 DBusMessage *reply = NULL;
290 DBusMessageIter iter;
291 struct wpa_dbus_dict_entry entry;
292 char *pg_object_path = NULL;
293 int persistent_group = 0;
296 char *net_id_str = NULL;
297 unsigned int group_id = 0;
298 struct wpa_ssid *ssid;
300 dbus_message_iter_init(message, &iter);
302 if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
305 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
306 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
309 if (!os_strcmp(entry.key, "persistent") &&
310 (entry.type == DBUS_TYPE_BOOLEAN)) {
311 persistent_group = (entry.bool_value == TRUE) ? 1 : 0;
312 } else if (!os_strcmp(entry.key, "frequency") &&
313 (entry.type == DBUS_TYPE_INT32)) {
314 freq = entry.int32_value;
317 } else if (!os_strcmp(entry.key, "persistent_group_object") &&
318 entry.type == DBUS_TYPE_OBJECT_PATH)
319 pg_object_path = os_strdup(entry.str_value);
323 wpa_dbus_dict_entry_clear(&entry);
326 if (pg_object_path != NULL) {
328 * A persistent group Object Path is defined meaning we want
329 * to re-invoke a persistent group.
332 iface = wpas_dbus_new_decompose_object_path(pg_object_path, 1,
335 os_strcmp(iface, wpa_s->dbus_new_path) != 0) {
337 wpas_dbus_error_invalid_args(message,
342 group_id = strtoul(net_id_str, NULL, 10);
343 if (errno == EINVAL) {
344 reply = wpas_dbus_error_invalid_args(
345 message, pg_object_path);
349 /* Get the SSID structure from the persistent group id */
350 ssid = wpa_config_get_network(wpa_s->conf, group_id);
351 if (ssid == NULL || ssid->disabled != 2)
354 if (wpas_p2p_group_add_persistent(wpa_s, ssid, 0, freq)) {
355 reply = wpas_dbus_error_unknown_error(
357 "Failed to reinvoke a persistent group");
360 } else if (wpas_p2p_group_add(wpa_s, persistent_group, freq))
364 os_free(pg_object_path);
369 wpa_dbus_dict_entry_clear(&entry);
371 reply = wpas_dbus_error_invalid_args(message, NULL);
376 DBusMessage * wpas_dbus_handler_p2p_disconnect(DBusMessage *message,
377 struct wpa_supplicant *wpa_s)
379 if (wpas_p2p_disconnect(wpa_s))
380 return wpas_dbus_error_unknown_error(message,
381 "failed to disconnect");
387 static dbus_bool_t wpa_dbus_p2p_check_enabled(struct wpa_supplicant *wpa_s,
388 DBusMessage *message,
389 DBusMessage **out_reply,
392 /* Return an error message or an error if P2P isn't available */
393 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL) {
395 *out_reply = dbus_message_new_error(
396 message, DBUS_ERROR_FAILED,
397 "P2P is not available for this interface");
399 dbus_set_error_const(error, DBUS_ERROR_FAILED,
400 "P2P is not available for this "
408 DBusMessage * wpas_dbus_handler_p2p_flush(DBusMessage *message,
409 struct wpa_supplicant *wpa_s)
411 DBusMessage *reply = NULL;
413 if (!wpa_dbus_p2p_check_enabled(wpa_s, message, &reply, NULL))
416 os_memset(wpa_s->p2p_auth_invite, 0, ETH_ALEN);
417 wpa_s->force_long_sd = 0;
418 p2p_flush(wpa_s->global->p2p);
424 DBusMessage * wpas_dbus_handler_p2p_connect(DBusMessage *message,
425 struct wpa_supplicant *wpa_s)
427 DBusMessageIter iter_dict;
428 DBusMessage *reply = NULL;
429 DBusMessageIter iter;
430 struct wpa_dbus_dict_entry entry;
431 char *peer_object_path = NULL;
432 int persistent_group = 0;
434 int authorize_only = 0;
439 enum p2p_wps_method wps_method = WPS_NOT_READY;
441 char *err_msg = NULL;
444 if (!wpa_dbus_p2p_check_enabled(wpa_s, message, &reply, NULL))
447 dbus_message_iter_init(message, &iter);
449 if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
452 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
453 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
456 if (!os_strcmp(entry.key, "peer") &&
457 (entry.type == DBUS_TYPE_OBJECT_PATH)) {
458 peer_object_path = os_strdup(entry.str_value);
459 } else if (!os_strcmp(entry.key, "persistent") &&
460 (entry.type == DBUS_TYPE_BOOLEAN)) {
461 persistent_group = (entry.bool_value == TRUE) ? 1 : 0;
462 } else if (!os_strcmp(entry.key, "join") &&
463 (entry.type == DBUS_TYPE_BOOLEAN)) {
464 join = (entry.bool_value == TRUE) ? 1 : 0;
465 } else if (!os_strcmp(entry.key, "authorize_only") &&
466 (entry.type == DBUS_TYPE_BOOLEAN)) {
467 authorize_only = (entry.bool_value == TRUE) ? 1 : 0;
468 } else if (!os_strcmp(entry.key, "frequency") &&
469 (entry.type == DBUS_TYPE_INT32)) {
470 freq = entry.int32_value;
473 } else if (!os_strcmp(entry.key, "go_intent") &&
474 (entry.type == DBUS_TYPE_INT32)) {
475 go_intent = entry.int32_value;
476 if ((go_intent < 0) || (go_intent > 15))
478 } else if (!os_strcmp(entry.key, "wps_method") &&
479 (entry.type == DBUS_TYPE_STRING)) {
480 if (!os_strcmp(entry.str_value, "pbc"))
481 wps_method = WPS_PBC;
482 else if (!os_strcmp(entry.str_value, "pin"))
483 wps_method = WPS_PIN_DISPLAY;
484 else if (!os_strcmp(entry.str_value, "display"))
485 wps_method = WPS_PIN_DISPLAY;
486 else if (!os_strcmp(entry.str_value, "keypad"))
487 wps_method = WPS_PIN_KEYPAD;
490 } else if (!os_strcmp(entry.key, "pin") &&
491 (entry.type == DBUS_TYPE_STRING)) {
492 pin = os_strdup(entry.str_value);
496 wpa_dbus_dict_entry_clear(&entry);
499 if (!peer_object_path || (wps_method == WPS_NOT_READY) ||
500 (parse_peer_object_path(peer_object_path, addr) < 0) ||
501 !p2p_peer_known(wpa_s->global->p2p, addr))
505 * Validate the wps_method specified and the pin value.
507 if ((!pin || !pin[0]) && (wps_method == WPS_PIN_KEYPAD))
510 new_pin = wpas_p2p_connect(wpa_s, addr, pin, wps_method,
511 persistent_group, join, authorize_only,
517 os_snprintf(npin, sizeof(npin), "%08d", new_pin);
518 generated_pin = npin;
519 reply = dbus_message_new_method_return(message);
520 dbus_message_append_args(reply, DBUS_TYPE_STRING,
521 &generated_pin, DBUS_TYPE_INVALID);
525 err_msg = "connect failed due to channel "
527 iface = WPAS_DBUS_ERROR_CONNECT_CHANNEL_UNAVAILABLE;
531 err_msg = "connect failed due to unsupported channel.";
532 iface = WPAS_DBUS_ERROR_CONNECT_CHANNEL_UNSUPPORTED;
536 err_msg = "connect failed due to unspecified error.";
537 iface = WPAS_DBUS_ERROR_CONNECT_UNSPECIFIED_ERROR;
543 * Do we need specialized errors corresponding to above
544 * error conditions as against just returning a different
547 reply = dbus_message_new_error(message, iface, err_msg);
551 os_free(peer_object_path);
555 wpa_dbus_dict_entry_clear(&entry);
557 reply = wpas_dbus_error_invalid_args(message, NULL);
562 DBusMessage * wpas_dbus_handler_p2p_invite(DBusMessage *message,
563 struct wpa_supplicant *wpa_s)
565 DBusMessageIter iter_dict;
566 DBusMessage *reply = NULL;
567 DBusMessageIter iter;
568 struct wpa_dbus_dict_entry entry;
569 char *peer_object_path = NULL;
570 char *pg_object_path = NULL;
572 char *net_id_str = NULL;
573 u8 peer_addr[ETH_ALEN];
574 unsigned int group_id = 0;
576 struct wpa_ssid *ssid;
578 if (!wpa_dbus_p2p_check_enabled(wpa_s, message, &reply, NULL))
581 dbus_message_iter_init(message, &iter);
583 if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
586 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
587 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
590 if (!os_strcmp(entry.key, "peer") &&
591 (entry.type == DBUS_TYPE_OBJECT_PATH)) {
592 peer_object_path = os_strdup(entry.str_value);
593 wpa_dbus_dict_entry_clear(&entry);
594 } else if (!os_strcmp(entry.key, "persistent_group_object") &&
595 (entry.type == DBUS_TYPE_OBJECT_PATH)) {
596 pg_object_path = os_strdup(entry.str_value);
598 wpa_dbus_dict_entry_clear(&entry);
600 wpa_dbus_dict_entry_clear(&entry);
605 if (!peer_object_path ||
606 (parse_peer_object_path(peer_object_path, peer_addr) < 0) ||
607 !p2p_peer_known(wpa_s->global->p2p, peer_addr)) {
613 * A group ID is defined meaning we want to re-invoke a
617 iface = wpas_dbus_new_decompose_object_path(pg_object_path, 1,
620 os_strcmp(iface, wpa_s->dbus_new_path) != 0) {
621 reply = wpas_dbus_error_invalid_args(message,
626 group_id = strtoul(net_id_str, NULL, 10);
627 if (errno == EINVAL) {
628 reply = wpas_dbus_error_invalid_args(
629 message, pg_object_path);
633 /* Get the SSID structure from the persistent group id */
634 ssid = wpa_config_get_network(wpa_s->conf, group_id);
635 if (ssid == NULL || ssid->disabled != 2)
638 if (wpas_p2p_invite(wpa_s, peer_addr, ssid, NULL) < 0) {
639 reply = wpas_dbus_error_unknown_error(
641 "Failed to reinvoke a persistent group");
646 * No group ID means propose to a peer to join my active group
648 if (wpas_p2p_invite_group(wpa_s, wpa_s->ifname,
650 reply = wpas_dbus_error_unknown_error(
651 message, "Failed to join to an active group");
657 os_free(pg_object_path);
658 os_free(peer_object_path);
662 reply = wpas_dbus_error_invalid_args(message, NULL);
667 DBusMessage * wpas_dbus_handler_p2p_prov_disc_req(DBusMessage *message,
668 struct wpa_supplicant *wpa_s)
670 DBusMessageIter iter;
671 char *peer_object_path = NULL;
672 char *config_method = NULL;
673 u8 peer_addr[ETH_ALEN];
675 dbus_message_iter_init(message, &iter);
676 dbus_message_iter_get_basic(&iter, &peer_object_path);
678 if (parse_peer_object_path(peer_object_path, peer_addr) < 0)
679 return wpas_dbus_error_invalid_args(message, NULL);
681 dbus_message_iter_next(&iter);
682 dbus_message_iter_get_basic(&iter, &config_method);
685 * Validation checks on config_method are being duplicated here
686 * to be able to return invalid args reply since the error code
687 * from p2p module are not granular enough (yet).
689 if (os_strcmp(config_method, "display") &&
690 os_strcmp(config_method, "keypad") &&
691 os_strcmp(config_method, "pbc") &&
692 os_strcmp(config_method, "pushbutton"))
693 return wpas_dbus_error_invalid_args(message, NULL);
695 if (wpas_p2p_prov_disc(wpa_s, peer_addr, config_method, 0) < 0)
696 return wpas_dbus_error_unknown_error(message,
697 "Failed to send provision discovery request");
704 * P2P Device property accessor methods.
707 dbus_bool_t wpas_dbus_getter_p2p_device_properties(DBusMessageIter *iter,
711 struct wpa_supplicant *wpa_s = user_data;
712 DBusMessageIter variant_iter, dict_iter;
713 DBusMessageIter iter_secdev_dict_entry, iter_secdev_dict_val,
714 iter_secdev_dict_array;
715 const char *dev_name;
716 int num_vendor_extensions = 0;
718 const struct wpabuf *vendor_ext[P2P_MAX_WPS_VENDOR_EXT];
720 if (!wpa_dbus_p2p_check_enabled(wpa_s, NULL, NULL, error))
723 if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
724 "a{sv}", &variant_iter) ||
725 !wpa_dbus_dict_open_write(&variant_iter, &dict_iter))
729 dev_name = wpa_s->conf->device_name;
731 !wpa_dbus_dict_append_string(&dict_iter, "DeviceName", dev_name))
734 /* Primary device type */
735 if (!wpa_dbus_dict_append_byte_array(&dict_iter, "PrimaryDeviceType",
736 (char *)wpa_s->conf->device_type,
740 /* Secondary device types */
741 if (wpa_s->conf->num_sec_device_types) {
742 if (!wpa_dbus_dict_begin_array(&dict_iter,
743 "SecondaryDeviceTypes",
744 DBUS_TYPE_ARRAY_AS_STRING
745 DBUS_TYPE_BYTE_AS_STRING,
746 &iter_secdev_dict_entry,
747 &iter_secdev_dict_val,
748 &iter_secdev_dict_array))
751 for (i = 0; i < wpa_s->conf->num_sec_device_types; i++)
752 wpa_dbus_dict_bin_array_add_element(
753 &iter_secdev_dict_array,
754 wpa_s->conf->sec_device_type[i],
757 if (!wpa_dbus_dict_end_array(&dict_iter,
758 &iter_secdev_dict_entry,
759 &iter_secdev_dict_val,
760 &iter_secdev_dict_array))
764 /* Vendor Extensions */
765 for (i = 0; i < P2P_MAX_WPS_VENDOR_EXT; i++) {
766 if (wpa_s->conf->wps_vendor_ext[i] == NULL)
768 vendor_ext[num_vendor_extensions++] =
769 wpa_s->conf->wps_vendor_ext[i];
772 if (num_vendor_extensions &&
773 !wpa_dbus_dict_append_wpabuf_array(&dict_iter,
776 num_vendor_extensions))
780 if (!wpa_dbus_dict_append_uint32(&dict_iter, "GOIntent",
781 wpa_s->conf->p2p_go_intent))
784 /* Persistent Reconnect */
785 if (!wpa_dbus_dict_append_bool(&dict_iter, "PersistantReconnect",
786 wpa_s->conf->persistent_reconnect))
789 /* Listen Reg Class */
790 if (!wpa_dbus_dict_append_uint32(&dict_iter, "ListenRegClass",
791 wpa_s->conf->p2p_listen_reg_class))
795 if (!wpa_dbus_dict_append_uint32(&dict_iter, "ListenChannel",
796 wpa_s->conf->p2p_listen_channel))
800 if (!wpa_dbus_dict_append_uint32(&dict_iter, "OperRegClass",
801 wpa_s->conf->p2p_oper_reg_class))
805 if (!wpa_dbus_dict_append_uint32(&dict_iter, "OperChannel",
806 wpa_s->conf->p2p_oper_channel))
810 if (wpa_s->conf->p2p_ssid_postfix &&
811 !wpa_dbus_dict_append_string(&dict_iter, "SsidPostfix",
812 wpa_s->conf->p2p_ssid_postfix))
816 if (!wpa_dbus_dict_append_bool(&dict_iter, "IntraBss",
817 wpa_s->conf->p2p_intra_bss))
821 if (!wpa_dbus_dict_append_uint32(&dict_iter, "GroupIdle",
822 wpa_s->conf->p2p_group_idle))
825 /* Dissasociation low ack */
826 if (!wpa_dbus_dict_append_uint32(&dict_iter, "disassoc_low_ack",
827 wpa_s->conf->disassoc_low_ack))
830 if (!wpa_dbus_dict_close_write(&variant_iter, &dict_iter) ||
831 !dbus_message_iter_close_container(iter, &variant_iter))
837 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
842 dbus_bool_t wpas_dbus_setter_p2p_device_properties(DBusMessageIter *iter,
846 struct wpa_supplicant *wpa_s = user_data;
847 DBusMessageIter variant_iter, iter_dict;
848 struct wpa_dbus_dict_entry entry = {.type = DBUS_TYPE_STRING };
851 if (!wpa_dbus_p2p_check_enabled(wpa_s, NULL, NULL, error))
854 dbus_message_iter_recurse(iter, &variant_iter);
855 if (!wpa_dbus_dict_open_read(&variant_iter, &iter_dict, error))
858 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
859 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry)) {
860 dbus_set_error_const(error, DBUS_ERROR_INVALID_ARGS,
861 "invalid message format");
865 if (os_strcmp(entry.key, "DeviceName") == 0) {
868 if (entry.type != DBUS_TYPE_STRING)
871 devname = os_strdup(entry.str_value);
873 goto err_no_mem_clear;
875 os_free(wpa_s->conf->device_name);
876 wpa_s->conf->device_name = devname;
878 wpa_s->conf->changed_parameters |=
879 CFG_CHANGED_DEVICE_NAME;
880 } else if (os_strcmp(entry.key, "PrimaryDeviceType") == 0) {
881 if (entry.type != DBUS_TYPE_ARRAY ||
882 entry.array_type != DBUS_TYPE_BYTE ||
883 entry.array_len != WPS_DEV_TYPE_LEN)
886 os_memcpy(wpa_s->conf->device_type,
887 entry.bytearray_value,
889 wpa_s->conf->changed_parameters |=
890 CFG_CHANGED_DEVICE_TYPE;
891 } else if (os_strcmp(entry.key, "SecondaryDeviceTypes") == 0) {
892 if (entry.type != DBUS_TYPE_ARRAY ||
893 entry.array_type != WPAS_DBUS_TYPE_BINARRAY ||
894 entry.array_len > MAX_SEC_DEVICE_TYPES)
897 for (i = 0; i < entry.array_len; i++)
898 if (wpabuf_len(entry.binarray_value[i]) !=
900 goto err_no_mem_clear;
901 for (i = 0; i < entry.array_len; i++)
902 os_memcpy(wpa_s->conf->sec_device_type[i],
903 wpabuf_head(entry.binarray_value[i]),
905 wpa_s->conf->num_sec_device_types = entry.array_len;
906 wpa_s->conf->changed_parameters |=
907 CFG_CHANGED_SEC_DEVICE_TYPE;
908 } else if (os_strcmp(entry.key, "VendorExtension") == 0) {
909 if ((entry.type != DBUS_TYPE_ARRAY) ||
910 (entry.array_type != WPAS_DBUS_TYPE_BINARRAY) ||
911 (entry.array_len > P2P_MAX_WPS_VENDOR_EXT))
914 wpa_s->conf->changed_parameters |=
915 CFG_CHANGED_VENDOR_EXTENSION;
917 for (i = 0; i < P2P_MAX_WPS_VENDOR_EXT; i++) {
918 wpabuf_free(wpa_s->conf->wps_vendor_ext[i]);
919 if (i < entry.array_len) {
920 wpa_s->conf->wps_vendor_ext[i] =
921 entry.binarray_value[i];
922 entry.binarray_value[i] = NULL;
924 wpa_s->conf->wps_vendor_ext[i] = NULL;
926 } else if ((os_strcmp(entry.key, "GOIntent") == 0) &&
927 (entry.type == DBUS_TYPE_UINT32) &&
928 (entry.uint32_value <= 15))
929 wpa_s->conf->p2p_go_intent = entry.uint32_value;
930 else if ((os_strcmp(entry.key, "PersistantReconnect") == 0) &&
931 (entry.type == DBUS_TYPE_BOOLEAN))
932 wpa_s->conf->persistent_reconnect = entry.bool_value;
933 else if ((os_strcmp(entry.key, "ListenRegClass") == 0) &&
934 (entry.type == DBUS_TYPE_UINT32)) {
935 wpa_s->conf->p2p_listen_reg_class = entry.uint32_value;
936 wpa_s->conf->changed_parameters |=
937 CFG_CHANGED_P2P_LISTEN_CHANNEL;
938 } else if ((os_strcmp(entry.key, "ListenChannel") == 0) &&
939 (entry.type == DBUS_TYPE_UINT32)) {
940 wpa_s->conf->p2p_listen_channel = entry.uint32_value;
941 wpa_s->conf->changed_parameters |=
942 CFG_CHANGED_P2P_LISTEN_CHANNEL;
943 } else if ((os_strcmp(entry.key, "OperRegClass") == 0) &&
944 (entry.type == DBUS_TYPE_UINT32)) {
945 wpa_s->conf->p2p_oper_reg_class = entry.uint32_value;
946 wpa_s->conf->changed_parameters |=
947 CFG_CHANGED_P2P_OPER_CHANNEL;
948 } else if ((os_strcmp(entry.key, "OperChannel") == 0) &&
949 (entry.type == DBUS_TYPE_UINT32)) {
950 wpa_s->conf->p2p_oper_channel = entry.uint32_value;
951 wpa_s->conf->changed_parameters |=
952 CFG_CHANGED_P2P_OPER_CHANNEL;
953 } else if (os_strcmp(entry.key, "SsidPostfix") == 0) {
956 if (entry.type != DBUS_TYPE_STRING)
959 postfix = os_strdup(entry.str_value);
961 goto err_no_mem_clear;
963 os_free(wpa_s->conf->p2p_ssid_postfix);
964 wpa_s->conf->p2p_ssid_postfix = postfix;
966 wpa_s->conf->changed_parameters |=
967 CFG_CHANGED_P2P_SSID_POSTFIX;
968 } else if ((os_strcmp(entry.key, "IntraBss") == 0) &&
969 (entry.type == DBUS_TYPE_BOOLEAN)) {
970 wpa_s->conf->p2p_intra_bss = entry.bool_value;
971 wpa_s->conf->changed_parameters |=
972 CFG_CHANGED_P2P_INTRA_BSS;
973 } else if ((os_strcmp(entry.key, "GroupIdle") == 0) &&
974 (entry.type == DBUS_TYPE_UINT32))
975 wpa_s->conf->p2p_group_idle = entry.uint32_value;
976 else if (os_strcmp(entry.key, "disassoc_low_ack") == 0 &&
977 entry.type == DBUS_TYPE_UINT32)
978 wpa_s->conf->disassoc_low_ack = entry.uint32_value;
982 wpa_dbus_dict_entry_clear(&entry);
985 if (wpa_s->conf->changed_parameters) {
986 /* Some changed parameters requires to update config*/
987 wpa_supplicant_update_config(wpa_s);
993 dbus_set_error_const(error, DBUS_ERROR_INVALID_ARGS,
994 "invalid message format");
995 wpa_dbus_dict_entry_clear(&entry);
999 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
1000 wpa_dbus_dict_entry_clear(&entry);
1005 dbus_bool_t wpas_dbus_getter_p2p_peers(DBusMessageIter *iter, DBusError *error,
1008 struct wpa_supplicant *wpa_s = user_data;
1009 struct p2p_data *p2p = wpa_s->global->p2p;
1010 int next = 0, i = 0;
1011 int num = 0, out_of_mem = 0;
1013 const struct p2p_peer_info *peer_info = NULL;
1014 dbus_bool_t success = FALSE;
1016 struct dl_list peer_objpath_list;
1017 struct peer_objpath_node {
1018 struct dl_list list;
1019 char path[WPAS_DBUS_OBJECT_PATH_MAX];
1022 char **peer_obj_paths = NULL;
1024 if (!wpa_dbus_p2p_check_enabled(wpa_s, NULL, NULL, error))
1027 dl_list_init(&peer_objpath_list);
1029 /* Get the first peer info */
1030 peer_info = p2p_get_peer_found(p2p, NULL, next);
1032 /* Get next and accumulate them */
1034 while (peer_info != NULL) {
1035 node = os_zalloc(sizeof(struct peer_objpath_node));
1041 addr = peer_info->p2p_device_addr;
1042 os_snprintf(node->path, WPAS_DBUS_OBJECT_PATH_MAX,
1043 "%s/" WPAS_DBUS_NEW_P2P_PEERS_PART
1045 wpa_s->dbus_new_path, MAC2STR(addr));
1046 dl_list_add_tail(&peer_objpath_list, &node->list);
1049 peer_info = p2p_get_peer_found(p2p, addr, next);
1053 * Now construct the peer object paths in a form suitable for
1054 * array_property_getter helper below.
1056 peer_obj_paths = os_zalloc(num * sizeof(char *));
1058 if (!peer_obj_paths) {
1063 dl_list_for_each_safe(node, tmp, &peer_objpath_list,
1064 struct peer_objpath_node, list)
1065 peer_obj_paths[i++] = node->path;
1067 success = wpas_dbus_simple_array_property_getter(iter,
1068 DBUS_TYPE_OBJECT_PATH,
1069 peer_obj_paths, num,
1074 os_free(peer_obj_paths);
1076 dl_list_for_each_safe(node, tmp, &peer_objpath_list,
1077 struct peer_objpath_node, list) {
1078 dl_list_del(&node->list);
1082 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
1088 enum wpas_p2p_role {
1089 WPAS_P2P_ROLE_DEVICE,
1091 WPAS_P2P_ROLE_CLIENT,
1094 static enum wpas_p2p_role wpas_get_p2p_role(struct wpa_supplicant *wpa_s)
1096 struct wpa_ssid *ssid = wpa_s->current_ssid;
1099 return WPAS_P2P_ROLE_DEVICE;
1100 if (wpa_s->wpa_state != WPA_COMPLETED)
1101 return WPAS_P2P_ROLE_DEVICE;
1103 switch (ssid->mode) {
1104 case WPAS_MODE_P2P_GO:
1105 case WPAS_MODE_P2P_GROUP_FORMATION:
1106 return WPAS_P2P_ROLE_GO;
1107 case WPAS_MODE_INFRA:
1108 if (ssid->p2p_group)
1109 return WPAS_P2P_ROLE_CLIENT;
1110 return WPAS_P2P_ROLE_DEVICE;
1112 return WPAS_P2P_ROLE_DEVICE;
1117 dbus_bool_t wpas_dbus_getter_p2p_role(DBusMessageIter *iter, DBusError *error,
1120 struct wpa_supplicant *wpa_s = user_data;
1123 switch (wpas_get_p2p_role(wpa_s)) {
1124 case WPAS_P2P_ROLE_GO:
1127 case WPAS_P2P_ROLE_CLIENT:
1134 return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING, &str,
1139 dbus_bool_t wpas_dbus_getter_p2p_group(DBusMessageIter *iter, DBusError *error,
1142 struct wpa_supplicant *wpa_s = user_data;
1144 if (wpa_s->dbus_groupobj_path == NULL)
1147 return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_OBJECT_PATH,
1148 &wpa_s->dbus_groupobj_path,
1153 dbus_bool_t wpas_dbus_getter_p2p_peergo(DBusMessageIter *iter,
1154 DBusError *error, void *user_data)
1156 struct wpa_supplicant *wpa_s = user_data;
1157 char go_peer_obj_path[WPAS_DBUS_OBJECT_PATH_MAX], *path;
1159 if (wpas_get_p2p_role(wpa_s) != WPAS_P2P_ROLE_CLIENT)
1162 os_snprintf(go_peer_obj_path, WPAS_DBUS_OBJECT_PATH_MAX,
1163 "%s/" WPAS_DBUS_NEW_P2P_PEERS_PART "/" COMPACT_MACSTR,
1164 wpa_s->dbus_new_path, MAC2STR(wpa_s->go_dev_addr));
1165 path = go_peer_obj_path;
1166 return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_OBJECT_PATH,
1172 * Peer object properties accessor methods
1175 dbus_bool_t wpas_dbus_getter_p2p_peer_device_name(DBusMessageIter *iter,
1179 struct peer_handler_args *peer_args = user_data;
1180 const struct p2p_peer_info *info;
1183 if (!wpa_dbus_p2p_check_enabled(peer_args->wpa_s, NULL, NULL, error))
1186 /* get the peer info */
1187 info = p2p_get_peer_found(peer_args->wpa_s->global->p2p,
1188 peer_args->p2p_device_addr, 0);
1190 dbus_set_error(error, DBUS_ERROR_FAILED,
1191 "failed to find peer");
1195 tmp = os_strdup(info->device_name);
1197 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
1201 if (!wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING, &tmp,
1203 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
1213 dbus_bool_t wpas_dbus_getter_p2p_peer_primary_device_type(
1214 DBusMessageIter *iter, DBusError *error, void *user_data)
1216 struct peer_handler_args *peer_args = user_data;
1217 const struct p2p_peer_info *info;
1219 info = p2p_get_peer_found(peer_args->wpa_s->global->p2p,
1220 peer_args->p2p_device_addr, 0);
1222 dbus_set_error(error, DBUS_ERROR_FAILED,
1223 "failed to find peer");
1227 if (!wpas_dbus_simple_array_property_getter(iter, DBUS_TYPE_BYTE,
1230 WPS_DEV_TYPE_LEN, error)) {
1231 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
1239 dbus_bool_t wpas_dbus_getter_p2p_peer_config_method(DBusMessageIter *iter,
1243 struct peer_handler_args *peer_args = user_data;
1244 const struct p2p_peer_info *info;
1246 info = p2p_get_peer_found(peer_args->wpa_s->global->p2p,
1247 peer_args->p2p_device_addr, 0);
1249 dbus_set_error(error, DBUS_ERROR_FAILED,
1250 "failed to find peer");
1254 if (!wpas_dbus_simple_property_getter(iter, DBUS_TYPE_UINT16,
1255 &info->config_methods, error)) {
1256 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
1264 dbus_bool_t wpas_dbus_getter_p2p_peer_level(DBusMessageIter *iter,
1268 struct peer_handler_args *peer_args = user_data;
1269 const struct p2p_peer_info *info;
1271 info = p2p_get_peer_found(peer_args->wpa_s->global->p2p,
1272 peer_args->p2p_device_addr, 0);
1274 dbus_set_error(error, DBUS_ERROR_FAILED,
1275 "failed to find peer");
1279 if (!wpas_dbus_simple_property_getter(iter, DBUS_TYPE_INT32,
1280 &info->level, error)) {
1281 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
1289 dbus_bool_t wpas_dbus_getter_p2p_peer_device_capability(DBusMessageIter *iter,
1293 struct peer_handler_args *peer_args = user_data;
1294 const struct p2p_peer_info *info;
1296 info = p2p_get_peer_found(peer_args->wpa_s->global->p2p,
1297 peer_args->p2p_device_addr, 0);
1299 dbus_set_error(error, DBUS_ERROR_FAILED,
1300 "failed to find peer");
1304 if (!wpas_dbus_simple_property_getter(iter, DBUS_TYPE_BYTE,
1305 &info->dev_capab, error)) {
1306 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
1314 dbus_bool_t wpas_dbus_getter_p2p_peer_group_capability(DBusMessageIter *iter,
1318 struct peer_handler_args *peer_args = user_data;
1319 const struct p2p_peer_info *info;
1321 info = p2p_get_peer_found(peer_args->wpa_s->global->p2p,
1322 peer_args->p2p_device_addr, 0);
1324 dbus_set_error(error, DBUS_ERROR_FAILED,
1325 "failed to find peer");
1329 if (!wpas_dbus_simple_property_getter(iter, DBUS_TYPE_BYTE,
1330 &info->group_capab, error)) {
1331 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
1339 dbus_bool_t wpas_dbus_getter_p2p_peer_secondary_device_types(
1340 DBusMessageIter *iter, DBusError *error, void *user_data)
1342 struct peer_handler_args *peer_args = user_data;
1343 const struct p2p_peer_info *info;
1344 DBusMessageIter variant_iter, array_iter;
1346 info = p2p_get_peer_found(peer_args->wpa_s->global->p2p,
1347 peer_args->p2p_device_addr, 0);
1349 dbus_set_error(error, DBUS_ERROR_FAILED,
1350 "failed to find peer");
1354 if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
1355 DBUS_TYPE_ARRAY_AS_STRING
1356 DBUS_TYPE_ARRAY_AS_STRING
1357 DBUS_TYPE_BYTE_AS_STRING,
1359 dbus_set_error(error, DBUS_ERROR_FAILED,
1360 "%s: failed to construct message 1", __func__);
1364 if (!dbus_message_iter_open_container(&variant_iter, DBUS_TYPE_ARRAY,
1365 DBUS_TYPE_ARRAY_AS_STRING
1366 DBUS_TYPE_BYTE_AS_STRING,
1368 dbus_set_error(error, DBUS_ERROR_FAILED,
1369 "%s: failed to construct message 2", __func__);
1373 if (info->wps_sec_dev_type_list_len) {
1374 const u8 *sec_dev_type_list = info->wps_sec_dev_type_list;
1375 int num_sec_device_types =
1376 info->wps_sec_dev_type_list_len / WPS_DEV_TYPE_LEN;
1378 DBusMessageIter inner_array_iter;
1380 for (i = 0; i < num_sec_device_types; i++) {
1381 if (!dbus_message_iter_open_container(
1382 &array_iter, DBUS_TYPE_ARRAY,
1383 DBUS_TYPE_BYTE_AS_STRING,
1384 &inner_array_iter)) {
1385 dbus_set_error(error, DBUS_ERROR_FAILED,
1386 "%s: failed to construct "
1392 if (!dbus_message_iter_append_fixed_array(
1393 &inner_array_iter, DBUS_TYPE_BYTE,
1394 &sec_dev_type_list, WPS_DEV_TYPE_LEN)) {
1395 dbus_set_error(error, DBUS_ERROR_FAILED,
1396 "%s: failed to construct "
1402 if (!dbus_message_iter_close_container(
1403 &array_iter, &inner_array_iter)) {
1404 dbus_set_error(error, DBUS_ERROR_FAILED,
1405 "%s: failed to construct "
1411 sec_dev_type_list += WPS_DEV_TYPE_LEN;
1415 if (!dbus_message_iter_close_container(&variant_iter, &array_iter)) {
1416 dbus_set_error(error, DBUS_ERROR_FAILED,
1417 "%s: failed to construct message 6", __func__);
1421 if (!dbus_message_iter_close_container(iter, &variant_iter)) {
1422 dbus_set_error(error, DBUS_ERROR_FAILED,
1423 "%s: failed to construct message 7", __func__);
1431 dbus_bool_t wpas_dbus_getter_p2p_peer_vendor_extension(DBusMessageIter *iter,
1435 struct wpabuf *vendor_extension[P2P_MAX_WPS_VENDOR_EXT];
1437 struct peer_handler_args *peer_args = user_data;
1438 const struct p2p_peer_info *info;
1440 info = p2p_get_peer_found(peer_args->wpa_s->global->p2p,
1441 peer_args->p2p_device_addr, 0);
1443 dbus_set_error(error, DBUS_ERROR_FAILED,
1444 "failed to find peer");
1448 /* Add WPS vendor extensions attribute */
1449 for (i = 0, num = 0; i < P2P_MAX_WPS_VENDOR_EXT; i++) {
1450 if (info->wps_vendor_ext[i] == NULL)
1452 vendor_extension[num] = info->wps_vendor_ext[i];
1456 if (!wpas_dbus_simple_array_array_property_getter(iter, DBUS_TYPE_BYTE,
1465 dbus_bool_t wpas_dbus_getter_p2p_peer_ies(DBusMessageIter *iter,
1466 DBusError *error, void *user_data)
1468 dbus_bool_t success;
1469 /* struct peer_handler_args *peer_args = user_data; */
1471 success = wpas_dbus_simple_array_property_getter(iter, DBUS_TYPE_BYTE,
1478 * wpas_dbus_getter_persistent_groups - Get array of persistent group objects
1479 * @iter: Pointer to incoming dbus message iter
1480 * @error: Location to store error on failure
1481 * @user_data: Function specific data
1482 * Returns: TRUE on success, FALSE on failure
1484 * Getter for "PersistentGroups" property.
1486 dbus_bool_t wpas_dbus_getter_persistent_groups(DBusMessageIter *iter,
1490 struct wpa_supplicant *wpa_s = user_data;
1491 struct wpa_ssid *ssid;
1493 unsigned int i = 0, num = 0;
1494 dbus_bool_t success = FALSE;
1496 if (wpa_s->conf == NULL) {
1497 wpa_printf(MSG_ERROR, "dbus: %s: "
1498 "An error occurred getting persistent groups list",
1500 dbus_set_error_const(error, DBUS_ERROR_FAILED, "an error "
1501 "occurred getting persistent groups list");
1505 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
1506 if (network_is_persistent_group(ssid))
1509 paths = os_zalloc(num * sizeof(char *));
1511 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
1515 /* Loop through configured networks and append object path of each */
1516 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) {
1517 if (!network_is_persistent_group(ssid))
1519 paths[i] = os_zalloc(WPAS_DBUS_OBJECT_PATH_MAX);
1520 if (paths[i] == NULL) {
1521 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY,
1525 /* Construct the object path for this network. */
1526 os_snprintf(paths[i++], WPAS_DBUS_OBJECT_PATH_MAX,
1527 "%s/" WPAS_DBUS_NEW_PERSISTENT_GROUPS_PART "/%d",
1528 wpa_s->dbus_new_path, ssid->id);
1531 success = wpas_dbus_simple_array_property_getter(iter,
1532 DBUS_TYPE_OBJECT_PATH,
1537 os_free(paths[--i]);
1544 * wpas_dbus_getter_persistent_group_properties - Get options for a persistent
1546 * @iter: Pointer to incoming dbus message iter
1547 * @error: Location to store error on failure
1548 * @user_data: Function specific data
1549 * Returns: TRUE on success, FALSE on failure
1551 * Getter for "Properties" property of a persistent group.
1553 dbus_bool_t wpas_dbus_getter_persistent_group_properties(DBusMessageIter *iter,
1557 struct network_handler_args *net = user_data;
1559 /* Leveraging the fact that persistent group object is still
1560 * represented in same manner as network within.
1562 return wpas_dbus_getter_network_properties(iter, error, net);
1567 * wpas_dbus_setter_persistent_group_properties - Get options for a persistent
1569 * @iter: Pointer to incoming dbus message iter
1570 * @error: Location to store error on failure
1571 * @user_data: Function specific data
1572 * Returns: TRUE on success, FALSE on failure
1574 * Setter for "Properties" property of a persistent group.
1576 dbus_bool_t wpas_dbus_setter_persistent_group_properties(DBusMessageIter *iter,
1580 struct network_handler_args *net = user_data;
1581 struct wpa_ssid *ssid = net->ssid;
1582 DBusMessageIter variant_iter;
1585 * Leveraging the fact that persistent group object is still
1586 * represented in same manner as network within.
1588 dbus_message_iter_recurse(iter, &variant_iter);
1589 return set_network_properties(net->wpa_s, ssid, &variant_iter, error);
1594 * wpas_dbus_new_iface_add_persistent_group - Add a new configured
1596 * @message: Pointer to incoming dbus message
1597 * @wpa_s: wpa_supplicant structure for a network interface
1598 * Returns: A dbus message containing the object path of the new
1601 * Handler function for "AddPersistentGroup" method call of a P2P Device
1604 DBusMessage * wpas_dbus_handler_add_persistent_group(
1605 DBusMessage *message, struct wpa_supplicant *wpa_s)
1607 DBusMessage *reply = NULL;
1608 DBusMessageIter iter;
1609 struct wpa_ssid *ssid = NULL;
1610 char path_buf[WPAS_DBUS_OBJECT_PATH_MAX], *path = path_buf;
1613 dbus_message_iter_init(message, &iter);
1615 ssid = wpa_config_add_network(wpa_s->conf);
1617 wpa_printf(MSG_ERROR, "dbus: %s: "
1618 "Cannot add new persistent group", __func__);
1619 reply = wpas_dbus_error_unknown_error(
1621 "wpa_supplicant could not add "
1622 "a persistent group on this interface.");
1626 /* Mark the ssid as being a persistent group before the notification */
1628 ssid->p2p_persistent_group = 1;
1629 wpas_notify_persistent_group_added(wpa_s, ssid);
1631 wpa_config_set_network_defaults(ssid);
1633 dbus_error_init(&error);
1634 if (!set_network_properties(wpa_s, ssid, &iter, &error)) {
1635 wpa_printf(MSG_DEBUG, "dbus: %s: "
1636 "Control interface could not set persistent group "
1637 "properties", __func__);
1638 reply = wpas_dbus_reply_new_from_error(message, &error,
1639 DBUS_ERROR_INVALID_ARGS,
1640 "Failed to set network "
1642 dbus_error_free(&error);
1646 /* Construct the object path for this network. */
1647 os_snprintf(path, WPAS_DBUS_OBJECT_PATH_MAX,
1648 "%s/" WPAS_DBUS_NEW_PERSISTENT_GROUPS_PART "/%d",
1649 wpa_s->dbus_new_path, ssid->id);
1651 reply = dbus_message_new_method_return(message);
1652 if (reply == NULL) {
1653 reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
1657 if (!dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH, &path,
1658 DBUS_TYPE_INVALID)) {
1659 dbus_message_unref(reply);
1660 reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
1669 wpas_notify_persistent_group_removed(wpa_s, ssid);
1670 wpa_config_remove_network(wpa_s->conf, ssid->id);
1677 * wpas_dbus_handler_remove_persistent_group - Remove a configured persistent
1679 * @message: Pointer to incoming dbus message
1680 * @wpa_s: wpa_supplicant structure for a network interface
1681 * Returns: NULL on success or dbus error on failure
1683 * Handler function for "RemovePersistentGroup" method call of a P2P Device
1686 DBusMessage * wpas_dbus_handler_remove_persistent_group(
1687 DBusMessage *message, struct wpa_supplicant *wpa_s)
1689 DBusMessage *reply = NULL;
1691 char *iface = NULL, *persistent_group_id = NULL;
1693 struct wpa_ssid *ssid;
1695 dbus_message_get_args(message, NULL, DBUS_TYPE_OBJECT_PATH, &op,
1699 * Extract the network ID and ensure the network is actually a child of
1702 iface = wpas_dbus_new_decompose_object_path(op, 1,
1703 &persistent_group_id,
1705 if (iface == NULL || os_strcmp(iface, wpa_s->dbus_new_path) != 0) {
1706 reply = wpas_dbus_error_invalid_args(message, op);
1710 id = strtoul(persistent_group_id, NULL, 10);
1711 if (errno == EINVAL) {
1712 reply = wpas_dbus_error_invalid_args(message, op);
1716 ssid = wpa_config_get_network(wpa_s->conf, id);
1718 reply = wpas_dbus_error_persistent_group_unknown(message);
1722 wpas_notify_persistent_group_removed(wpa_s, ssid);
1724 if (wpa_config_remove_network(wpa_s->conf, id) < 0) {
1725 wpa_printf(MSG_ERROR, "dbus: %s: "
1726 "error occurred when removing persistent group %d",
1728 reply = wpas_dbus_error_unknown_error(
1730 "error removing the specified persistent group on "
1737 os_free(persistent_group_id);
1742 static void remove_persistent_group(struct wpa_supplicant *wpa_s,
1743 struct wpa_ssid *ssid)
1745 wpas_notify_persistent_group_removed(wpa_s, ssid);
1747 if (wpa_config_remove_network(wpa_s->conf, ssid->id) < 0) {
1748 wpa_printf(MSG_ERROR, "dbus: %s: "
1749 "error occurred when removing persistent group %d",
1750 __func__, ssid->id);
1757 * wpas_dbus_handler_remove_all_persistent_groups - Remove all configured
1759 * @message: Pointer to incoming dbus message
1760 * @wpa_s: wpa_supplicant structure for a network interface
1761 * Returns: NULL on success or dbus error on failure
1763 * Handler function for "RemoveAllPersistentGroups" method call of a
1764 * P2P Device interface.
1766 DBusMessage * wpas_dbus_handler_remove_all_persistent_groups(
1767 DBusMessage *message, struct wpa_supplicant *wpa_s)
1769 struct wpa_ssid *ssid, *next;
1770 struct wpa_config *config;
1772 config = wpa_s->conf;
1773 ssid = config->ssid;
1776 if (network_is_persistent_group(ssid))
1777 remove_persistent_group(wpa_s, ssid);
1785 * Group object properties accessor methods
1788 dbus_bool_t wpas_dbus_getter_p2p_group_members(DBusMessageIter *iter,
1792 struct wpa_supplicant *wpa_s = user_data;
1793 struct wpa_ssid *ssid;
1794 unsigned int num_members;
1799 dbus_bool_t success = FALSE;
1801 /* Verify correct role for this property */
1802 if (wpas_get_p2p_role(wpa_s) != WPAS_P2P_ROLE_GO) {
1803 return wpas_dbus_simple_array_property_getter(
1804 iter, DBUS_TYPE_OBJECT_PATH, NULL, 0, error);
1807 ssid = wpa_s->conf->ssid;
1808 /* At present WPAS P2P_GO mode only applicable for p2p_go */
1809 if (ssid->mode != WPAS_MODE_P2P_GO &&
1810 ssid->mode != WPAS_MODE_AP &&
1811 ssid->mode != WPAS_MODE_P2P_GROUP_FORMATION)
1814 num_members = p2p_get_group_num_members(wpa_s->p2p_group);
1816 paths = os_zalloc(num_members * sizeof(char *));
1821 while ((addr = p2p_iterate_group_members(wpa_s->p2p_group, &next))) {
1822 paths[i] = os_zalloc(WPAS_DBUS_OBJECT_PATH_MAX);
1825 os_snprintf(paths[i], WPAS_DBUS_OBJECT_PATH_MAX,
1826 "%s/" WPAS_DBUS_NEW_P2P_GROUPMEMBERS_PART
1828 wpa_s->dbus_groupobj_path, MAC2STR(addr));
1832 success = wpas_dbus_simple_array_property_getter(iter,
1833 DBUS_TYPE_OBJECT_PATH,
1837 for (i = 0; i < num_members; i++)
1843 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
1845 for (i = 0; i < num_members; i++)
1853 dbus_bool_t wpas_dbus_getter_p2p_group_ssid(DBusMessageIter *iter,
1854 DBusError *error, void *user_data)
1856 struct wpa_supplicant *wpa_s = user_data;
1857 if (wpa_s->current_ssid == NULL)
1859 return wpas_dbus_simple_array_property_getter(
1860 iter, DBUS_TYPE_BYTE, wpa_s->current_ssid->ssid,
1861 wpa_s->current_ssid->ssid_len, error);
1865 dbus_bool_t wpas_dbus_getter_p2p_group_bssid(DBusMessageIter *iter,
1869 struct wpa_supplicant *wpa_s = user_data;
1870 u8 role = wpas_get_p2p_role(wpa_s);
1873 if (role == WPAS_P2P_ROLE_CLIENT) {
1874 if (wpa_s->current_ssid == NULL)
1876 p_bssid = wpa_s->current_ssid->bssid;
1878 if (wpa_s->ap_iface == NULL)
1880 p_bssid = wpa_s->ap_iface->bss[0]->own_addr;
1883 return wpas_dbus_simple_array_property_getter(iter, DBUS_TYPE_BYTE,
1889 dbus_bool_t wpas_dbus_getter_p2p_group_frequency(DBusMessageIter *iter,
1893 struct wpa_supplicant *wpa_s = user_data;
1895 u8 role = wpas_get_p2p_role(wpa_s);
1897 if (role == WPAS_P2P_ROLE_CLIENT) {
1898 if (wpa_s->go_params == NULL)
1900 op_freq = wpa_s->go_params->freq;
1902 if (wpa_s->ap_iface == NULL)
1904 op_freq = wpa_s->ap_iface->freq;
1907 return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_UINT16,
1912 dbus_bool_t wpas_dbus_getter_p2p_group_passphrase(DBusMessageIter *iter,
1916 struct wpa_supplicant *wpa_s = user_data;
1917 u8 role = wpas_get_p2p_role(wpa_s);
1918 char *p_pass = NULL;
1920 /* Verify correct role for this property */
1921 if (role == WPAS_P2P_ROLE_GO) {
1922 if (wpa_s->current_ssid == NULL)
1924 p_pass = wpa_s->current_ssid->passphrase;
1928 return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING,
1934 dbus_bool_t wpas_dbus_getter_p2p_group_psk(DBusMessageIter *iter,
1935 DBusError *error, void *user_data)
1937 struct wpa_supplicant *wpa_s = user_data;
1938 u8 role = wpas_get_p2p_role(wpa_s);
1942 /* Verify correct role for this property */
1943 if (role == WPAS_P2P_ROLE_CLIENT) {
1944 if (wpa_s->current_ssid == NULL)
1946 p_psk = wpa_s->current_ssid->psk;
1950 return wpas_dbus_simple_array_property_getter(iter, DBUS_TYPE_BYTE,
1951 &p_psk, psk_len, error);
1955 dbus_bool_t wpas_dbus_getter_p2p_group_vendor_ext(DBusMessageIter *iter,
1959 struct wpa_supplicant *wpa_s = user_data;
1960 struct hostapd_data *hapd;
1961 struct wpabuf *vendor_ext[MAX_WPS_VENDOR_EXTENSIONS];
1962 int num_vendor_ext = 0;
1965 /* Verify correct role for this property */
1966 if (wpas_get_p2p_role(wpa_s) == WPAS_P2P_ROLE_GO) {
1967 if (wpa_s->ap_iface == NULL)
1969 hapd = wpa_s->ap_iface->bss[0];
1971 /* Parse WPS Vendor Extensions sent in Beacon/Probe Response */
1972 for (i = 0; i < MAX_WPS_VENDOR_EXTENSIONS; i++) {
1973 if (hapd->conf->wps_vendor_ext[i] == NULL)
1974 vendor_ext[i] = NULL;
1976 vendor_ext[num_vendor_ext++] =
1977 hapd->conf->wps_vendor_ext[i];
1982 /* Return vendor extensions or no data */
1983 return wpas_dbus_simple_array_array_property_getter(iter,
1991 dbus_bool_t wpas_dbus_setter_p2p_group_vendor_ext(DBusMessageIter *iter,
1995 struct wpa_supplicant *wpa_s = user_data;
1996 DBusMessageIter variant_iter, iter_dict;
1997 struct wpa_dbus_dict_entry entry = { .type = DBUS_TYPE_STRING };
1999 struct hostapd_data *hapd = NULL;
2001 if (wpas_get_p2p_role(wpa_s) == WPAS_P2P_ROLE_GO &&
2002 wpa_s->ap_iface != NULL)
2003 hapd = wpa_s->ap_iface->bss[0];
2007 dbus_message_iter_recurse(iter, &variant_iter);
2008 if (!wpa_dbus_dict_open_read(&variant_iter, &iter_dict, error))
2011 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
2012 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry)) {
2013 dbus_set_error_const(error, DBUS_ERROR_INVALID_ARGS,
2014 "invalid message format");
2018 if (os_strcmp(entry.key, "WPSVendorExtensions") == 0) {
2019 if (entry.type != DBUS_TYPE_ARRAY ||
2020 entry.array_type != WPAS_DBUS_TYPE_BINARRAY ||
2021 entry.array_len > MAX_WPS_VENDOR_EXTENSIONS)
2024 for (i = 0; i < MAX_WPS_VENDOR_EXTENSIONS; i++) {
2025 if (i < entry.array_len) {
2026 hapd->conf->wps_vendor_ext[i] =
2027 entry.binarray_value[i];
2028 entry.binarray_value[i] = NULL;
2030 hapd->conf->wps_vendor_ext[i] = NULL;
2033 hostapd_update_wps(hapd);
2037 wpa_dbus_dict_entry_clear(&entry);
2043 wpa_dbus_dict_entry_clear(&entry);
2044 dbus_set_error_const(error, DBUS_ERROR_INVALID_ARGS,
2045 "invalid message format");
2050 DBusMessage * wpas_dbus_handler_p2p_add_service(DBusMessage *message,
2051 struct wpa_supplicant *wpa_s)
2053 DBusMessageIter iter_dict;
2054 DBusMessage *reply = NULL;
2055 DBusMessageIter iter;
2056 struct wpa_dbus_dict_entry entry;
2059 char *service = NULL;
2060 struct wpabuf *query = NULL;
2061 struct wpabuf *resp = NULL;
2064 dbus_message_iter_init(message, &iter);
2066 if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
2069 if (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
2070 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
2073 if (!os_strcmp(entry.key, "service_type") &&
2074 (entry.type == DBUS_TYPE_STRING)) {
2075 if (!os_strcmp(entry.str_value, "upnp"))
2077 else if (!os_strcmp(entry.str_value, "bonjour"))
2081 wpa_dbus_dict_entry_clear(&entry);
2086 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
2087 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
2090 if (!os_strcmp(entry.key, "version") &&
2091 entry.type == DBUS_TYPE_INT32)
2092 version = entry.uint32_value;
2093 else if (!os_strcmp(entry.key, "service") &&
2094 entry.type == DBUS_TYPE_STRING)
2095 service = os_strdup(entry.str_value);
2096 wpa_dbus_dict_entry_clear(&entry);
2098 if (version <= 0 || service == NULL)
2101 if (wpas_p2p_service_add_upnp(wpa_s, version, service) != 0)
2105 } else if (bonjour == 1) {
2106 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
2107 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
2110 if (!os_strcmp(entry.key, "query")) {
2111 if ((entry.type != DBUS_TYPE_ARRAY) ||
2112 (entry.array_type != DBUS_TYPE_BYTE))
2114 query = wpabuf_alloc_copy(
2115 entry.bytearray_value,
2117 } else if (!os_strcmp(entry.key, "response")) {
2118 if ((entry.type != DBUS_TYPE_ARRAY) ||
2119 (entry.array_type != DBUS_TYPE_BYTE))
2121 resp = wpabuf_alloc_copy(entry.bytearray_value,
2125 wpa_dbus_dict_entry_clear(&entry);
2128 if (query == NULL || resp == NULL)
2131 if (wpas_p2p_service_add_bonjour(wpa_s, query, resp) < 0) {
2141 wpa_dbus_dict_entry_clear(&entry);
2143 return wpas_dbus_error_invalid_args(message, NULL);
2147 DBusMessage * wpas_dbus_handler_p2p_delete_service(
2148 DBusMessage *message, struct wpa_supplicant *wpa_s)
2150 DBusMessageIter iter_dict;
2151 DBusMessage *reply = NULL;
2152 DBusMessageIter iter;
2153 struct wpa_dbus_dict_entry entry;
2157 char *service = NULL;
2158 struct wpabuf *query = NULL;
2161 dbus_message_iter_init(message, &iter);
2163 if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
2166 if (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
2167 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
2170 if (!os_strcmp(entry.key, "service_type") &&
2171 (entry.type == DBUS_TYPE_STRING)) {
2172 if (!os_strcmp(entry.str_value, "upnp"))
2174 else if (!os_strcmp(entry.str_value, "bonjour"))
2178 wpa_dbus_dict_entry_clear(&entry);
2182 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
2183 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
2185 if (!os_strcmp(entry.key, "version") &&
2186 entry.type == DBUS_TYPE_INT32)
2187 version = entry.uint32_value;
2188 else if (!os_strcmp(entry.key, "service") &&
2189 entry.type == DBUS_TYPE_STRING)
2190 service = os_strdup(entry.str_value);
2194 wpa_dbus_dict_entry_clear(&entry);
2197 if (version <= 0 || service == NULL)
2200 ret = wpas_p2p_service_del_upnp(wpa_s, version, service);
2204 } else if (bonjour == 1) {
2205 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
2206 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
2209 if (!os_strcmp(entry.key, "query")) {
2210 if ((entry.type != DBUS_TYPE_ARRAY) ||
2211 (entry.array_type != DBUS_TYPE_BYTE))
2213 query = wpabuf_alloc_copy(
2214 entry.bytearray_value,
2219 wpa_dbus_dict_entry_clear(&entry);
2225 ret = wpas_p2p_service_del_bonjour(wpa_s, query);
2234 wpa_dbus_dict_entry_clear(&entry);
2236 return wpas_dbus_error_invalid_args(message, NULL);
2240 DBusMessage * wpas_dbus_handler_p2p_flush_service(DBusMessage *message,
2241 struct wpa_supplicant *wpa_s)
2243 wpas_p2p_service_flush(wpa_s);
2248 DBusMessage * wpas_dbus_handler_p2p_service_sd_req(
2249 DBusMessage *message, struct wpa_supplicant *wpa_s)
2251 DBusMessageIter iter_dict;
2252 DBusMessage *reply = NULL;
2253 DBusMessageIter iter;
2254 struct wpa_dbus_dict_entry entry;
2256 char *service = NULL;
2257 char *peer_object_path = NULL;
2258 struct wpabuf *tlv = NULL;
2263 dbus_message_iter_init(message, &iter);
2265 if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
2268 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
2269 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
2271 if (!os_strcmp(entry.key, "peer_object") &&
2272 entry.type == DBUS_TYPE_OBJECT_PATH) {
2273 peer_object_path = os_strdup(entry.str_value);
2274 } else if (!os_strcmp(entry.key, "service_type") &&
2275 entry.type == DBUS_TYPE_STRING) {
2276 if (!os_strcmp(entry.str_value, "upnp"))
2280 } else if (!os_strcmp(entry.key, "version") &&
2281 entry.type == DBUS_TYPE_INT32) {
2282 version = entry.uint32_value;
2283 } else if (!os_strcmp(entry.key, "service") &&
2284 entry.type == DBUS_TYPE_STRING) {
2285 service = os_strdup(entry.str_value);
2286 } else if (!os_strcmp(entry.key, "tlv")) {
2287 if (entry.type != DBUS_TYPE_ARRAY ||
2288 entry.array_type != DBUS_TYPE_BYTE)
2290 tlv = wpabuf_alloc_copy(entry.bytearray_value,
2295 wpa_dbus_dict_entry_clear(&entry);
2298 if (!peer_object_path ||
2299 (parse_peer_object_path(peer_object_path, addr) < 0) ||
2300 !p2p_peer_known(wpa_s->global->p2p, addr))
2304 if (version <= 0 || service == NULL)
2307 ref = wpas_p2p_sd_request_upnp(wpa_s, addr, version, service);
2311 ref = wpas_p2p_sd_request(wpa_s, addr, tlv);
2316 reply = dbus_message_new_method_return(message);
2317 dbus_message_append_args(reply, DBUS_TYPE_UINT64,
2318 &ref, DBUS_TYPE_INVALID);
2320 reply = wpas_dbus_error_unknown_error(
2321 message, "Unable to send SD request");
2325 os_free(peer_object_path);
2328 wpa_dbus_dict_entry_clear(&entry);
2332 reply = wpas_dbus_error_invalid_args(message, NULL);
2337 DBusMessage * wpas_dbus_handler_p2p_service_sd_res(
2338 DBusMessage *message, struct wpa_supplicant *wpa_s)
2340 DBusMessageIter iter_dict;
2341 DBusMessage *reply = NULL;
2342 DBusMessageIter iter;
2343 struct wpa_dbus_dict_entry entry;
2344 char *peer_object_path = NULL;
2345 struct wpabuf *tlv = NULL;
2350 dbus_message_iter_init(message, &iter);
2352 if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
2355 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
2356 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
2359 if (!os_strcmp(entry.key, "peer_object") &&
2360 entry.type == DBUS_TYPE_OBJECT_PATH) {
2361 peer_object_path = os_strdup(entry.str_value);
2362 } else if (!os_strcmp(entry.key, "frequency") &&
2363 entry.type == DBUS_TYPE_INT32) {
2364 freq = entry.uint32_value;
2365 } else if (!os_strcmp(entry.key, "dialog_token") &&
2366 entry.type == DBUS_TYPE_UINT32) {
2367 dlg_tok = entry.uint32_value;
2368 } else if (!os_strcmp(entry.key, "tlvs")) {
2369 if (entry.type != DBUS_TYPE_ARRAY ||
2370 entry.array_type != DBUS_TYPE_BYTE)
2372 tlv = wpabuf_alloc_copy(entry.bytearray_value,
2377 wpa_dbus_dict_entry_clear(&entry);
2379 if (!peer_object_path ||
2380 (parse_peer_object_path(peer_object_path, addr) < 0) ||
2381 !p2p_peer_known(wpa_s->global->p2p, addr))
2387 wpas_p2p_sd_response(wpa_s, freq, addr, (u8) dlg_tok, tlv);
2390 os_free(peer_object_path);
2393 wpa_dbus_dict_entry_clear(&entry);
2395 reply = wpas_dbus_error_invalid_args(message, NULL);
2400 DBusMessage * wpas_dbus_handler_p2p_service_sd_cancel_req(
2401 DBusMessage *message, struct wpa_supplicant *wpa_s)
2403 DBusMessageIter iter;
2406 dbus_message_iter_init(message, &iter);
2407 dbus_message_iter_get_basic(&iter, &req);
2412 if (!wpas_p2p_sd_cancel_request(wpa_s, req))
2417 return wpas_dbus_error_invalid_args(message, NULL);
2421 DBusMessage * wpas_dbus_handler_p2p_service_update(
2422 DBusMessage *message, struct wpa_supplicant *wpa_s)
2424 wpas_p2p_sd_service_update(wpa_s);
2429 DBusMessage * wpas_dbus_handler_p2p_serv_disc_external(
2430 DBusMessage *message, struct wpa_supplicant *wpa_s)
2432 DBusMessageIter iter;
2435 dbus_message_iter_init(message, &iter);
2436 dbus_message_iter_get_basic(&iter, &ext);
2438 wpa_s->p2p_sd_over_ctrl_iface = ext;