2 * WPA Supplicant / dbus-based control interface (P2P)
3 * Copyright (c) 2011-2012, Intel Corporation
5 * This software may be distributed under the terms of the BSD license.
6 * See README for more details.
11 #include "utils/includes.h"
13 #include "../config.h"
14 #include "../wpa_supplicant_i.h"
15 #include "../wps_supplicant.h"
16 #include "../notify.h"
17 #include "dbus_new_helpers.h"
19 #include "dbus_new_handlers.h"
20 #include "dbus_new_handlers_p2p.h"
21 #include "dbus_dict_helpers.h"
23 #include "common/ieee802_11_defs.h"
24 #include "ap/hostapd.h"
25 #include "ap/ap_config.h"
26 #include "ap/wps_hostapd.h"
28 #include "../p2p_supplicant.h"
31 * Parses out the mac address from the peer object path.
32 * @peer_path - object path of the form
33 * /fi/w1/wpa_supplicant1/Interfaces/n/Peers/00112233445566 (no colons)
34 * @addr - out param must be of ETH_ALEN size
35 * Returns 0 if valid (including MAC), -1 otherwise
37 static int parse_peer_object_path(char *peer_path, u8 addr[ETH_ALEN])
43 p = os_strrchr(peer_path, '/');
47 return hwaddr_compact_aton(p, addr);
52 * wpas_dbus_error_persistent_group_unknown - Return a new PersistentGroupUnknown
54 * @message: Pointer to incoming dbus message this error refers to
55 * Returns: a dbus error message
57 * Convenience function to create and return an invalid persistent group error.
59 static DBusMessage * wpas_dbus_error_persistent_group_unknown(
62 return dbus_message_new_error(message, WPAS_DBUS_ERROR_NETWORK_UNKNOWN,
63 "There is no such persistent group in "
68 DBusMessage * wpas_dbus_handler_p2p_find(DBusMessage *message,
69 struct wpa_supplicant *wpa_s)
71 struct wpa_dbus_dict_entry entry;
72 DBusMessage *reply = NULL;
74 DBusMessageIter iter_dict;
75 unsigned int timeout = 0;
76 enum p2p_discovery_type type = P2P_FIND_ONLY_SOCIAL;
77 int num_req_dev_types = 0;
79 u8 *req_dev_types = NULL;
81 dbus_message_iter_init(message, &iter);
84 if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
87 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
88 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
91 if (!os_strcmp(entry.key, "Timeout") &&
92 (entry.type == DBUS_TYPE_INT32)) {
93 timeout = entry.uint32_value;
94 } else if (os_strcmp(entry.key, "RequestedDeviceTypes") == 0) {
95 if ((entry.type != DBUS_TYPE_ARRAY) ||
96 (entry.array_type != WPAS_DBUS_TYPE_BINARRAY))
99 os_free(req_dev_types);
101 os_malloc(WPS_DEV_TYPE_LEN * entry.array_len);
105 for (i = 0; i < entry.array_len; i++) {
106 if (wpabuf_len(entry.binarray_value[i]) !=
109 os_memcpy(req_dev_types + i * WPS_DEV_TYPE_LEN,
110 wpabuf_head(entry.binarray_value[i]),
113 num_req_dev_types = entry.array_len;
114 } else if (!os_strcmp(entry.key, "DiscoveryType") &&
115 (entry.type == DBUS_TYPE_STRING)) {
116 if (!os_strcmp(entry.str_value, "start_with_full"))
117 type = P2P_FIND_START_WITH_FULL;
118 else if (!os_strcmp(entry.str_value, "social"))
119 type = P2P_FIND_ONLY_SOCIAL;
120 else if (!os_strcmp(entry.str_value, "progressive"))
121 type = P2P_FIND_PROGRESSIVE;
126 wpa_dbus_dict_entry_clear(&entry);
129 wpas_p2p_find(wpa_s, timeout, type, num_req_dev_types, req_dev_types,
131 os_free(req_dev_types);
135 wpa_dbus_dict_entry_clear(&entry);
137 os_free(req_dev_types);
138 reply = wpas_dbus_error_invalid_args(message, entry.key);
143 DBusMessage * wpas_dbus_handler_p2p_stop_find(DBusMessage *message,
144 struct wpa_supplicant *wpa_s)
146 wpas_p2p_stop_find(wpa_s);
151 DBusMessage * wpas_dbus_handler_p2p_rejectpeer(DBusMessage *message,
152 struct wpa_supplicant *wpa_s)
154 DBusMessageIter iter;
155 char *peer_object_path = NULL;
156 u8 peer_addr[ETH_ALEN];
158 dbus_message_iter_init(message, &iter);
159 dbus_message_iter_get_basic(&iter, &peer_object_path);
161 if (parse_peer_object_path(peer_object_path, peer_addr) < 0)
162 return wpas_dbus_error_invalid_args(message, NULL);
164 if (wpas_p2p_reject(wpa_s, peer_addr) < 0)
165 return wpas_dbus_error_unknown_error(message,
166 "Failed to call wpas_p2p_reject method.");
172 DBusMessage * wpas_dbus_handler_p2p_listen(DBusMessage *message,
173 struct wpa_supplicant *wpa_s)
175 dbus_int32_t timeout = 0;
177 if (!dbus_message_get_args(message, NULL, DBUS_TYPE_INT32, &timeout,
179 return dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
182 if (wpas_p2p_listen(wpa_s, (unsigned int)timeout))
183 return dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
190 DBusMessage * wpas_dbus_handler_p2p_extendedlisten(
191 DBusMessage *message, struct wpa_supplicant *wpa_s)
193 unsigned int period = 0, interval = 0;
194 struct wpa_dbus_dict_entry entry;
195 DBusMessageIter iter;
196 DBusMessageIter iter_dict;
198 dbus_message_iter_init(message, &iter);
201 if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
204 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
205 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
208 if (!os_strcmp(entry.key, "period") &&
209 (entry.type == DBUS_TYPE_INT32))
210 period = entry.uint32_value;
211 else if (!os_strcmp(entry.key, "interval") &&
212 (entry.type == DBUS_TYPE_INT32))
213 interval = entry.uint32_value;
216 wpa_dbus_dict_entry_clear(&entry);
219 if (wpas_p2p_ext_listen(wpa_s, period, interval))
220 return wpas_dbus_error_unknown_error(
221 message, "failed to initiate a p2p_ext_listen.");
226 wpa_dbus_dict_entry_clear(&entry);
228 return wpas_dbus_error_invalid_args(message, entry.key);
232 DBusMessage * wpas_dbus_handler_p2p_presence_request(
233 DBusMessage *message, struct wpa_supplicant *wpa_s)
235 unsigned int dur1 = 0, int1 = 0, dur2 = 0, int2 = 0;
236 struct wpa_dbus_dict_entry entry;
237 DBusMessageIter iter;
238 DBusMessageIter iter_dict;
240 dbus_message_iter_init(message, &iter);
243 if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
246 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
247 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
250 if (!os_strcmp(entry.key, "duration1") &&
251 (entry.type == DBUS_TYPE_INT32))
252 dur1 = entry.uint32_value;
253 else if (!os_strcmp(entry.key, "interval1") &&
254 entry.type == DBUS_TYPE_INT32)
255 int1 = entry.uint32_value;
256 else if (!os_strcmp(entry.key, "duration2") &&
257 entry.type == DBUS_TYPE_INT32)
258 dur2 = entry.uint32_value;
259 else if (!os_strcmp(entry.key, "interval2") &&
260 entry.type == DBUS_TYPE_INT32)
261 int2 = entry.uint32_value;
265 wpa_dbus_dict_entry_clear(&entry);
267 if (wpas_p2p_presence_req(wpa_s, dur1, int1, dur2, int2) < 0)
268 return wpas_dbus_error_unknown_error(message,
269 "Failed to invoke presence request.");
274 wpa_dbus_dict_entry_clear(&entry);
276 return wpas_dbus_error_invalid_args(message, entry.key);
280 DBusMessage * wpas_dbus_handler_p2p_group_add(DBusMessage *message,
281 struct wpa_supplicant *wpa_s)
283 DBusMessageIter iter_dict;
284 DBusMessage *reply = NULL;
285 DBusMessageIter iter;
286 struct wpa_dbus_dict_entry entry;
287 char *pg_object_path = NULL;
288 int persistent_group = 0;
291 char *net_id_str = NULL;
292 unsigned int group_id = 0;
293 struct wpa_ssid *ssid;
295 dbus_message_iter_init(message, &iter);
297 if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
300 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
301 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
304 if (!os_strcmp(entry.key, "persistent") &&
305 (entry.type == DBUS_TYPE_BOOLEAN)) {
306 persistent_group = (entry.bool_value == TRUE) ? 1 : 0;
307 } else if (!os_strcmp(entry.key, "frequency") &&
308 (entry.type == DBUS_TYPE_INT32)) {
309 freq = entry.int32_value;
312 } else if (!os_strcmp(entry.key, "persistent_group_object") &&
313 entry.type == DBUS_TYPE_OBJECT_PATH)
314 pg_object_path = os_strdup(entry.str_value);
318 wpa_dbus_dict_entry_clear(&entry);
321 if (pg_object_path != NULL) {
323 * A persistent group Object Path is defined meaning we want
324 * to re-invoke a persistent group.
327 iface = wpas_dbus_new_decompose_object_path(pg_object_path, 1,
330 os_strcmp(iface, wpa_s->dbus_new_path) != 0) {
332 wpas_dbus_error_invalid_args(message,
337 group_id = strtoul(net_id_str, NULL, 10);
338 if (errno == EINVAL) {
339 reply = wpas_dbus_error_invalid_args(
340 message, pg_object_path);
344 /* Get the SSID structure from the persistent group id */
345 ssid = wpa_config_get_network(wpa_s->conf, group_id);
346 if (ssid == NULL || ssid->disabled != 2)
349 if (wpas_p2p_group_add_persistent(wpa_s, ssid, 0, freq, 0)) {
350 reply = wpas_dbus_error_unknown_error(
352 "Failed to reinvoke a persistent group");
355 } else if (wpas_p2p_group_add(wpa_s, persistent_group, freq, 0))
359 os_free(pg_object_path);
364 wpa_dbus_dict_entry_clear(&entry);
366 reply = wpas_dbus_error_invalid_args(message, NULL);
371 DBusMessage * wpas_dbus_handler_p2p_disconnect(DBusMessage *message,
372 struct wpa_supplicant *wpa_s)
374 if (wpas_p2p_disconnect(wpa_s))
375 return wpas_dbus_error_unknown_error(message,
376 "failed to disconnect");
382 static dbus_bool_t wpa_dbus_p2p_check_enabled(struct wpa_supplicant *wpa_s,
383 DBusMessage *message,
384 DBusMessage **out_reply,
387 /* Return an error message or an error if P2P isn't available */
388 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL) {
390 *out_reply = dbus_message_new_error(
391 message, DBUS_ERROR_FAILED,
392 "P2P is not available for this interface");
394 dbus_set_error_const(error, DBUS_ERROR_FAILED,
395 "P2P is not available for this "
403 DBusMessage * wpas_dbus_handler_p2p_flush(DBusMessage *message,
404 struct wpa_supplicant *wpa_s)
406 DBusMessage *reply = NULL;
408 if (!wpa_dbus_p2p_check_enabled(wpa_s, message, &reply, NULL))
411 os_memset(wpa_s->p2p_auth_invite, 0, ETH_ALEN);
412 wpa_s->force_long_sd = 0;
413 p2p_flush(wpa_s->global->p2p);
419 DBusMessage * wpas_dbus_handler_p2p_connect(DBusMessage *message,
420 struct wpa_supplicant *wpa_s)
422 DBusMessageIter iter_dict;
423 DBusMessage *reply = NULL;
424 DBusMessageIter iter;
425 struct wpa_dbus_dict_entry entry;
426 char *peer_object_path = NULL;
427 int persistent_group = 0;
429 int authorize_only = 0;
434 enum p2p_wps_method wps_method = WPS_NOT_READY;
436 char *err_msg = NULL;
439 if (!wpa_dbus_p2p_check_enabled(wpa_s, message, &reply, NULL))
442 dbus_message_iter_init(message, &iter);
444 if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
447 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
448 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
451 if (!os_strcmp(entry.key, "peer") &&
452 (entry.type == DBUS_TYPE_OBJECT_PATH)) {
453 peer_object_path = os_strdup(entry.str_value);
454 } else if (!os_strcmp(entry.key, "persistent") &&
455 (entry.type == DBUS_TYPE_BOOLEAN)) {
456 persistent_group = (entry.bool_value == TRUE) ? 1 : 0;
457 } else if (!os_strcmp(entry.key, "join") &&
458 (entry.type == DBUS_TYPE_BOOLEAN)) {
459 join = (entry.bool_value == TRUE) ? 1 : 0;
460 } else if (!os_strcmp(entry.key, "authorize_only") &&
461 (entry.type == DBUS_TYPE_BOOLEAN)) {
462 authorize_only = (entry.bool_value == TRUE) ? 1 : 0;
463 } else if (!os_strcmp(entry.key, "frequency") &&
464 (entry.type == DBUS_TYPE_INT32)) {
465 freq = entry.int32_value;
468 } else if (!os_strcmp(entry.key, "go_intent") &&
469 (entry.type == DBUS_TYPE_INT32)) {
470 go_intent = entry.int32_value;
471 if ((go_intent < 0) || (go_intent > 15))
473 } else if (!os_strcmp(entry.key, "wps_method") &&
474 (entry.type == DBUS_TYPE_STRING)) {
475 if (!os_strcmp(entry.str_value, "pbc"))
476 wps_method = WPS_PBC;
477 else if (!os_strcmp(entry.str_value, "pin"))
478 wps_method = WPS_PIN_DISPLAY;
479 else if (!os_strcmp(entry.str_value, "display"))
480 wps_method = WPS_PIN_DISPLAY;
481 else if (!os_strcmp(entry.str_value, "keypad"))
482 wps_method = WPS_PIN_KEYPAD;
485 } else if (!os_strcmp(entry.key, "pin") &&
486 (entry.type == DBUS_TYPE_STRING)) {
487 pin = os_strdup(entry.str_value);
491 wpa_dbus_dict_entry_clear(&entry);
494 if (!peer_object_path || (wps_method == WPS_NOT_READY) ||
495 (parse_peer_object_path(peer_object_path, addr) < 0) ||
496 !p2p_peer_known(wpa_s->global->p2p, addr))
500 * Validate the wps_method specified and the pin value.
502 if ((!pin || !pin[0]) && (wps_method == WPS_PIN_KEYPAD))
505 new_pin = wpas_p2p_connect(wpa_s, addr, pin, wps_method,
506 persistent_group, 0, join, authorize_only,
507 go_intent, freq, -1, 0, 0);
512 os_snprintf(npin, sizeof(npin), "%08d", new_pin);
513 generated_pin = npin;
514 reply = dbus_message_new_method_return(message);
515 dbus_message_append_args(reply, DBUS_TYPE_STRING,
516 &generated_pin, DBUS_TYPE_INVALID);
520 err_msg = "connect failed due to channel "
522 iface = WPAS_DBUS_ERROR_CONNECT_CHANNEL_UNAVAILABLE;
526 err_msg = "connect failed due to unsupported channel.";
527 iface = WPAS_DBUS_ERROR_CONNECT_CHANNEL_UNSUPPORTED;
531 err_msg = "connect failed due to unspecified error.";
532 iface = WPAS_DBUS_ERROR_CONNECT_UNSPECIFIED_ERROR;
538 * Do we need specialized errors corresponding to above
539 * error conditions as against just returning a different
542 reply = dbus_message_new_error(message, iface, err_msg);
546 os_free(peer_object_path);
550 wpa_dbus_dict_entry_clear(&entry);
552 reply = wpas_dbus_error_invalid_args(message, NULL);
557 DBusMessage * wpas_dbus_handler_p2p_invite(DBusMessage *message,
558 struct wpa_supplicant *wpa_s)
560 DBusMessageIter iter_dict;
561 DBusMessage *reply = NULL;
562 DBusMessageIter iter;
563 struct wpa_dbus_dict_entry entry;
564 char *peer_object_path = NULL;
565 char *pg_object_path = NULL;
567 char *net_id_str = NULL;
568 u8 peer_addr[ETH_ALEN];
569 unsigned int group_id = 0;
571 struct wpa_ssid *ssid;
573 if (!wpa_dbus_p2p_check_enabled(wpa_s, message, &reply, NULL))
576 dbus_message_iter_init(message, &iter);
578 if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
581 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
582 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
585 if (!os_strcmp(entry.key, "peer") &&
586 (entry.type == DBUS_TYPE_OBJECT_PATH)) {
587 peer_object_path = os_strdup(entry.str_value);
588 wpa_dbus_dict_entry_clear(&entry);
589 } else if (!os_strcmp(entry.key, "persistent_group_object") &&
590 (entry.type == DBUS_TYPE_OBJECT_PATH)) {
591 pg_object_path = os_strdup(entry.str_value);
593 wpa_dbus_dict_entry_clear(&entry);
595 wpa_dbus_dict_entry_clear(&entry);
600 if (!peer_object_path ||
601 (parse_peer_object_path(peer_object_path, peer_addr) < 0) ||
602 !p2p_peer_known(wpa_s->global->p2p, peer_addr)) {
608 * A group ID is defined meaning we want to re-invoke a
612 iface = wpas_dbus_new_decompose_object_path(pg_object_path, 1,
615 os_strcmp(iface, wpa_s->dbus_new_path) != 0) {
616 reply = wpas_dbus_error_invalid_args(message,
621 group_id = strtoul(net_id_str, NULL, 10);
622 if (errno == EINVAL) {
623 reply = wpas_dbus_error_invalid_args(
624 message, pg_object_path);
628 /* Get the SSID structure from the persistent group id */
629 ssid = wpa_config_get_network(wpa_s->conf, group_id);
630 if (ssid == NULL || ssid->disabled != 2)
633 if (wpas_p2p_invite(wpa_s, peer_addr, ssid, NULL, 0, 0) < 0) {
634 reply = wpas_dbus_error_unknown_error(
636 "Failed to reinvoke a persistent group");
641 * No group ID means propose to a peer to join my active group
643 if (wpas_p2p_invite_group(wpa_s, wpa_s->ifname,
645 reply = wpas_dbus_error_unknown_error(
646 message, "Failed to join to an active group");
652 os_free(pg_object_path);
653 os_free(peer_object_path);
657 reply = wpas_dbus_error_invalid_args(message, NULL);
662 DBusMessage * wpas_dbus_handler_p2p_prov_disc_req(DBusMessage *message,
663 struct wpa_supplicant *wpa_s)
665 DBusMessageIter iter;
666 char *peer_object_path = NULL;
667 char *config_method = NULL;
668 u8 peer_addr[ETH_ALEN];
670 dbus_message_iter_init(message, &iter);
671 dbus_message_iter_get_basic(&iter, &peer_object_path);
673 if (parse_peer_object_path(peer_object_path, peer_addr) < 0)
674 return wpas_dbus_error_invalid_args(message, NULL);
676 dbus_message_iter_next(&iter);
677 dbus_message_iter_get_basic(&iter, &config_method);
680 * Validation checks on config_method are being duplicated here
681 * to be able to return invalid args reply since the error code
682 * from p2p module are not granular enough (yet).
684 if (os_strcmp(config_method, "display") &&
685 os_strcmp(config_method, "keypad") &&
686 os_strcmp(config_method, "pbc") &&
687 os_strcmp(config_method, "pushbutton"))
688 return wpas_dbus_error_invalid_args(message, NULL);
690 if (wpas_p2p_prov_disc(wpa_s, peer_addr, config_method,
691 WPAS_P2P_PD_FOR_GO_NEG) < 0)
692 return wpas_dbus_error_unknown_error(message,
693 "Failed to send provision discovery request");
700 * P2P Device property accessor methods.
703 dbus_bool_t wpas_dbus_getter_p2p_device_config(DBusMessageIter *iter,
707 struct wpa_supplicant *wpa_s = user_data;
708 DBusMessageIter variant_iter, dict_iter;
709 DBusMessageIter iter_secdev_dict_entry, iter_secdev_dict_val,
710 iter_secdev_dict_array;
711 const char *dev_name;
712 int num_vendor_extensions = 0;
714 const struct wpabuf *vendor_ext[P2P_MAX_WPS_VENDOR_EXT];
716 if (!wpa_dbus_p2p_check_enabled(wpa_s, NULL, NULL, error))
719 if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
720 "a{sv}", &variant_iter) ||
721 !wpa_dbus_dict_open_write(&variant_iter, &dict_iter))
725 dev_name = wpa_s->conf->device_name;
727 !wpa_dbus_dict_append_string(&dict_iter, "DeviceName", dev_name))
730 /* Primary device type */
731 if (!wpa_dbus_dict_append_byte_array(&dict_iter, "PrimaryDeviceType",
732 (char *)wpa_s->conf->device_type,
736 /* Secondary device types */
737 if (wpa_s->conf->num_sec_device_types) {
738 if (!wpa_dbus_dict_begin_array(&dict_iter,
739 "SecondaryDeviceTypes",
740 DBUS_TYPE_ARRAY_AS_STRING
741 DBUS_TYPE_BYTE_AS_STRING,
742 &iter_secdev_dict_entry,
743 &iter_secdev_dict_val,
744 &iter_secdev_dict_array))
747 for (i = 0; i < wpa_s->conf->num_sec_device_types; i++)
748 wpa_dbus_dict_bin_array_add_element(
749 &iter_secdev_dict_array,
750 wpa_s->conf->sec_device_type[i],
753 if (!wpa_dbus_dict_end_array(&dict_iter,
754 &iter_secdev_dict_entry,
755 &iter_secdev_dict_val,
756 &iter_secdev_dict_array))
760 /* Vendor Extensions */
761 for (i = 0; i < P2P_MAX_WPS_VENDOR_EXT; i++) {
762 if (wpa_s->conf->wps_vendor_ext[i] == NULL)
764 vendor_ext[num_vendor_extensions++] =
765 wpa_s->conf->wps_vendor_ext[i];
768 if (num_vendor_extensions &&
769 !wpa_dbus_dict_append_wpabuf_array(&dict_iter,
772 num_vendor_extensions))
776 if (!wpa_dbus_dict_append_uint32(&dict_iter, "GOIntent",
777 wpa_s->conf->p2p_go_intent))
780 /* Persistent Reconnect */
781 if (!wpa_dbus_dict_append_bool(&dict_iter, "PersistentReconnect",
782 wpa_s->conf->persistent_reconnect))
785 /* Listen Reg Class */
786 if (!wpa_dbus_dict_append_uint32(&dict_iter, "ListenRegClass",
787 wpa_s->conf->p2p_listen_reg_class))
791 if (!wpa_dbus_dict_append_uint32(&dict_iter, "ListenChannel",
792 wpa_s->conf->p2p_listen_channel))
796 if (!wpa_dbus_dict_append_uint32(&dict_iter, "OperRegClass",
797 wpa_s->conf->p2p_oper_reg_class))
801 if (!wpa_dbus_dict_append_uint32(&dict_iter, "OperChannel",
802 wpa_s->conf->p2p_oper_channel))
806 if (wpa_s->conf->p2p_ssid_postfix &&
807 !wpa_dbus_dict_append_string(&dict_iter, "SsidPostfix",
808 wpa_s->conf->p2p_ssid_postfix))
812 if (!wpa_dbus_dict_append_bool(&dict_iter, "IntraBss",
813 wpa_s->conf->p2p_intra_bss))
817 if (!wpa_dbus_dict_append_uint32(&dict_iter, "GroupIdle",
818 wpa_s->conf->p2p_group_idle))
821 /* Dissasociation low ack */
822 if (!wpa_dbus_dict_append_uint32(&dict_iter, "disassoc_low_ack",
823 wpa_s->conf->disassoc_low_ack))
826 if (!wpa_dbus_dict_close_write(&variant_iter, &dict_iter) ||
827 !dbus_message_iter_close_container(iter, &variant_iter))
833 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
838 dbus_bool_t wpas_dbus_setter_p2p_device_config(DBusMessageIter *iter,
842 struct wpa_supplicant *wpa_s = user_data;
843 DBusMessageIter variant_iter, iter_dict;
844 struct wpa_dbus_dict_entry entry = {.type = DBUS_TYPE_STRING };
847 if (!wpa_dbus_p2p_check_enabled(wpa_s, NULL, NULL, error))
850 dbus_message_iter_recurse(iter, &variant_iter);
851 if (!wpa_dbus_dict_open_read(&variant_iter, &iter_dict, error))
854 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
855 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry)) {
856 dbus_set_error_const(error, DBUS_ERROR_INVALID_ARGS,
857 "invalid message format");
861 if (os_strcmp(entry.key, "DeviceName") == 0) {
864 if (entry.type != DBUS_TYPE_STRING)
867 devname = os_strdup(entry.str_value);
869 goto err_no_mem_clear;
871 os_free(wpa_s->conf->device_name);
872 wpa_s->conf->device_name = devname;
874 wpa_s->conf->changed_parameters |=
875 CFG_CHANGED_DEVICE_NAME;
876 } else if (os_strcmp(entry.key, "PrimaryDeviceType") == 0) {
877 if (entry.type != DBUS_TYPE_ARRAY ||
878 entry.array_type != DBUS_TYPE_BYTE ||
879 entry.array_len != WPS_DEV_TYPE_LEN)
882 os_memcpy(wpa_s->conf->device_type,
883 entry.bytearray_value,
885 wpa_s->conf->changed_parameters |=
886 CFG_CHANGED_DEVICE_TYPE;
887 } else if (os_strcmp(entry.key, "SecondaryDeviceTypes") == 0) {
888 if (entry.type != DBUS_TYPE_ARRAY ||
889 entry.array_type != WPAS_DBUS_TYPE_BINARRAY ||
890 entry.array_len > MAX_SEC_DEVICE_TYPES)
893 for (i = 0; i < entry.array_len; i++)
894 if (wpabuf_len(entry.binarray_value[i]) !=
896 goto err_no_mem_clear;
897 for (i = 0; i < entry.array_len; i++)
898 os_memcpy(wpa_s->conf->sec_device_type[i],
899 wpabuf_head(entry.binarray_value[i]),
901 wpa_s->conf->num_sec_device_types = entry.array_len;
902 wpa_s->conf->changed_parameters |=
903 CFG_CHANGED_SEC_DEVICE_TYPE;
904 } else if (os_strcmp(entry.key, "VendorExtension") == 0) {
905 if ((entry.type != DBUS_TYPE_ARRAY) ||
906 (entry.array_type != WPAS_DBUS_TYPE_BINARRAY) ||
907 (entry.array_len > P2P_MAX_WPS_VENDOR_EXT))
910 wpa_s->conf->changed_parameters |=
911 CFG_CHANGED_VENDOR_EXTENSION;
913 for (i = 0; i < P2P_MAX_WPS_VENDOR_EXT; i++) {
914 wpabuf_free(wpa_s->conf->wps_vendor_ext[i]);
915 if (i < entry.array_len) {
916 wpa_s->conf->wps_vendor_ext[i] =
917 entry.binarray_value[i];
918 entry.binarray_value[i] = NULL;
920 wpa_s->conf->wps_vendor_ext[i] = NULL;
922 } else if ((os_strcmp(entry.key, "GOIntent") == 0) &&
923 (entry.type == DBUS_TYPE_UINT32) &&
924 (entry.uint32_value <= 15))
925 wpa_s->conf->p2p_go_intent = entry.uint32_value;
926 else if ((os_strcmp(entry.key, "PersistentReconnect") == 0) &&
927 (entry.type == DBUS_TYPE_BOOLEAN))
928 wpa_s->conf->persistent_reconnect = entry.bool_value;
929 else if ((os_strcmp(entry.key, "ListenRegClass") == 0) &&
930 (entry.type == DBUS_TYPE_UINT32)) {
931 wpa_s->conf->p2p_listen_reg_class = entry.uint32_value;
932 wpa_s->conf->changed_parameters |=
933 CFG_CHANGED_P2P_LISTEN_CHANNEL;
934 } else if ((os_strcmp(entry.key, "ListenChannel") == 0) &&
935 (entry.type == DBUS_TYPE_UINT32)) {
936 wpa_s->conf->p2p_listen_channel = entry.uint32_value;
937 wpa_s->conf->changed_parameters |=
938 CFG_CHANGED_P2P_LISTEN_CHANNEL;
939 } else if ((os_strcmp(entry.key, "OperRegClass") == 0) &&
940 (entry.type == DBUS_TYPE_UINT32)) {
941 wpa_s->conf->p2p_oper_reg_class = entry.uint32_value;
942 wpa_s->conf->changed_parameters |=
943 CFG_CHANGED_P2P_OPER_CHANNEL;
944 } else if ((os_strcmp(entry.key, "OperChannel") == 0) &&
945 (entry.type == DBUS_TYPE_UINT32)) {
946 wpa_s->conf->p2p_oper_channel = entry.uint32_value;
947 wpa_s->conf->changed_parameters |=
948 CFG_CHANGED_P2P_OPER_CHANNEL;
949 } else if (os_strcmp(entry.key, "SsidPostfix") == 0) {
952 if (entry.type != DBUS_TYPE_STRING)
955 postfix = os_strdup(entry.str_value);
957 goto err_no_mem_clear;
959 os_free(wpa_s->conf->p2p_ssid_postfix);
960 wpa_s->conf->p2p_ssid_postfix = postfix;
962 wpa_s->conf->changed_parameters |=
963 CFG_CHANGED_P2P_SSID_POSTFIX;
964 } else if ((os_strcmp(entry.key, "IntraBss") == 0) &&
965 (entry.type == DBUS_TYPE_BOOLEAN)) {
966 wpa_s->conf->p2p_intra_bss = entry.bool_value;
967 wpa_s->conf->changed_parameters |=
968 CFG_CHANGED_P2P_INTRA_BSS;
969 } else if ((os_strcmp(entry.key, "GroupIdle") == 0) &&
970 (entry.type == DBUS_TYPE_UINT32))
971 wpa_s->conf->p2p_group_idle = entry.uint32_value;
972 else if (os_strcmp(entry.key, "disassoc_low_ack") == 0 &&
973 entry.type == DBUS_TYPE_UINT32)
974 wpa_s->conf->disassoc_low_ack = entry.uint32_value;
978 wpa_dbus_dict_entry_clear(&entry);
981 if (wpa_s->conf->changed_parameters) {
982 /* Some changed parameters requires to update config*/
983 wpa_supplicant_update_config(wpa_s);
989 dbus_set_error_const(error, DBUS_ERROR_INVALID_ARGS,
990 "invalid message format");
991 wpa_dbus_dict_entry_clear(&entry);
995 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
996 wpa_dbus_dict_entry_clear(&entry);
1001 dbus_bool_t wpas_dbus_getter_p2p_peers(DBusMessageIter *iter, DBusError *error,
1004 struct wpa_supplicant *wpa_s = user_data;
1005 struct p2p_data *p2p = wpa_s->global->p2p;
1006 int next = 0, i = 0;
1007 int num = 0, out_of_mem = 0;
1009 const struct p2p_peer_info *peer_info = NULL;
1010 dbus_bool_t success = FALSE;
1012 struct dl_list peer_objpath_list;
1013 struct peer_objpath_node {
1014 struct dl_list list;
1015 char path[WPAS_DBUS_OBJECT_PATH_MAX];
1018 char **peer_obj_paths = NULL;
1020 if (!wpa_dbus_p2p_check_enabled(wpa_s, NULL, NULL, error))
1023 dl_list_init(&peer_objpath_list);
1025 /* Get the first peer info */
1026 peer_info = p2p_get_peer_found(p2p, NULL, next);
1028 /* Get next and accumulate them */
1030 while (peer_info != NULL) {
1031 node = os_zalloc(sizeof(struct peer_objpath_node));
1037 addr = peer_info->p2p_device_addr;
1038 os_snprintf(node->path, WPAS_DBUS_OBJECT_PATH_MAX,
1039 "%s/" WPAS_DBUS_NEW_P2P_PEERS_PART
1041 wpa_s->dbus_new_path, MAC2STR(addr));
1042 dl_list_add_tail(&peer_objpath_list, &node->list);
1045 peer_info = p2p_get_peer_found(p2p, addr, next);
1049 * Now construct the peer object paths in a form suitable for
1050 * array_property_getter helper below.
1052 peer_obj_paths = os_calloc(num, sizeof(char *));
1054 if (!peer_obj_paths) {
1059 dl_list_for_each_safe(node, tmp, &peer_objpath_list,
1060 struct peer_objpath_node, list)
1061 peer_obj_paths[i++] = node->path;
1063 success = wpas_dbus_simple_array_property_getter(iter,
1064 DBUS_TYPE_OBJECT_PATH,
1065 peer_obj_paths, num,
1070 os_free(peer_obj_paths);
1072 dl_list_for_each_safe(node, tmp, &peer_objpath_list,
1073 struct peer_objpath_node, list) {
1074 dl_list_del(&node->list);
1078 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
1084 enum wpas_p2p_role {
1085 WPAS_P2P_ROLE_DEVICE,
1087 WPAS_P2P_ROLE_CLIENT,
1090 static enum wpas_p2p_role wpas_get_p2p_role(struct wpa_supplicant *wpa_s)
1092 struct wpa_ssid *ssid = wpa_s->current_ssid;
1095 return WPAS_P2P_ROLE_DEVICE;
1096 if (wpa_s->wpa_state != WPA_COMPLETED)
1097 return WPAS_P2P_ROLE_DEVICE;
1099 switch (ssid->mode) {
1100 case WPAS_MODE_P2P_GO:
1101 case WPAS_MODE_P2P_GROUP_FORMATION:
1102 return WPAS_P2P_ROLE_GO;
1103 case WPAS_MODE_INFRA:
1104 if (ssid->p2p_group)
1105 return WPAS_P2P_ROLE_CLIENT;
1106 return WPAS_P2P_ROLE_DEVICE;
1108 return WPAS_P2P_ROLE_DEVICE;
1113 dbus_bool_t wpas_dbus_getter_p2p_role(DBusMessageIter *iter, DBusError *error,
1116 struct wpa_supplicant *wpa_s = user_data;
1119 switch (wpas_get_p2p_role(wpa_s)) {
1120 case WPAS_P2P_ROLE_GO:
1123 case WPAS_P2P_ROLE_CLIENT:
1130 return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING, &str,
1135 dbus_bool_t wpas_dbus_getter_p2p_group(DBusMessageIter *iter, DBusError *error,
1138 struct wpa_supplicant *wpa_s = user_data;
1139 char path_buf[WPAS_DBUS_OBJECT_PATH_MAX];
1140 char *dbus_groupobj_path = path_buf;
1142 if (wpa_s->dbus_groupobj_path == NULL)
1143 os_snprintf(dbus_groupobj_path, WPAS_DBUS_OBJECT_PATH_MAX,
1146 os_snprintf(dbus_groupobj_path, WPAS_DBUS_OBJECT_PATH_MAX,
1147 "%s", wpa_s->dbus_groupobj_path);
1149 return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_OBJECT_PATH,
1150 &dbus_groupobj_path, error);
1154 dbus_bool_t wpas_dbus_getter_p2p_peergo(DBusMessageIter *iter,
1155 DBusError *error, void *user_data)
1157 struct wpa_supplicant *wpa_s = user_data;
1158 char go_peer_obj_path[WPAS_DBUS_OBJECT_PATH_MAX], *path;
1160 if (wpas_get_p2p_role(wpa_s) != WPAS_P2P_ROLE_CLIENT)
1161 os_snprintf(go_peer_obj_path, WPAS_DBUS_OBJECT_PATH_MAX, "/");
1163 os_snprintf(go_peer_obj_path, WPAS_DBUS_OBJECT_PATH_MAX,
1164 "%s/" WPAS_DBUS_NEW_P2P_PEERS_PART "/"
1166 wpa_s->dbus_new_path, MAC2STR(wpa_s->go_dev_addr));
1168 path = go_peer_obj_path;
1169 return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_OBJECT_PATH,
1175 * Peer object properties accessor methods
1178 dbus_bool_t wpas_dbus_getter_p2p_peer_device_name(DBusMessageIter *iter,
1182 struct peer_handler_args *peer_args = user_data;
1183 const struct p2p_peer_info *info;
1186 if (!wpa_dbus_p2p_check_enabled(peer_args->wpa_s, NULL, NULL, error))
1189 /* get the peer info */
1190 info = p2p_get_peer_found(peer_args->wpa_s->global->p2p,
1191 peer_args->p2p_device_addr, 0);
1193 dbus_set_error(error, DBUS_ERROR_FAILED,
1194 "failed to find peer");
1198 tmp = os_strdup(info->device_name);
1200 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
1204 if (!wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING, &tmp,
1206 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
1216 dbus_bool_t wpas_dbus_getter_p2p_peer_primary_device_type(
1217 DBusMessageIter *iter, DBusError *error, void *user_data)
1219 struct peer_handler_args *peer_args = user_data;
1220 const struct p2p_peer_info *info;
1222 info = p2p_get_peer_found(peer_args->wpa_s->global->p2p,
1223 peer_args->p2p_device_addr, 0);
1225 dbus_set_error(error, DBUS_ERROR_FAILED,
1226 "failed to find peer");
1230 if (!wpas_dbus_simple_array_property_getter(iter, DBUS_TYPE_BYTE,
1233 WPS_DEV_TYPE_LEN, error)) {
1234 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
1242 dbus_bool_t wpas_dbus_getter_p2p_peer_config_method(DBusMessageIter *iter,
1246 struct peer_handler_args *peer_args = user_data;
1247 const struct p2p_peer_info *info;
1249 info = p2p_get_peer_found(peer_args->wpa_s->global->p2p,
1250 peer_args->p2p_device_addr, 0);
1252 dbus_set_error(error, DBUS_ERROR_FAILED,
1253 "failed to find peer");
1257 if (!wpas_dbus_simple_property_getter(iter, DBUS_TYPE_UINT16,
1258 &info->config_methods, error)) {
1259 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
1267 dbus_bool_t wpas_dbus_getter_p2p_peer_level(DBusMessageIter *iter,
1271 struct peer_handler_args *peer_args = user_data;
1272 const struct p2p_peer_info *info;
1274 info = p2p_get_peer_found(peer_args->wpa_s->global->p2p,
1275 peer_args->p2p_device_addr, 0);
1277 dbus_set_error(error, DBUS_ERROR_FAILED,
1278 "failed to find peer");
1282 if (!wpas_dbus_simple_property_getter(iter, DBUS_TYPE_INT32,
1283 &info->level, error)) {
1284 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
1292 dbus_bool_t wpas_dbus_getter_p2p_peer_device_capability(DBusMessageIter *iter,
1296 struct peer_handler_args *peer_args = user_data;
1297 const struct p2p_peer_info *info;
1299 info = p2p_get_peer_found(peer_args->wpa_s->global->p2p,
1300 peer_args->p2p_device_addr, 0);
1302 dbus_set_error(error, DBUS_ERROR_FAILED,
1303 "failed to find peer");
1307 if (!wpas_dbus_simple_property_getter(iter, DBUS_TYPE_BYTE,
1308 &info->dev_capab, error)) {
1309 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
1317 dbus_bool_t wpas_dbus_getter_p2p_peer_group_capability(DBusMessageIter *iter,
1321 struct peer_handler_args *peer_args = user_data;
1322 const struct p2p_peer_info *info;
1324 info = p2p_get_peer_found(peer_args->wpa_s->global->p2p,
1325 peer_args->p2p_device_addr, 0);
1327 dbus_set_error(error, DBUS_ERROR_FAILED,
1328 "failed to find peer");
1332 if (!wpas_dbus_simple_property_getter(iter, DBUS_TYPE_BYTE,
1333 &info->group_capab, error)) {
1334 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
1342 dbus_bool_t wpas_dbus_getter_p2p_peer_secondary_device_types(
1343 DBusMessageIter *iter, DBusError *error, void *user_data)
1345 struct peer_handler_args *peer_args = user_data;
1346 const struct p2p_peer_info *info;
1347 DBusMessageIter variant_iter, array_iter;
1349 info = p2p_get_peer_found(peer_args->wpa_s->global->p2p,
1350 peer_args->p2p_device_addr, 0);
1352 dbus_set_error(error, DBUS_ERROR_FAILED,
1353 "failed to find peer");
1357 if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
1358 DBUS_TYPE_ARRAY_AS_STRING
1359 DBUS_TYPE_ARRAY_AS_STRING
1360 DBUS_TYPE_BYTE_AS_STRING,
1362 dbus_set_error(error, DBUS_ERROR_FAILED,
1363 "%s: failed to construct message 1", __func__);
1367 if (!dbus_message_iter_open_container(&variant_iter, DBUS_TYPE_ARRAY,
1368 DBUS_TYPE_ARRAY_AS_STRING
1369 DBUS_TYPE_BYTE_AS_STRING,
1371 dbus_set_error(error, DBUS_ERROR_FAILED,
1372 "%s: failed to construct message 2", __func__);
1376 if (info->wps_sec_dev_type_list_len) {
1377 const u8 *sec_dev_type_list = info->wps_sec_dev_type_list;
1378 int num_sec_device_types =
1379 info->wps_sec_dev_type_list_len / WPS_DEV_TYPE_LEN;
1381 DBusMessageIter inner_array_iter;
1383 for (i = 0; i < num_sec_device_types; i++) {
1384 if (!dbus_message_iter_open_container(
1385 &array_iter, DBUS_TYPE_ARRAY,
1386 DBUS_TYPE_BYTE_AS_STRING,
1387 &inner_array_iter)) {
1388 dbus_set_error(error, DBUS_ERROR_FAILED,
1389 "%s: failed to construct "
1395 if (!dbus_message_iter_append_fixed_array(
1396 &inner_array_iter, DBUS_TYPE_BYTE,
1397 &sec_dev_type_list, WPS_DEV_TYPE_LEN)) {
1398 dbus_set_error(error, DBUS_ERROR_FAILED,
1399 "%s: failed to construct "
1405 if (!dbus_message_iter_close_container(
1406 &array_iter, &inner_array_iter)) {
1407 dbus_set_error(error, DBUS_ERROR_FAILED,
1408 "%s: failed to construct "
1414 sec_dev_type_list += WPS_DEV_TYPE_LEN;
1418 if (!dbus_message_iter_close_container(&variant_iter, &array_iter)) {
1419 dbus_set_error(error, DBUS_ERROR_FAILED,
1420 "%s: failed to construct message 6", __func__);
1424 if (!dbus_message_iter_close_container(iter, &variant_iter)) {
1425 dbus_set_error(error, DBUS_ERROR_FAILED,
1426 "%s: failed to construct message 7", __func__);
1434 dbus_bool_t wpas_dbus_getter_p2p_peer_vendor_extension(DBusMessageIter *iter,
1438 struct wpabuf *vendor_extension[P2P_MAX_WPS_VENDOR_EXT];
1440 struct peer_handler_args *peer_args = user_data;
1441 const struct p2p_peer_info *info;
1443 info = p2p_get_peer_found(peer_args->wpa_s->global->p2p,
1444 peer_args->p2p_device_addr, 0);
1446 dbus_set_error(error, DBUS_ERROR_FAILED,
1447 "failed to find peer");
1451 /* Add WPS vendor extensions attribute */
1452 for (i = 0, num = 0; i < P2P_MAX_WPS_VENDOR_EXT; i++) {
1453 if (info->wps_vendor_ext[i] == NULL)
1455 vendor_extension[num] = info->wps_vendor_ext[i];
1459 if (!wpas_dbus_simple_array_array_property_getter(iter, DBUS_TYPE_BYTE,
1468 dbus_bool_t wpas_dbus_getter_p2p_peer_ies(DBusMessageIter *iter,
1469 DBusError *error, void *user_data)
1471 dbus_bool_t success;
1472 /* struct peer_handler_args *peer_args = user_data; */
1474 success = wpas_dbus_simple_array_property_getter(iter, DBUS_TYPE_BYTE,
1481 * wpas_dbus_getter_persistent_groups - Get array of persistent group objects
1482 * @iter: Pointer to incoming dbus message iter
1483 * @error: Location to store error on failure
1484 * @user_data: Function specific data
1485 * Returns: TRUE on success, FALSE on failure
1487 * Getter for "PersistentGroups" property.
1489 dbus_bool_t wpas_dbus_getter_persistent_groups(DBusMessageIter *iter,
1493 struct wpa_supplicant *wpa_s = user_data;
1494 struct wpa_ssid *ssid;
1496 unsigned int i = 0, num = 0;
1497 dbus_bool_t success = FALSE;
1499 if (wpa_s->conf == NULL) {
1500 wpa_printf(MSG_ERROR, "dbus: %s: "
1501 "An error occurred getting persistent groups list",
1503 dbus_set_error_const(error, DBUS_ERROR_FAILED, "an error "
1504 "occurred getting persistent groups list");
1508 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
1509 if (network_is_persistent_group(ssid))
1512 paths = os_calloc(num, sizeof(char *));
1514 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
1518 /* Loop through configured networks and append object path of each */
1519 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) {
1520 if (!network_is_persistent_group(ssid))
1522 paths[i] = os_zalloc(WPAS_DBUS_OBJECT_PATH_MAX);
1523 if (paths[i] == NULL) {
1524 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY,
1528 /* Construct the object path for this network. */
1529 os_snprintf(paths[i++], WPAS_DBUS_OBJECT_PATH_MAX,
1530 "%s/" WPAS_DBUS_NEW_PERSISTENT_GROUPS_PART "/%d",
1531 wpa_s->dbus_new_path, ssid->id);
1534 success = wpas_dbus_simple_array_property_getter(iter,
1535 DBUS_TYPE_OBJECT_PATH,
1540 os_free(paths[--i]);
1547 * wpas_dbus_getter_persistent_group_properties - Get options for a persistent
1549 * @iter: Pointer to incoming dbus message iter
1550 * @error: Location to store error on failure
1551 * @user_data: Function specific data
1552 * Returns: TRUE on success, FALSE on failure
1554 * Getter for "Properties" property of a persistent group.
1556 dbus_bool_t wpas_dbus_getter_persistent_group_properties(DBusMessageIter *iter,
1560 struct network_handler_args *net = user_data;
1562 /* Leveraging the fact that persistent group object is still
1563 * represented in same manner as network within.
1565 return wpas_dbus_getter_network_properties(iter, error, net);
1570 * wpas_dbus_setter_persistent_group_properties - Get options for a persistent
1572 * @iter: Pointer to incoming dbus message iter
1573 * @error: Location to store error on failure
1574 * @user_data: Function specific data
1575 * Returns: TRUE on success, FALSE on failure
1577 * Setter for "Properties" property of a persistent group.
1579 dbus_bool_t wpas_dbus_setter_persistent_group_properties(DBusMessageIter *iter,
1583 struct network_handler_args *net = user_data;
1584 struct wpa_ssid *ssid = net->ssid;
1585 DBusMessageIter variant_iter;
1588 * Leveraging the fact that persistent group object is still
1589 * represented in same manner as network within.
1591 dbus_message_iter_recurse(iter, &variant_iter);
1592 return set_network_properties(net->wpa_s, ssid, &variant_iter, error);
1597 * wpas_dbus_new_iface_add_persistent_group - Add a new configured
1599 * @message: Pointer to incoming dbus message
1600 * @wpa_s: wpa_supplicant structure for a network interface
1601 * Returns: A dbus message containing the object path of the new
1604 * Handler function for "AddPersistentGroup" method call of a P2P Device
1607 DBusMessage * wpas_dbus_handler_add_persistent_group(
1608 DBusMessage *message, struct wpa_supplicant *wpa_s)
1610 DBusMessage *reply = NULL;
1611 DBusMessageIter iter;
1612 struct wpa_ssid *ssid = NULL;
1613 char path_buf[WPAS_DBUS_OBJECT_PATH_MAX], *path = path_buf;
1616 dbus_message_iter_init(message, &iter);
1618 ssid = wpa_config_add_network(wpa_s->conf);
1620 wpa_printf(MSG_ERROR, "dbus: %s: "
1621 "Cannot add new persistent group", __func__);
1622 reply = wpas_dbus_error_unknown_error(
1624 "wpa_supplicant could not add "
1625 "a persistent group on this interface.");
1629 /* Mark the ssid as being a persistent group before the notification */
1631 ssid->p2p_persistent_group = 1;
1632 wpas_notify_persistent_group_added(wpa_s, ssid);
1634 wpa_config_set_network_defaults(ssid);
1636 dbus_error_init(&error);
1637 if (!set_network_properties(wpa_s, ssid, &iter, &error)) {
1638 wpa_printf(MSG_DEBUG, "dbus: %s: "
1639 "Control interface could not set persistent group "
1640 "properties", __func__);
1641 reply = wpas_dbus_reply_new_from_error(message, &error,
1642 DBUS_ERROR_INVALID_ARGS,
1643 "Failed to set network "
1645 dbus_error_free(&error);
1649 /* Construct the object path for this network. */
1650 os_snprintf(path, WPAS_DBUS_OBJECT_PATH_MAX,
1651 "%s/" WPAS_DBUS_NEW_PERSISTENT_GROUPS_PART "/%d",
1652 wpa_s->dbus_new_path, ssid->id);
1654 reply = dbus_message_new_method_return(message);
1655 if (reply == NULL) {
1656 reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
1660 if (!dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH, &path,
1661 DBUS_TYPE_INVALID)) {
1662 dbus_message_unref(reply);
1663 reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
1672 wpas_notify_persistent_group_removed(wpa_s, ssid);
1673 wpa_config_remove_network(wpa_s->conf, ssid->id);
1680 * wpas_dbus_handler_remove_persistent_group - Remove a configured persistent
1682 * @message: Pointer to incoming dbus message
1683 * @wpa_s: wpa_supplicant structure for a network interface
1684 * Returns: NULL on success or dbus error on failure
1686 * Handler function for "RemovePersistentGroup" method call of a P2P Device
1689 DBusMessage * wpas_dbus_handler_remove_persistent_group(
1690 DBusMessage *message, struct wpa_supplicant *wpa_s)
1692 DBusMessage *reply = NULL;
1694 char *iface = NULL, *persistent_group_id = NULL;
1696 struct wpa_ssid *ssid;
1698 dbus_message_get_args(message, NULL, DBUS_TYPE_OBJECT_PATH, &op,
1702 * Extract the network ID and ensure the network is actually a child of
1705 iface = wpas_dbus_new_decompose_object_path(op, 1,
1706 &persistent_group_id,
1708 if (iface == NULL || os_strcmp(iface, wpa_s->dbus_new_path) != 0) {
1709 reply = wpas_dbus_error_invalid_args(message, op);
1713 id = strtoul(persistent_group_id, NULL, 10);
1714 if (errno == EINVAL) {
1715 reply = wpas_dbus_error_invalid_args(message, op);
1719 ssid = wpa_config_get_network(wpa_s->conf, id);
1721 reply = wpas_dbus_error_persistent_group_unknown(message);
1725 wpas_notify_persistent_group_removed(wpa_s, ssid);
1727 if (wpa_config_remove_network(wpa_s->conf, id) < 0) {
1728 wpa_printf(MSG_ERROR, "dbus: %s: "
1729 "error occurred when removing persistent group %d",
1731 reply = wpas_dbus_error_unknown_error(
1733 "error removing the specified persistent group on "
1740 os_free(persistent_group_id);
1745 static void remove_persistent_group(struct wpa_supplicant *wpa_s,
1746 struct wpa_ssid *ssid)
1748 wpas_notify_persistent_group_removed(wpa_s, ssid);
1750 if (wpa_config_remove_network(wpa_s->conf, ssid->id) < 0) {
1751 wpa_printf(MSG_ERROR, "dbus: %s: "
1752 "error occurred when removing persistent group %d",
1753 __func__, ssid->id);
1760 * wpas_dbus_handler_remove_all_persistent_groups - Remove all configured
1762 * @message: Pointer to incoming dbus message
1763 * @wpa_s: wpa_supplicant structure for a network interface
1764 * Returns: NULL on success or dbus error on failure
1766 * Handler function for "RemoveAllPersistentGroups" method call of a
1767 * P2P Device interface.
1769 DBusMessage * wpas_dbus_handler_remove_all_persistent_groups(
1770 DBusMessage *message, struct wpa_supplicant *wpa_s)
1772 struct wpa_ssid *ssid, *next;
1773 struct wpa_config *config;
1775 config = wpa_s->conf;
1776 ssid = config->ssid;
1779 if (network_is_persistent_group(ssid))
1780 remove_persistent_group(wpa_s, ssid);
1788 * Group object properties accessor methods
1791 dbus_bool_t wpas_dbus_getter_p2p_group_members(DBusMessageIter *iter,
1795 struct wpa_supplicant *wpa_s = user_data;
1796 struct wpa_ssid *ssid;
1797 unsigned int num_members;
1802 dbus_bool_t success = FALSE;
1804 /* Verify correct role for this property */
1805 if (wpas_get_p2p_role(wpa_s) != WPAS_P2P_ROLE_GO) {
1806 return wpas_dbus_simple_array_property_getter(
1807 iter, DBUS_TYPE_OBJECT_PATH, NULL, 0, error);
1810 ssid = wpa_s->conf->ssid;
1811 /* At present WPAS P2P_GO mode only applicable for p2p_go */
1812 if (ssid->mode != WPAS_MODE_P2P_GO &&
1813 ssid->mode != WPAS_MODE_AP &&
1814 ssid->mode != WPAS_MODE_P2P_GROUP_FORMATION)
1817 num_members = p2p_get_group_num_members(wpa_s->p2p_group);
1819 paths = os_calloc(num_members, sizeof(char *));
1824 while ((addr = p2p_iterate_group_members(wpa_s->p2p_group, &next))) {
1825 paths[i] = os_zalloc(WPAS_DBUS_OBJECT_PATH_MAX);
1828 os_snprintf(paths[i], WPAS_DBUS_OBJECT_PATH_MAX,
1829 "%s/" WPAS_DBUS_NEW_P2P_GROUPMEMBERS_PART
1831 wpa_s->dbus_groupobj_path, MAC2STR(addr));
1835 success = wpas_dbus_simple_array_property_getter(iter,
1836 DBUS_TYPE_OBJECT_PATH,
1840 for (i = 0; i < num_members; i++)
1846 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
1848 for (i = 0; i < num_members; i++)
1856 dbus_bool_t wpas_dbus_getter_p2p_group_ssid(DBusMessageIter *iter,
1857 DBusError *error, void *user_data)
1859 struct wpa_supplicant *wpa_s = user_data;
1860 if (wpa_s->current_ssid == NULL)
1862 return wpas_dbus_simple_array_property_getter(
1863 iter, DBUS_TYPE_BYTE, wpa_s->current_ssid->ssid,
1864 wpa_s->current_ssid->ssid_len, error);
1868 dbus_bool_t wpas_dbus_getter_p2p_group_bssid(DBusMessageIter *iter,
1872 struct wpa_supplicant *wpa_s = user_data;
1873 u8 role = wpas_get_p2p_role(wpa_s);
1876 if (role == WPAS_P2P_ROLE_CLIENT) {
1877 if (wpa_s->current_ssid == NULL)
1879 p_bssid = wpa_s->current_ssid->bssid;
1881 if (wpa_s->ap_iface == NULL)
1883 p_bssid = wpa_s->ap_iface->bss[0]->own_addr;
1886 return wpas_dbus_simple_array_property_getter(iter, DBUS_TYPE_BYTE,
1892 dbus_bool_t wpas_dbus_getter_p2p_group_frequency(DBusMessageIter *iter,
1896 struct wpa_supplicant *wpa_s = user_data;
1898 u8 role = wpas_get_p2p_role(wpa_s);
1900 if (role == WPAS_P2P_ROLE_CLIENT) {
1901 if (wpa_s->go_params == NULL)
1903 op_freq = wpa_s->go_params->freq;
1905 if (wpa_s->ap_iface == NULL)
1907 op_freq = wpa_s->ap_iface->freq;
1910 return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_UINT16,
1915 dbus_bool_t wpas_dbus_getter_p2p_group_passphrase(DBusMessageIter *iter,
1919 struct wpa_supplicant *wpa_s = user_data;
1920 u8 role = wpas_get_p2p_role(wpa_s);
1921 char *p_pass = NULL;
1923 /* Verify correct role for this property */
1924 if (role == WPAS_P2P_ROLE_GO) {
1925 if (wpa_s->current_ssid == NULL)
1927 p_pass = wpa_s->current_ssid->passphrase;
1931 return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING,
1937 dbus_bool_t wpas_dbus_getter_p2p_group_psk(DBusMessageIter *iter,
1938 DBusError *error, void *user_data)
1940 struct wpa_supplicant *wpa_s = user_data;
1941 u8 role = wpas_get_p2p_role(wpa_s);
1945 /* Verify correct role for this property */
1946 if (role == WPAS_P2P_ROLE_CLIENT) {
1947 if (wpa_s->current_ssid == NULL)
1949 p_psk = wpa_s->current_ssid->psk;
1953 return wpas_dbus_simple_array_property_getter(iter, DBUS_TYPE_BYTE,
1954 &p_psk, psk_len, error);
1958 dbus_bool_t wpas_dbus_getter_p2p_group_vendor_ext(DBusMessageIter *iter,
1962 struct wpa_supplicant *wpa_s = user_data;
1963 struct hostapd_data *hapd;
1964 struct wpabuf *vendor_ext[MAX_WPS_VENDOR_EXTENSIONS];
1965 int num_vendor_ext = 0;
1968 /* Verify correct role for this property */
1969 if (wpas_get_p2p_role(wpa_s) == WPAS_P2P_ROLE_GO) {
1970 if (wpa_s->ap_iface == NULL)
1972 hapd = wpa_s->ap_iface->bss[0];
1974 /* Parse WPS Vendor Extensions sent in Beacon/Probe Response */
1975 for (i = 0; i < MAX_WPS_VENDOR_EXTENSIONS; i++) {
1976 if (hapd->conf->wps_vendor_ext[i] == NULL)
1977 vendor_ext[i] = NULL;
1979 vendor_ext[num_vendor_ext++] =
1980 hapd->conf->wps_vendor_ext[i];
1985 /* Return vendor extensions or no data */
1986 return wpas_dbus_simple_array_array_property_getter(iter,
1994 dbus_bool_t wpas_dbus_setter_p2p_group_vendor_ext(DBusMessageIter *iter,
1998 struct wpa_supplicant *wpa_s = user_data;
1999 DBusMessageIter variant_iter, iter_dict;
2000 struct wpa_dbus_dict_entry entry = { .type = DBUS_TYPE_STRING };
2002 struct hostapd_data *hapd = NULL;
2004 if (wpas_get_p2p_role(wpa_s) == WPAS_P2P_ROLE_GO &&
2005 wpa_s->ap_iface != NULL)
2006 hapd = wpa_s->ap_iface->bss[0];
2010 dbus_message_iter_recurse(iter, &variant_iter);
2011 if (!wpa_dbus_dict_open_read(&variant_iter, &iter_dict, error))
2014 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
2015 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry)) {
2016 dbus_set_error_const(error, DBUS_ERROR_INVALID_ARGS,
2017 "invalid message format");
2021 if (os_strcmp(entry.key, "WPSVendorExtensions") == 0) {
2022 if (entry.type != DBUS_TYPE_ARRAY ||
2023 entry.array_type != WPAS_DBUS_TYPE_BINARRAY ||
2024 entry.array_len > MAX_WPS_VENDOR_EXTENSIONS)
2027 for (i = 0; i < MAX_WPS_VENDOR_EXTENSIONS; i++) {
2028 if (i < entry.array_len) {
2029 hapd->conf->wps_vendor_ext[i] =
2030 entry.binarray_value[i];
2031 entry.binarray_value[i] = NULL;
2033 hapd->conf->wps_vendor_ext[i] = NULL;
2036 hostapd_update_wps(hapd);
2040 wpa_dbus_dict_entry_clear(&entry);
2046 wpa_dbus_dict_entry_clear(&entry);
2047 dbus_set_error_const(error, DBUS_ERROR_INVALID_ARGS,
2048 "invalid message format");
2053 DBusMessage * wpas_dbus_handler_p2p_add_service(DBusMessage *message,
2054 struct wpa_supplicant *wpa_s)
2056 DBusMessageIter iter_dict;
2057 DBusMessage *reply = NULL;
2058 DBusMessageIter iter;
2059 struct wpa_dbus_dict_entry entry;
2062 char *service = NULL;
2063 struct wpabuf *query = NULL;
2064 struct wpabuf *resp = NULL;
2067 dbus_message_iter_init(message, &iter);
2069 if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
2072 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
2073 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
2076 if (!os_strcmp(entry.key, "service_type") &&
2077 (entry.type == DBUS_TYPE_STRING)) {
2078 if (!os_strcmp(entry.str_value, "upnp"))
2080 else if (!os_strcmp(entry.str_value, "bonjour"))
2084 } else if (!os_strcmp(entry.key, "version") &&
2085 entry.type == DBUS_TYPE_INT32) {
2086 version = entry.uint32_value;
2087 } else if (!os_strcmp(entry.key, "service") &&
2088 (entry.type == DBUS_TYPE_STRING)) {
2089 service = os_strdup(entry.str_value);
2090 } else if (!os_strcmp(entry.key, "query")) {
2091 if ((entry.type != DBUS_TYPE_ARRAY) ||
2092 (entry.array_type != DBUS_TYPE_BYTE))
2094 query = wpabuf_alloc_copy(
2095 entry.bytearray_value,
2097 } else if (!os_strcmp(entry.key, "response")) {
2098 if ((entry.type != DBUS_TYPE_ARRAY) ||
2099 (entry.array_type != DBUS_TYPE_BYTE))
2101 resp = wpabuf_alloc_copy(entry.bytearray_value,
2104 wpa_dbus_dict_entry_clear(&entry);
2108 if (version <= 0 || service == NULL)
2111 if (wpas_p2p_service_add_upnp(wpa_s, version, service) != 0)
2116 } else if (bonjour == 1) {
2117 if (query == NULL || resp == NULL)
2120 if (wpas_p2p_service_add_bonjour(wpa_s, query, resp) < 0)
2129 wpa_dbus_dict_entry_clear(&entry);
2134 return wpas_dbus_error_invalid_args(message, NULL);
2138 DBusMessage * wpas_dbus_handler_p2p_delete_service(
2139 DBusMessage *message, struct wpa_supplicant *wpa_s)
2141 DBusMessageIter iter_dict;
2142 DBusMessage *reply = NULL;
2143 DBusMessageIter iter;
2144 struct wpa_dbus_dict_entry entry;
2148 char *service = NULL;
2149 struct wpabuf *query = NULL;
2152 dbus_message_iter_init(message, &iter);
2154 if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
2157 if (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
2158 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
2161 if (!os_strcmp(entry.key, "service_type") &&
2162 (entry.type == DBUS_TYPE_STRING)) {
2163 if (!os_strcmp(entry.str_value, "upnp"))
2165 else if (!os_strcmp(entry.str_value, "bonjour"))
2169 wpa_dbus_dict_entry_clear(&entry);
2173 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
2174 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
2176 if (!os_strcmp(entry.key, "version") &&
2177 entry.type == DBUS_TYPE_INT32)
2178 version = entry.uint32_value;
2179 else if (!os_strcmp(entry.key, "service") &&
2180 entry.type == DBUS_TYPE_STRING)
2181 service = os_strdup(entry.str_value);
2185 wpa_dbus_dict_entry_clear(&entry);
2188 if (version <= 0 || service == NULL)
2191 ret = wpas_p2p_service_del_upnp(wpa_s, version, service);
2195 } else if (bonjour == 1) {
2196 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
2197 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
2200 if (!os_strcmp(entry.key, "query")) {
2201 if ((entry.type != DBUS_TYPE_ARRAY) ||
2202 (entry.array_type != DBUS_TYPE_BYTE))
2204 query = wpabuf_alloc_copy(
2205 entry.bytearray_value,
2210 wpa_dbus_dict_entry_clear(&entry);
2216 ret = wpas_p2p_service_del_bonjour(wpa_s, query);
2225 wpa_dbus_dict_entry_clear(&entry);
2227 return wpas_dbus_error_invalid_args(message, NULL);
2231 DBusMessage * wpas_dbus_handler_p2p_flush_service(DBusMessage *message,
2232 struct wpa_supplicant *wpa_s)
2234 wpas_p2p_service_flush(wpa_s);
2239 DBusMessage * wpas_dbus_handler_p2p_service_sd_req(
2240 DBusMessage *message, struct wpa_supplicant *wpa_s)
2242 DBusMessageIter iter_dict;
2243 DBusMessage *reply = NULL;
2244 DBusMessageIter iter;
2245 struct wpa_dbus_dict_entry entry;
2247 char *service = NULL;
2248 char *peer_object_path = NULL;
2249 struct wpabuf *tlv = NULL;
2252 u8 addr_buf[ETH_ALEN], *addr;
2254 dbus_message_iter_init(message, &iter);
2256 if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
2259 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
2260 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
2262 if (!os_strcmp(entry.key, "peer_object") &&
2263 entry.type == DBUS_TYPE_OBJECT_PATH) {
2264 peer_object_path = os_strdup(entry.str_value);
2265 } else if (!os_strcmp(entry.key, "service_type") &&
2266 entry.type == DBUS_TYPE_STRING) {
2267 if (!os_strcmp(entry.str_value, "upnp"))
2271 } else if (!os_strcmp(entry.key, "version") &&
2272 entry.type == DBUS_TYPE_INT32) {
2273 version = entry.uint32_value;
2274 } else if (!os_strcmp(entry.key, "service") &&
2275 entry.type == DBUS_TYPE_STRING) {
2276 service = os_strdup(entry.str_value);
2277 } else if (!os_strcmp(entry.key, "tlv")) {
2278 if (entry.type != DBUS_TYPE_ARRAY ||
2279 entry.array_type != DBUS_TYPE_BYTE)
2281 tlv = wpabuf_alloc_copy(entry.bytearray_value,
2286 wpa_dbus_dict_entry_clear(&entry);
2289 if (!peer_object_path) {
2292 if (parse_peer_object_path(peer_object_path, addr_buf) < 0 ||
2293 !p2p_peer_known(wpa_s->global->p2p, addr_buf))
2300 if (version <= 0 || service == NULL)
2303 ref = wpas_p2p_sd_request_upnp(wpa_s, addr, version, service);
2307 ref = wpas_p2p_sd_request(wpa_s, addr, tlv);
2312 reply = dbus_message_new_method_return(message);
2313 dbus_message_append_args(reply, DBUS_TYPE_UINT64,
2314 &ref, DBUS_TYPE_INVALID);
2316 reply = wpas_dbus_error_unknown_error(
2317 message, "Unable to send SD request");
2321 os_free(peer_object_path);
2324 wpa_dbus_dict_entry_clear(&entry);
2328 reply = wpas_dbus_error_invalid_args(message, NULL);
2333 DBusMessage * wpas_dbus_handler_p2p_service_sd_res(
2334 DBusMessage *message, struct wpa_supplicant *wpa_s)
2336 DBusMessageIter iter_dict;
2337 DBusMessage *reply = NULL;
2338 DBusMessageIter iter;
2339 struct wpa_dbus_dict_entry entry;
2340 char *peer_object_path = NULL;
2341 struct wpabuf *tlv = NULL;
2346 dbus_message_iter_init(message, &iter);
2348 if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
2351 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
2352 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
2355 if (!os_strcmp(entry.key, "peer_object") &&
2356 entry.type == DBUS_TYPE_OBJECT_PATH) {
2357 peer_object_path = os_strdup(entry.str_value);
2358 } else if (!os_strcmp(entry.key, "frequency") &&
2359 entry.type == DBUS_TYPE_INT32) {
2360 freq = entry.uint32_value;
2361 } else if (!os_strcmp(entry.key, "dialog_token") &&
2362 entry.type == DBUS_TYPE_UINT32) {
2363 dlg_tok = entry.uint32_value;
2364 } else if (!os_strcmp(entry.key, "tlvs")) {
2365 if (entry.type != DBUS_TYPE_ARRAY ||
2366 entry.array_type != DBUS_TYPE_BYTE)
2368 tlv = wpabuf_alloc_copy(entry.bytearray_value,
2373 wpa_dbus_dict_entry_clear(&entry);
2375 if (!peer_object_path ||
2376 (parse_peer_object_path(peer_object_path, addr) < 0) ||
2377 !p2p_peer_known(wpa_s->global->p2p, addr))
2383 wpas_p2p_sd_response(wpa_s, freq, addr, (u8) dlg_tok, tlv);
2386 os_free(peer_object_path);
2389 wpa_dbus_dict_entry_clear(&entry);
2391 reply = wpas_dbus_error_invalid_args(message, NULL);
2396 DBusMessage * wpas_dbus_handler_p2p_service_sd_cancel_req(
2397 DBusMessage *message, struct wpa_supplicant *wpa_s)
2399 DBusMessageIter iter;
2402 dbus_message_iter_init(message, &iter);
2403 dbus_message_iter_get_basic(&iter, &req);
2408 if (!wpas_p2p_sd_cancel_request(wpa_s, req))
2413 return wpas_dbus_error_invalid_args(message, NULL);
2417 DBusMessage * wpas_dbus_handler_p2p_service_update(
2418 DBusMessage *message, struct wpa_supplicant *wpa_s)
2420 wpas_p2p_sd_service_update(wpa_s);
2425 DBusMessage * wpas_dbus_handler_p2p_serv_disc_external(
2426 DBusMessage *message, struct wpa_supplicant *wpa_s)
2428 DBusMessageIter iter;
2431 dbus_message_iter_init(message, &iter);
2432 dbus_message_iter_get_basic(&iter, &ext);
2434 wpa_s->p2p_sd_over_ctrl_iface = ext;