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"
29 #include "../wifi_display.h"
32 * Parses out the mac address from the peer object path.
33 * @peer_path - object path of the form
34 * /fi/w1/wpa_supplicant1/Interfaces/n/Peers/00112233445566 (no colons)
35 * @addr - out param must be of ETH_ALEN size
36 * Returns 0 if valid (including MAC), -1 otherwise
38 static int parse_peer_object_path(const char *peer_path, u8 addr[ETH_ALEN])
44 p = os_strrchr(peer_path, '/');
48 return hwaddr_compact_aton(p, addr);
53 * wpas_dbus_error_persistent_group_unknown - Return a new PersistentGroupUnknown
55 * @message: Pointer to incoming dbus message this error refers to
56 * Returns: a dbus error message
58 * Convenience function to create and return an invalid persistent group error.
60 static DBusMessage * wpas_dbus_error_persistent_group_unknown(
63 return dbus_message_new_error(message, WPAS_DBUS_ERROR_NETWORK_UNKNOWN,
64 "There is no such persistent group in "
69 DBusMessage * wpas_dbus_handler_p2p_find(DBusMessage *message,
70 struct wpa_supplicant *wpa_s)
72 struct wpa_dbus_dict_entry entry;
73 DBusMessage *reply = NULL;
75 DBusMessageIter iter_dict;
76 unsigned int timeout = 0;
77 enum p2p_discovery_type type = P2P_FIND_START_WITH_FULL;
78 int num_req_dev_types = 0;
80 u8 *req_dev_types = NULL;
82 dbus_message_iter_init(message, &iter);
85 if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
88 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
89 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
92 if (!os_strcmp(entry.key, "Timeout") &&
93 (entry.type == DBUS_TYPE_INT32)) {
94 timeout = entry.uint32_value;
95 } else if (os_strcmp(entry.key, "RequestedDeviceTypes") == 0) {
96 if ((entry.type != DBUS_TYPE_ARRAY) ||
97 (entry.array_type != WPAS_DBUS_TYPE_BINARRAY))
100 os_free(req_dev_types);
102 os_malloc(WPS_DEV_TYPE_LEN * entry.array_len);
106 for (i = 0; i < entry.array_len; i++) {
107 if (wpabuf_len(entry.binarray_value[i]) !=
110 os_memcpy(req_dev_types + i * WPS_DEV_TYPE_LEN,
111 wpabuf_head(entry.binarray_value[i]),
114 num_req_dev_types = entry.array_len;
115 } else if (!os_strcmp(entry.key, "DiscoveryType") &&
116 (entry.type == DBUS_TYPE_STRING)) {
117 if (!os_strcmp(entry.str_value, "start_with_full"))
118 type = P2P_FIND_START_WITH_FULL;
119 else if (!os_strcmp(entry.str_value, "social"))
120 type = P2P_FIND_ONLY_SOCIAL;
121 else if (!os_strcmp(entry.str_value, "progressive"))
122 type = P2P_FIND_PROGRESSIVE;
127 wpa_dbus_dict_entry_clear(&entry);
131 wpa_s = wpa_s->p2p_dev;
133 wpas_p2p_find(wpa_s, timeout, type, num_req_dev_types, req_dev_types,
135 os_free(req_dev_types);
139 wpa_dbus_dict_entry_clear(&entry);
141 os_free(req_dev_types);
142 reply = wpas_dbus_error_invalid_args(message, entry.key);
147 DBusMessage * wpas_dbus_handler_p2p_stop_find(DBusMessage *message,
148 struct wpa_supplicant *wpa_s)
151 wpa_s = wpa_s->p2p_dev;
153 wpas_p2p_stop_find(wpa_s);
158 DBusMessage * wpas_dbus_handler_p2p_rejectpeer(DBusMessage *message,
159 struct wpa_supplicant *wpa_s)
161 DBusMessageIter iter;
162 char *peer_object_path = NULL;
163 u8 peer_addr[ETH_ALEN];
165 dbus_message_iter_init(message, &iter);
166 dbus_message_iter_get_basic(&iter, &peer_object_path);
168 if (parse_peer_object_path(peer_object_path, peer_addr) < 0)
169 return wpas_dbus_error_invalid_args(message, NULL);
172 wpa_s = wpa_s->p2p_dev;
174 if (wpas_p2p_reject(wpa_s, peer_addr) < 0)
175 return wpas_dbus_error_unknown_error(message,
176 "Failed to call wpas_p2p_reject method.");
182 DBusMessage * wpas_dbus_handler_p2p_listen(DBusMessage *message,
183 struct wpa_supplicant *wpa_s)
185 dbus_int32_t timeout = 0;
187 if (!dbus_message_get_args(message, NULL, DBUS_TYPE_INT32, &timeout,
189 return dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
193 wpa_s = wpa_s->p2p_dev;
195 if (wpas_p2p_listen(wpa_s, (unsigned int) timeout)) {
196 return dbus_message_new_error(message,
197 WPAS_DBUS_ERROR_UNKNOWN_ERROR,
198 "Could not start P2P listen");
205 DBusMessage * wpas_dbus_handler_p2p_extendedlisten(
206 DBusMessage *message, struct wpa_supplicant *wpa_s)
208 unsigned int period = 0, interval = 0;
209 struct wpa_dbus_dict_entry entry;
210 DBusMessageIter iter;
211 DBusMessageIter iter_dict;
213 dbus_message_iter_init(message, &iter);
216 if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
219 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
220 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
223 if (!os_strcmp(entry.key, "period") &&
224 (entry.type == DBUS_TYPE_INT32))
225 period = entry.uint32_value;
226 else if (!os_strcmp(entry.key, "interval") &&
227 (entry.type == DBUS_TYPE_INT32))
228 interval = entry.uint32_value;
231 wpa_dbus_dict_entry_clear(&entry);
235 wpa_s = wpa_s->p2p_dev;
237 if (wpas_p2p_ext_listen(wpa_s, period, interval))
238 return wpas_dbus_error_unknown_error(
239 message, "failed to initiate a p2p_ext_listen.");
244 wpa_dbus_dict_entry_clear(&entry);
246 return wpas_dbus_error_invalid_args(message, entry.key);
250 DBusMessage * wpas_dbus_handler_p2p_presence_request(
251 DBusMessage *message, struct wpa_supplicant *wpa_s)
253 unsigned int dur1 = 0, int1 = 0, dur2 = 0, int2 = 0;
254 struct wpa_dbus_dict_entry entry;
255 DBusMessageIter iter;
256 DBusMessageIter iter_dict;
258 dbus_message_iter_init(message, &iter);
261 if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
264 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
265 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
268 if (!os_strcmp(entry.key, "duration1") &&
269 (entry.type == DBUS_TYPE_INT32))
270 dur1 = entry.uint32_value;
271 else if (!os_strcmp(entry.key, "interval1") &&
272 entry.type == DBUS_TYPE_INT32)
273 int1 = entry.uint32_value;
274 else if (!os_strcmp(entry.key, "duration2") &&
275 entry.type == DBUS_TYPE_INT32)
276 dur2 = entry.uint32_value;
277 else if (!os_strcmp(entry.key, "interval2") &&
278 entry.type == DBUS_TYPE_INT32)
279 int2 = entry.uint32_value;
283 wpa_dbus_dict_entry_clear(&entry);
287 wpa_s = wpa_s->p2p_dev;
289 if (wpas_p2p_presence_req(wpa_s, dur1, int1, dur2, int2) < 0)
290 return wpas_dbus_error_unknown_error(message,
291 "Failed to invoke presence request.");
296 wpa_dbus_dict_entry_clear(&entry);
298 return wpas_dbus_error_invalid_args(message, entry.key);
302 DBusMessage * wpas_dbus_handler_p2p_group_add(DBusMessage *message,
303 struct wpa_supplicant *wpa_s)
305 DBusMessageIter iter_dict;
306 DBusMessage *reply = NULL;
307 DBusMessageIter iter;
308 struct wpa_dbus_dict_entry entry;
309 char *pg_object_path = NULL;
310 int persistent_group = 0;
313 unsigned int group_id = 0;
314 struct wpa_ssid *ssid;
316 dbus_message_iter_init(message, &iter);
318 if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
321 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
322 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
325 if (!os_strcmp(entry.key, "persistent") &&
326 (entry.type == DBUS_TYPE_BOOLEAN)) {
327 persistent_group = (entry.bool_value == TRUE) ? 1 : 0;
328 } else if (!os_strcmp(entry.key, "frequency") &&
329 (entry.type == DBUS_TYPE_INT32)) {
330 freq = entry.int32_value;
333 } else if (!os_strcmp(entry.key, "persistent_group_object") &&
334 entry.type == DBUS_TYPE_OBJECT_PATH)
335 pg_object_path = os_strdup(entry.str_value);
339 wpa_dbus_dict_entry_clear(&entry);
343 wpa_s = wpa_s->p2p_dev;
345 if (pg_object_path != NULL) {
349 * A persistent group Object Path is defined meaning we want
350 * to re-invoke a persistent group.
353 iface = wpas_dbus_new_decompose_object_path(
354 pg_object_path, WPAS_DBUS_NEW_PERSISTENT_GROUPS_PART,
356 if (iface == NULL || net_id_str == NULL ||
357 os_strcmp(iface, wpa_s->dbus_new_path) != 0) {
359 wpas_dbus_error_invalid_args(message,
364 group_id = strtoul(net_id_str, NULL, 10);
365 if (errno == EINVAL) {
366 reply = wpas_dbus_error_invalid_args(
367 message, pg_object_path);
371 /* Get the SSID structure from the persistent group id */
372 ssid = wpa_config_get_network(wpa_s->conf, group_id);
373 if (ssid == NULL || ssid->disabled != 2)
376 if (wpas_p2p_group_add_persistent(wpa_s, ssid, 0, freq, 0, 0, 0,
378 reply = wpas_dbus_error_unknown_error(
380 "Failed to reinvoke a persistent group");
383 } else if (wpas_p2p_group_add(wpa_s, persistent_group, freq, 0, 0))
387 os_free(pg_object_path);
391 wpa_dbus_dict_entry_clear(&entry);
393 reply = wpas_dbus_error_invalid_args(message, NULL);
398 DBusMessage * wpas_dbus_handler_p2p_disconnect(DBusMessage *message,
399 struct wpa_supplicant *wpa_s)
401 if (wpas_p2p_disconnect(wpa_s))
402 return wpas_dbus_error_unknown_error(message,
403 "failed to disconnect");
409 static dbus_bool_t wpa_dbus_p2p_check_enabled(struct wpa_supplicant *wpa_s,
410 DBusMessage *message,
411 DBusMessage **out_reply,
414 /* Return an error message or an error if P2P isn't available */
415 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL) {
417 *out_reply = dbus_message_new_error(
418 message, DBUS_ERROR_FAILED,
419 "P2P is not available for this interface");
421 dbus_set_error_const(error, DBUS_ERROR_FAILED,
422 "P2P is not available for this "
430 DBusMessage * wpas_dbus_handler_p2p_flush(DBusMessage *message,
431 struct wpa_supplicant *wpa_s)
433 DBusMessage *reply = NULL;
435 if (!wpa_dbus_p2p_check_enabled(wpa_s, message, &reply, NULL))
439 wpa_s = wpa_s->p2p_dev;
441 os_memset(wpa_s->p2p_auth_invite, 0, ETH_ALEN);
442 wpa_s->force_long_sd = 0;
443 p2p_flush(wpa_s->global->p2p);
449 DBusMessage * wpas_dbus_handler_p2p_connect(DBusMessage *message,
450 struct wpa_supplicant *wpa_s)
452 DBusMessageIter iter_dict;
453 DBusMessage *reply = NULL;
454 DBusMessageIter iter;
455 struct wpa_dbus_dict_entry entry;
456 char *peer_object_path = NULL;
457 int persistent_group = 0;
459 int authorize_only = 0;
464 enum p2p_wps_method wps_method = WPS_NOT_READY;
466 char *err_msg = NULL;
469 if (!wpa_dbus_p2p_check_enabled(wpa_s, message, &reply, NULL))
472 dbus_message_iter_init(message, &iter);
474 if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
477 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
478 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
481 if (!os_strcmp(entry.key, "peer") &&
482 (entry.type == DBUS_TYPE_OBJECT_PATH)) {
483 peer_object_path = os_strdup(entry.str_value);
484 } else if (!os_strcmp(entry.key, "persistent") &&
485 (entry.type == DBUS_TYPE_BOOLEAN)) {
486 persistent_group = (entry.bool_value == TRUE) ? 1 : 0;
487 } else if (!os_strcmp(entry.key, "join") &&
488 (entry.type == DBUS_TYPE_BOOLEAN)) {
489 join = (entry.bool_value == TRUE) ? 1 : 0;
490 } else if (!os_strcmp(entry.key, "authorize_only") &&
491 (entry.type == DBUS_TYPE_BOOLEAN)) {
492 authorize_only = (entry.bool_value == TRUE) ? 1 : 0;
493 } else if (!os_strcmp(entry.key, "frequency") &&
494 (entry.type == DBUS_TYPE_INT32)) {
495 freq = entry.int32_value;
498 } else if (!os_strcmp(entry.key, "go_intent") &&
499 (entry.type == DBUS_TYPE_INT32)) {
500 go_intent = entry.int32_value;
501 if ((go_intent < 0) || (go_intent > 15))
503 } else if (!os_strcmp(entry.key, "wps_method") &&
504 (entry.type == DBUS_TYPE_STRING)) {
505 if (!os_strcmp(entry.str_value, "pbc"))
506 wps_method = WPS_PBC;
507 else if (!os_strcmp(entry.str_value, "pin"))
508 wps_method = WPS_PIN_DISPLAY;
509 else if (!os_strcmp(entry.str_value, "display"))
510 wps_method = WPS_PIN_DISPLAY;
511 else if (!os_strcmp(entry.str_value, "keypad"))
512 wps_method = WPS_PIN_KEYPAD;
515 } else if (!os_strcmp(entry.key, "pin") &&
516 (entry.type == DBUS_TYPE_STRING)) {
517 pin = os_strdup(entry.str_value);
521 wpa_dbus_dict_entry_clear(&entry);
524 if (wps_method == WPS_NOT_READY ||
525 parse_peer_object_path(peer_object_path, addr) < 0 ||
526 !p2p_peer_known(wpa_s->global->p2p, addr))
530 * Validate the wps_method specified and the pin value.
532 if ((!pin || !pin[0]) && (wps_method == WPS_PIN_KEYPAD))
536 wpa_s = wpa_s->p2p_dev;
538 new_pin = wpas_p2p_connect(wpa_s, addr, pin, wps_method,
539 persistent_group, 0, join, authorize_only,
540 go_intent, freq, -1, 0, 0, 0);
545 os_snprintf(npin, sizeof(npin), "%08d", new_pin);
546 generated_pin = npin;
547 reply = dbus_message_new_method_return(message);
548 dbus_message_append_args(reply, DBUS_TYPE_STRING,
549 &generated_pin, DBUS_TYPE_INVALID);
553 err_msg = "connect failed due to channel "
555 iface = WPAS_DBUS_ERROR_CONNECT_CHANNEL_UNAVAILABLE;
559 err_msg = "connect failed due to unsupported channel.";
560 iface = WPAS_DBUS_ERROR_CONNECT_CHANNEL_UNSUPPORTED;
564 err_msg = "connect failed due to unspecified error.";
565 iface = WPAS_DBUS_ERROR_CONNECT_UNSPECIFIED_ERROR;
571 * Do we need specialized errors corresponding to above
572 * error conditions as against just returning a different
575 reply = dbus_message_new_error(message, iface, err_msg);
579 os_free(peer_object_path);
583 wpa_dbus_dict_entry_clear(&entry);
585 reply = wpas_dbus_error_invalid_args(message, NULL);
590 DBusMessage * wpas_dbus_handler_p2p_invite(DBusMessage *message,
591 struct wpa_supplicant *wpa_s)
593 DBusMessageIter iter_dict;
594 DBusMessage *reply = NULL;
595 DBusMessageIter iter;
596 struct wpa_dbus_dict_entry entry;
597 char *peer_object_path = NULL;
598 char *pg_object_path = NULL;
600 u8 peer_addr[ETH_ALEN];
601 unsigned int group_id = 0;
603 struct wpa_ssid *ssid;
605 if (!wpa_dbus_p2p_check_enabled(wpa_s, message, &reply, NULL))
608 dbus_message_iter_init(message, &iter);
610 if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
613 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
614 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
617 if (!os_strcmp(entry.key, "peer") &&
618 (entry.type == DBUS_TYPE_OBJECT_PATH)) {
619 peer_object_path = os_strdup(entry.str_value);
620 wpa_dbus_dict_entry_clear(&entry);
621 } else if (!os_strcmp(entry.key, "persistent_group_object") &&
622 (entry.type == DBUS_TYPE_OBJECT_PATH)) {
623 pg_object_path = os_strdup(entry.str_value);
625 wpa_dbus_dict_entry_clear(&entry);
627 wpa_dbus_dict_entry_clear(&entry);
632 if (parse_peer_object_path(peer_object_path, peer_addr) < 0 ||
633 !p2p_peer_known(wpa_s->global->p2p, peer_addr))
637 wpa_s = wpa_s->p2p_dev;
642 * A group ID is defined meaning we want to re-invoke a
646 iface = wpas_dbus_new_decompose_object_path(
648 WPAS_DBUS_NEW_PERSISTENT_GROUPS_PART,
650 if (iface == NULL || net_id_str == NULL ||
651 os_strcmp(iface, wpa_s->dbus_new_path) != 0) {
652 reply = wpas_dbus_error_invalid_args(message,
657 group_id = strtoul(net_id_str, NULL, 10);
658 if (errno == EINVAL) {
659 reply = wpas_dbus_error_invalid_args(
660 message, pg_object_path);
664 /* Get the SSID structure from the persistent group id */
665 ssid = wpa_config_get_network(wpa_s->conf, group_id);
666 if (ssid == NULL || ssid->disabled != 2)
669 if (wpas_p2p_invite(wpa_s, peer_addr, ssid, NULL, 0, 0, 0, 0) <
671 reply = wpas_dbus_error_unknown_error(
673 "Failed to reinvoke a persistent group");
678 * No group ID means propose to a peer to join my active group
680 if (wpas_p2p_invite_group(wpa_s, wpa_s->ifname,
682 reply = wpas_dbus_error_unknown_error(
683 message, "Failed to join to an active group");
690 os_free(pg_object_path);
691 os_free(peer_object_path);
695 reply = wpas_dbus_error_invalid_args(message, NULL);
700 DBusMessage * wpas_dbus_handler_p2p_prov_disc_req(DBusMessage *message,
701 struct wpa_supplicant *wpa_s)
703 DBusMessageIter iter;
704 char *peer_object_path = NULL;
705 char *config_method = NULL;
706 u8 peer_addr[ETH_ALEN];
708 dbus_message_iter_init(message, &iter);
709 dbus_message_iter_get_basic(&iter, &peer_object_path);
711 if (parse_peer_object_path(peer_object_path, peer_addr) < 0)
712 return wpas_dbus_error_invalid_args(message, NULL);
714 dbus_message_iter_next(&iter);
715 dbus_message_iter_get_basic(&iter, &config_method);
718 * Validation checks on config_method are being duplicated here
719 * to be able to return invalid args reply since the error code
720 * from p2p module are not granular enough (yet).
722 if (os_strcmp(config_method, "display") &&
723 os_strcmp(config_method, "keypad") &&
724 os_strcmp(config_method, "pbc") &&
725 os_strcmp(config_method, "pushbutton"))
726 return wpas_dbus_error_invalid_args(message, NULL);
729 wpa_s = wpa_s->p2p_dev;
731 if (wpas_p2p_prov_disc(wpa_s, peer_addr, config_method,
732 WPAS_P2P_PD_FOR_GO_NEG) < 0)
733 return wpas_dbus_error_unknown_error(message,
734 "Failed to send provision discovery request");
741 * P2P Device property accessor methods.
744 dbus_bool_t wpas_dbus_getter_p2p_device_config(DBusMessageIter *iter,
748 struct wpa_supplicant *wpa_s = user_data;
749 DBusMessageIter variant_iter, dict_iter;
750 DBusMessageIter iter_secdev_dict_entry, iter_secdev_dict_val,
751 iter_secdev_dict_array;
752 const char *dev_name;
753 int num_vendor_extensions = 0;
755 const struct wpabuf *vendor_ext[P2P_MAX_WPS_VENDOR_EXT];
757 if (!wpa_dbus_p2p_check_enabled(wpa_s, NULL, NULL, error))
761 wpa_s = wpa_s->p2p_dev;
763 if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
764 "a{sv}", &variant_iter) ||
765 !wpa_dbus_dict_open_write(&variant_iter, &dict_iter))
769 dev_name = wpa_s->conf->device_name;
771 !wpa_dbus_dict_append_string(&dict_iter, "DeviceName", dev_name))
774 /* Primary device type */
775 if (!wpa_dbus_dict_append_byte_array(&dict_iter, "PrimaryDeviceType",
776 (char *)wpa_s->conf->device_type,
780 /* Secondary device types */
781 if (wpa_s->conf->num_sec_device_types) {
782 if (!wpa_dbus_dict_begin_array(&dict_iter,
783 "SecondaryDeviceTypes",
784 DBUS_TYPE_ARRAY_AS_STRING
785 DBUS_TYPE_BYTE_AS_STRING,
786 &iter_secdev_dict_entry,
787 &iter_secdev_dict_val,
788 &iter_secdev_dict_array))
791 for (i = 0; i < wpa_s->conf->num_sec_device_types; i++)
792 wpa_dbus_dict_bin_array_add_element(
793 &iter_secdev_dict_array,
794 wpa_s->conf->sec_device_type[i],
797 if (!wpa_dbus_dict_end_array(&dict_iter,
798 &iter_secdev_dict_entry,
799 &iter_secdev_dict_val,
800 &iter_secdev_dict_array))
804 /* Vendor Extensions */
805 for (i = 0; i < P2P_MAX_WPS_VENDOR_EXT; i++) {
806 if (wpa_s->conf->wps_vendor_ext[i] == NULL)
808 vendor_ext[num_vendor_extensions++] =
809 wpa_s->conf->wps_vendor_ext[i];
812 if (num_vendor_extensions &&
813 !wpa_dbus_dict_append_wpabuf_array(&dict_iter,
816 num_vendor_extensions))
820 if (!wpa_dbus_dict_append_uint32(&dict_iter, "GOIntent",
821 wpa_s->conf->p2p_go_intent))
824 /* Persistent Reconnect */
825 if (!wpa_dbus_dict_append_bool(&dict_iter, "PersistentReconnect",
826 wpa_s->conf->persistent_reconnect))
829 /* Listen Reg Class */
830 if (!wpa_dbus_dict_append_uint32(&dict_iter, "ListenRegClass",
831 wpa_s->conf->p2p_listen_reg_class))
835 if (!wpa_dbus_dict_append_uint32(&dict_iter, "ListenChannel",
836 wpa_s->conf->p2p_listen_channel))
840 if (!wpa_dbus_dict_append_uint32(&dict_iter, "OperRegClass",
841 wpa_s->conf->p2p_oper_reg_class))
845 if (!wpa_dbus_dict_append_uint32(&dict_iter, "OperChannel",
846 wpa_s->conf->p2p_oper_channel))
850 if (wpa_s->conf->p2p_ssid_postfix &&
851 !wpa_dbus_dict_append_string(&dict_iter, "SsidPostfix",
852 wpa_s->conf->p2p_ssid_postfix))
856 if (!wpa_dbus_dict_append_bool(&dict_iter, "IntraBss",
857 wpa_s->conf->p2p_intra_bss))
861 if (!wpa_dbus_dict_append_uint32(&dict_iter, "GroupIdle",
862 wpa_s->conf->p2p_group_idle))
865 /* Dissasociation low ack */
866 if (!wpa_dbus_dict_append_uint32(&dict_iter, "disassoc_low_ack",
867 wpa_s->conf->disassoc_low_ack))
871 if (!wpa_dbus_dict_append_bool(&dict_iter, "NoGroupIface",
872 wpa_s->conf->p2p_no_group_iface))
875 /* P2P Search Delay */
876 if (!wpa_dbus_dict_append_uint32(&dict_iter, "p2p_search_delay",
877 wpa_s->conf->p2p_search_delay))
880 if (!wpa_dbus_dict_close_write(&variant_iter, &dict_iter) ||
881 !dbus_message_iter_close_container(iter, &variant_iter))
887 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
892 dbus_bool_t wpas_dbus_setter_p2p_device_config(DBusMessageIter *iter,
896 struct wpa_supplicant *wpa_s = user_data;
897 DBusMessageIter variant_iter, iter_dict;
898 struct wpa_dbus_dict_entry entry = {.type = DBUS_TYPE_STRING };
901 if (!wpa_dbus_p2p_check_enabled(wpa_s, NULL, NULL, error))
905 wpa_s = wpa_s->p2p_dev;
907 dbus_message_iter_recurse(iter, &variant_iter);
908 if (!wpa_dbus_dict_open_read(&variant_iter, &iter_dict, error))
911 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
912 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry)) {
913 dbus_set_error_const(error, DBUS_ERROR_INVALID_ARGS,
914 "invalid message format");
918 if (os_strcmp(entry.key, "DeviceName") == 0) {
921 if (entry.type != DBUS_TYPE_STRING)
924 devname = os_strdup(entry.str_value);
926 goto err_no_mem_clear;
928 os_free(wpa_s->conf->device_name);
929 wpa_s->conf->device_name = devname;
931 wpa_s->conf->changed_parameters |=
932 CFG_CHANGED_DEVICE_NAME;
933 } else if (os_strcmp(entry.key, "PrimaryDeviceType") == 0) {
934 if (entry.type != DBUS_TYPE_ARRAY ||
935 entry.array_type != DBUS_TYPE_BYTE ||
936 entry.array_len != WPS_DEV_TYPE_LEN)
939 os_memcpy(wpa_s->conf->device_type,
940 entry.bytearray_value,
942 wpa_s->conf->changed_parameters |=
943 CFG_CHANGED_DEVICE_TYPE;
944 } else if (os_strcmp(entry.key, "SecondaryDeviceTypes") == 0) {
945 if (entry.type != DBUS_TYPE_ARRAY ||
946 entry.array_type != WPAS_DBUS_TYPE_BINARRAY ||
947 entry.array_len > MAX_SEC_DEVICE_TYPES)
950 for (i = 0; i < entry.array_len; i++)
951 if (wpabuf_len(entry.binarray_value[i]) !=
953 goto err_no_mem_clear;
954 for (i = 0; i < entry.array_len; i++)
955 os_memcpy(wpa_s->conf->sec_device_type[i],
956 wpabuf_head(entry.binarray_value[i]),
958 wpa_s->conf->num_sec_device_types = entry.array_len;
959 wpa_s->conf->changed_parameters |=
960 CFG_CHANGED_SEC_DEVICE_TYPE;
961 } else if (os_strcmp(entry.key, "VendorExtension") == 0) {
962 if ((entry.type != DBUS_TYPE_ARRAY) ||
963 (entry.array_type != WPAS_DBUS_TYPE_BINARRAY) ||
964 (entry.array_len > P2P_MAX_WPS_VENDOR_EXT))
967 wpa_s->conf->changed_parameters |=
968 CFG_CHANGED_VENDOR_EXTENSION;
970 for (i = 0; i < P2P_MAX_WPS_VENDOR_EXT; i++) {
971 wpabuf_free(wpa_s->conf->wps_vendor_ext[i]);
972 if (i < entry.array_len) {
973 wpa_s->conf->wps_vendor_ext[i] =
974 entry.binarray_value[i];
975 entry.binarray_value[i] = NULL;
977 wpa_s->conf->wps_vendor_ext[i] = NULL;
979 } else if ((os_strcmp(entry.key, "GOIntent") == 0) &&
980 (entry.type == DBUS_TYPE_UINT32) &&
981 (entry.uint32_value <= 15))
982 wpa_s->conf->p2p_go_intent = entry.uint32_value;
983 else if ((os_strcmp(entry.key, "PersistentReconnect") == 0) &&
984 (entry.type == DBUS_TYPE_BOOLEAN))
985 wpa_s->conf->persistent_reconnect = entry.bool_value;
986 else if ((os_strcmp(entry.key, "ListenRegClass") == 0) &&
987 (entry.type == DBUS_TYPE_UINT32)) {
988 wpa_s->conf->p2p_listen_reg_class = entry.uint32_value;
989 wpa_s->conf->changed_parameters |=
990 CFG_CHANGED_P2P_LISTEN_CHANNEL;
991 } else if ((os_strcmp(entry.key, "ListenChannel") == 0) &&
992 (entry.type == DBUS_TYPE_UINT32)) {
993 wpa_s->conf->p2p_listen_channel = entry.uint32_value;
994 wpa_s->conf->changed_parameters |=
995 CFG_CHANGED_P2P_LISTEN_CHANNEL;
996 } else if ((os_strcmp(entry.key, "OperRegClass") == 0) &&
997 (entry.type == DBUS_TYPE_UINT32)) {
998 wpa_s->conf->p2p_oper_reg_class = entry.uint32_value;
999 wpa_s->conf->changed_parameters |=
1000 CFG_CHANGED_P2P_OPER_CHANNEL;
1001 } else if ((os_strcmp(entry.key, "OperChannel") == 0) &&
1002 (entry.type == DBUS_TYPE_UINT32)) {
1003 wpa_s->conf->p2p_oper_channel = entry.uint32_value;
1004 wpa_s->conf->changed_parameters |=
1005 CFG_CHANGED_P2P_OPER_CHANNEL;
1006 } else if (os_strcmp(entry.key, "SsidPostfix") == 0) {
1009 if (entry.type != DBUS_TYPE_STRING)
1012 postfix = os_strdup(entry.str_value);
1014 goto err_no_mem_clear;
1016 os_free(wpa_s->conf->p2p_ssid_postfix);
1017 wpa_s->conf->p2p_ssid_postfix = postfix;
1019 wpa_s->conf->changed_parameters |=
1020 CFG_CHANGED_P2P_SSID_POSTFIX;
1021 } else if ((os_strcmp(entry.key, "IntraBss") == 0) &&
1022 (entry.type == DBUS_TYPE_BOOLEAN)) {
1023 wpa_s->conf->p2p_intra_bss = entry.bool_value;
1024 wpa_s->conf->changed_parameters |=
1025 CFG_CHANGED_P2P_INTRA_BSS;
1026 } else if ((os_strcmp(entry.key, "GroupIdle") == 0) &&
1027 (entry.type == DBUS_TYPE_UINT32))
1028 wpa_s->conf->p2p_group_idle = entry.uint32_value;
1029 else if (os_strcmp(entry.key, "disassoc_low_ack") == 0 &&
1030 entry.type == DBUS_TYPE_UINT32)
1031 wpa_s->conf->disassoc_low_ack = entry.uint32_value;
1032 else if (os_strcmp(entry.key, "NoGroupIface") == 0 &&
1033 entry.type == DBUS_TYPE_BOOLEAN)
1034 wpa_s->conf->p2p_no_group_iface = entry.bool_value;
1035 else if (os_strcmp(entry.key, "p2p_search_delay") == 0 &&
1036 entry.type == DBUS_TYPE_UINT32)
1037 wpa_s->conf->p2p_search_delay = entry.uint32_value;
1041 wpa_dbus_dict_entry_clear(&entry);
1044 if (wpa_s->conf->changed_parameters) {
1045 /* Some changed parameters requires to update config*/
1046 wpa_supplicant_update_config(wpa_s);
1052 dbus_set_error_const(error, DBUS_ERROR_INVALID_ARGS,
1053 "invalid message format");
1054 wpa_dbus_dict_entry_clear(&entry);
1058 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
1059 wpa_dbus_dict_entry_clear(&entry);
1064 dbus_bool_t wpas_dbus_getter_p2p_peers(DBusMessageIter *iter, DBusError *error,
1067 struct wpa_supplicant *wpa_s = user_data;
1068 struct p2p_data *p2p = wpa_s->global->p2p;
1069 int next = 0, i = 0;
1070 int num = 0, out_of_mem = 0;
1072 const struct p2p_peer_info *peer_info = NULL;
1073 dbus_bool_t success = FALSE;
1075 struct dl_list peer_objpath_list;
1076 struct peer_objpath_node {
1077 struct dl_list list;
1078 char path[WPAS_DBUS_OBJECT_PATH_MAX];
1081 char **peer_obj_paths = NULL;
1083 if (!wpa_dbus_p2p_check_enabled(wpa_s, NULL, NULL, error))
1086 dl_list_init(&peer_objpath_list);
1088 /* Get the first peer info */
1089 peer_info = p2p_get_peer_found(p2p, NULL, next);
1091 /* Get next and accumulate them */
1093 while (peer_info != NULL) {
1094 node = os_zalloc(sizeof(struct peer_objpath_node));
1100 addr = peer_info->p2p_device_addr;
1101 os_snprintf(node->path, WPAS_DBUS_OBJECT_PATH_MAX,
1102 "%s/" WPAS_DBUS_NEW_P2P_PEERS_PART
1104 wpa_s->dbus_new_path, MAC2STR(addr));
1105 dl_list_add_tail(&peer_objpath_list, &node->list);
1108 peer_info = p2p_get_peer_found(p2p, addr, next);
1112 * Now construct the peer object paths in a form suitable for
1113 * array_property_getter helper below.
1115 peer_obj_paths = os_calloc(num, sizeof(char *));
1117 if (!peer_obj_paths) {
1122 dl_list_for_each_safe(node, tmp, &peer_objpath_list,
1123 struct peer_objpath_node, list)
1124 peer_obj_paths[i++] = node->path;
1126 success = wpas_dbus_simple_array_property_getter(iter,
1127 DBUS_TYPE_OBJECT_PATH,
1128 peer_obj_paths, num,
1133 os_free(peer_obj_paths);
1135 dl_list_for_each_safe(node, tmp, &peer_objpath_list,
1136 struct peer_objpath_node, list) {
1137 dl_list_del(&node->list);
1141 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
1147 enum wpas_p2p_role {
1148 WPAS_P2P_ROLE_DEVICE,
1150 WPAS_P2P_ROLE_CLIENT,
1153 static enum wpas_p2p_role wpas_get_p2p_role(struct wpa_supplicant *wpa_s)
1155 struct wpa_ssid *ssid = wpa_s->current_ssid;
1158 return WPAS_P2P_ROLE_DEVICE;
1159 if (wpa_s->wpa_state != WPA_COMPLETED)
1160 return WPAS_P2P_ROLE_DEVICE;
1162 switch (ssid->mode) {
1163 case WPAS_MODE_P2P_GO:
1164 case WPAS_MODE_P2P_GROUP_FORMATION:
1165 return WPAS_P2P_ROLE_GO;
1166 case WPAS_MODE_INFRA:
1167 if (ssid->p2p_group)
1168 return WPAS_P2P_ROLE_CLIENT;
1169 return WPAS_P2P_ROLE_DEVICE;
1171 return WPAS_P2P_ROLE_DEVICE;
1176 dbus_bool_t wpas_dbus_getter_p2p_role(DBusMessageIter *iter, DBusError *error,
1179 struct wpa_supplicant *wpa_s = user_data;
1182 switch (wpas_get_p2p_role(wpa_s)) {
1183 case WPAS_P2P_ROLE_GO:
1186 case WPAS_P2P_ROLE_CLIENT:
1194 return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING, &str,
1199 dbus_bool_t wpas_dbus_getter_p2p_group(DBusMessageIter *iter, DBusError *error,
1202 struct wpa_supplicant *wpa_s = user_data;
1203 char path_buf[WPAS_DBUS_OBJECT_PATH_MAX];
1204 char *dbus_groupobj_path = path_buf;
1206 if (wpa_s->dbus_groupobj_path == NULL)
1207 os_snprintf(dbus_groupobj_path, WPAS_DBUS_OBJECT_PATH_MAX,
1210 os_snprintf(dbus_groupobj_path, WPAS_DBUS_OBJECT_PATH_MAX,
1211 "%s", wpa_s->dbus_groupobj_path);
1213 return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_OBJECT_PATH,
1214 &dbus_groupobj_path, error);
1218 dbus_bool_t wpas_dbus_getter_p2p_peergo(DBusMessageIter *iter,
1219 DBusError *error, void *user_data)
1221 struct wpa_supplicant *wpa_s = user_data;
1222 char go_peer_obj_path[WPAS_DBUS_OBJECT_PATH_MAX], *path;
1224 if (wpas_get_p2p_role(wpa_s) != WPAS_P2P_ROLE_CLIENT)
1225 os_snprintf(go_peer_obj_path, WPAS_DBUS_OBJECT_PATH_MAX, "/");
1227 os_snprintf(go_peer_obj_path, WPAS_DBUS_OBJECT_PATH_MAX,
1228 "%s/" WPAS_DBUS_NEW_P2P_PEERS_PART "/"
1230 wpa_s->dbus_new_path, MAC2STR(wpa_s->go_dev_addr));
1232 path = go_peer_obj_path;
1233 return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_OBJECT_PATH,
1239 * Peer object properties accessor methods
1242 dbus_bool_t wpas_dbus_getter_p2p_peer_device_name(DBusMessageIter *iter,
1246 struct peer_handler_args *peer_args = user_data;
1247 const struct p2p_peer_info *info;
1250 if (!wpa_dbus_p2p_check_enabled(peer_args->wpa_s, NULL, NULL, error))
1253 /* get the peer info */
1254 info = p2p_get_peer_found(peer_args->wpa_s->global->p2p,
1255 peer_args->p2p_device_addr, 0);
1257 dbus_set_error(error, DBUS_ERROR_FAILED,
1258 "failed to find peer");
1262 tmp = os_strdup(info->device_name);
1264 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
1268 if (!wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING, &tmp,
1270 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
1280 dbus_bool_t wpas_dbus_getter_p2p_peer_primary_device_type(
1281 DBusMessageIter *iter, DBusError *error, void *user_data)
1283 struct peer_handler_args *peer_args = user_data;
1284 const struct p2p_peer_info *info;
1286 info = p2p_get_peer_found(peer_args->wpa_s->global->p2p,
1287 peer_args->p2p_device_addr, 0);
1289 dbus_set_error(error, DBUS_ERROR_FAILED,
1290 "failed to find peer");
1294 if (!wpas_dbus_simple_array_property_getter(iter, DBUS_TYPE_BYTE,
1297 WPS_DEV_TYPE_LEN, error)) {
1298 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
1306 dbus_bool_t wpas_dbus_getter_p2p_peer_config_method(DBusMessageIter *iter,
1310 struct peer_handler_args *peer_args = user_data;
1311 const struct p2p_peer_info *info;
1313 info = p2p_get_peer_found(peer_args->wpa_s->global->p2p,
1314 peer_args->p2p_device_addr, 0);
1316 dbus_set_error(error, DBUS_ERROR_FAILED,
1317 "failed to find peer");
1321 if (!wpas_dbus_simple_property_getter(iter, DBUS_TYPE_UINT16,
1322 &info->config_methods, error)) {
1323 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
1331 dbus_bool_t wpas_dbus_getter_p2p_peer_level(DBusMessageIter *iter,
1335 struct peer_handler_args *peer_args = user_data;
1336 const struct p2p_peer_info *info;
1338 info = p2p_get_peer_found(peer_args->wpa_s->global->p2p,
1339 peer_args->p2p_device_addr, 0);
1341 dbus_set_error(error, DBUS_ERROR_FAILED,
1342 "failed to find peer");
1346 if (!wpas_dbus_simple_property_getter(iter, DBUS_TYPE_INT32,
1347 &info->level, error)) {
1348 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
1356 dbus_bool_t wpas_dbus_getter_p2p_peer_device_capability(DBusMessageIter *iter,
1360 struct peer_handler_args *peer_args = user_data;
1361 const struct p2p_peer_info *info;
1363 info = p2p_get_peer_found(peer_args->wpa_s->global->p2p,
1364 peer_args->p2p_device_addr, 0);
1366 dbus_set_error(error, DBUS_ERROR_FAILED,
1367 "failed to find peer");
1371 if (!wpas_dbus_simple_property_getter(iter, DBUS_TYPE_BYTE,
1372 &info->dev_capab, error)) {
1373 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
1381 dbus_bool_t wpas_dbus_getter_p2p_peer_group_capability(DBusMessageIter *iter,
1385 struct peer_handler_args *peer_args = user_data;
1386 const struct p2p_peer_info *info;
1388 info = p2p_get_peer_found(peer_args->wpa_s->global->p2p,
1389 peer_args->p2p_device_addr, 0);
1391 dbus_set_error(error, DBUS_ERROR_FAILED,
1392 "failed to find peer");
1396 if (!wpas_dbus_simple_property_getter(iter, DBUS_TYPE_BYTE,
1397 &info->group_capab, error)) {
1398 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
1406 dbus_bool_t wpas_dbus_getter_p2p_peer_secondary_device_types(
1407 DBusMessageIter *iter, DBusError *error, void *user_data)
1409 struct peer_handler_args *peer_args = user_data;
1410 const struct p2p_peer_info *info;
1411 DBusMessageIter variant_iter, array_iter;
1413 info = p2p_get_peer_found(peer_args->wpa_s->global->p2p,
1414 peer_args->p2p_device_addr, 0);
1416 dbus_set_error(error, DBUS_ERROR_FAILED,
1417 "failed to find peer");
1421 if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
1422 DBUS_TYPE_ARRAY_AS_STRING
1423 DBUS_TYPE_ARRAY_AS_STRING
1424 DBUS_TYPE_BYTE_AS_STRING,
1426 dbus_set_error(error, DBUS_ERROR_FAILED,
1427 "%s: failed to construct message 1", __func__);
1431 if (!dbus_message_iter_open_container(&variant_iter, DBUS_TYPE_ARRAY,
1432 DBUS_TYPE_ARRAY_AS_STRING
1433 DBUS_TYPE_BYTE_AS_STRING,
1435 dbus_set_error(error, DBUS_ERROR_FAILED,
1436 "%s: failed to construct message 2", __func__);
1440 if (info->wps_sec_dev_type_list_len) {
1441 const u8 *sec_dev_type_list = info->wps_sec_dev_type_list;
1442 int num_sec_device_types =
1443 info->wps_sec_dev_type_list_len / WPS_DEV_TYPE_LEN;
1445 DBusMessageIter inner_array_iter;
1447 for (i = 0; i < num_sec_device_types; i++) {
1448 if (!dbus_message_iter_open_container(
1449 &array_iter, DBUS_TYPE_ARRAY,
1450 DBUS_TYPE_BYTE_AS_STRING,
1451 &inner_array_iter)) {
1452 dbus_set_error(error, DBUS_ERROR_FAILED,
1453 "%s: failed to construct "
1459 if (!dbus_message_iter_append_fixed_array(
1460 &inner_array_iter, DBUS_TYPE_BYTE,
1461 &sec_dev_type_list, WPS_DEV_TYPE_LEN)) {
1462 dbus_set_error(error, DBUS_ERROR_FAILED,
1463 "%s: failed to construct "
1469 if (!dbus_message_iter_close_container(
1470 &array_iter, &inner_array_iter)) {
1471 dbus_set_error(error, DBUS_ERROR_FAILED,
1472 "%s: failed to construct "
1478 sec_dev_type_list += WPS_DEV_TYPE_LEN;
1482 if (!dbus_message_iter_close_container(&variant_iter, &array_iter)) {
1483 dbus_set_error(error, DBUS_ERROR_FAILED,
1484 "%s: failed to construct message 6", __func__);
1488 if (!dbus_message_iter_close_container(iter, &variant_iter)) {
1489 dbus_set_error(error, DBUS_ERROR_FAILED,
1490 "%s: failed to construct message 7", __func__);
1498 dbus_bool_t wpas_dbus_getter_p2p_peer_vendor_extension(DBusMessageIter *iter,
1502 struct wpabuf *vendor_extension[P2P_MAX_WPS_VENDOR_EXT];
1503 unsigned int i, num = 0;
1504 struct peer_handler_args *peer_args = user_data;
1505 const struct p2p_peer_info *info;
1507 info = p2p_get_peer_found(peer_args->wpa_s->global->p2p,
1508 peer_args->p2p_device_addr, 0);
1510 dbus_set_error(error, DBUS_ERROR_FAILED,
1511 "failed to find peer");
1515 /* Add WPS vendor extensions attribute */
1516 os_memset(vendor_extension, 0, sizeof(vendor_extension));
1517 for (i = 0; i < P2P_MAX_WPS_VENDOR_EXT; i++) {
1518 if (info->wps_vendor_ext[i] == NULL)
1520 vendor_extension[num] = info->wps_vendor_ext[i];
1524 if (!wpas_dbus_simple_array_array_property_getter(iter, DBUS_TYPE_BYTE,
1533 dbus_bool_t wpas_dbus_getter_p2p_peer_ies(DBusMessageIter *iter,
1534 DBusError *error, void *user_data)
1536 struct peer_handler_args *peer_args = user_data;
1537 const struct p2p_peer_info *info;
1539 info = p2p_get_peer_found(peer_args->wpa_s->global->p2p,
1540 peer_args->p2p_device_addr, 0);
1542 dbus_set_error(error, DBUS_ERROR_FAILED,
1543 "failed to find peer");
1547 if (info->wfd_subelems == NULL)
1548 return wpas_dbus_simple_array_property_getter(iter,
1552 return wpas_dbus_simple_array_property_getter(
1553 iter, DBUS_TYPE_BYTE, (char *) info->wfd_subelems->buf,
1554 info->wfd_subelems->used, error);
1558 dbus_bool_t wpas_dbus_getter_p2p_peer_device_address(DBusMessageIter *iter,
1562 struct peer_handler_args *peer_args = user_data;
1563 const struct p2p_peer_info *info;
1565 info = p2p_get_peer_found(peer_args->wpa_s->global->p2p,
1566 peer_args->p2p_device_addr, 0);
1568 dbus_set_error(error, DBUS_ERROR_FAILED,
1569 "failed to find peer");
1573 return wpas_dbus_simple_array_property_getter(
1574 iter, DBUS_TYPE_BYTE, (char *) info->p2p_device_addr,
1579 struct peer_group_data {
1580 struct wpa_supplicant *wpa_s;
1581 const struct p2p_peer_info *info;
1583 unsigned int nb_paths;
1588 static int match_group_where_peer_is_client(struct p2p_group *group,
1591 struct peer_group_data *data = user_data;
1592 const struct p2p_group_config *cfg;
1593 struct wpa_supplicant *wpa_s_go;
1596 if (!p2p_group_is_client_connected(group, data->info->p2p_device_addr))
1599 cfg = p2p_group_get_config(group);
1601 wpa_s_go = wpas_get_p2p_go_iface(data->wpa_s, cfg->ssid,
1603 if (wpa_s_go == NULL)
1606 paths = os_realloc_array(data->paths, data->nb_paths + 1,
1611 data->paths = paths;
1612 data->paths[data->nb_paths] = wpa_s_go->dbus_groupobj_path;
1618 data->error = ENOMEM;
1623 dbus_bool_t wpas_dbus_getter_p2p_peer_groups(DBusMessageIter *iter,
1627 struct peer_handler_args *peer_args = user_data;
1628 const struct p2p_peer_info *info;
1629 struct peer_group_data data;
1630 struct wpa_supplicant *wpa_s, *wpa_s_go;
1631 dbus_bool_t success = FALSE;
1633 info = p2p_get_peer_found(peer_args->wpa_s->global->p2p,
1634 peer_args->p2p_device_addr, 0);
1636 dbus_set_error(error, DBUS_ERROR_FAILED,
1637 "failed to find peer");
1641 os_memset(&data, 0, sizeof(data));
1643 wpa_s = peer_args->wpa_s;
1645 wpa_s = wpa_s->p2p_dev;
1647 wpa_s_go = wpas_get_p2p_client_iface(wpa_s, info->p2p_device_addr);
1649 data.paths = os_calloc(1, sizeof(char *));
1650 if (data.paths == NULL)
1652 data.paths[0] = wpa_s_go->dbus_groupobj_path;
1656 data.wpa_s = peer_args->wpa_s;
1659 p2p_loop_on_all_groups(peer_args->wpa_s->global->p2p,
1660 match_group_where_peer_is_client, &data);
1664 if (data.paths == NULL) {
1665 return wpas_dbus_simple_array_property_getter(
1666 iter, DBUS_TYPE_OBJECT_PATH, NULL, 0, error);
1669 success = wpas_dbus_simple_array_property_getter(iter,
1670 DBUS_TYPE_OBJECT_PATH,
1672 data.nb_paths, error);
1676 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
1678 os_free(data.paths);
1684 * wpas_dbus_getter_persistent_groups - Get array of persistent group objects
1685 * @iter: Pointer to incoming dbus message iter
1686 * @error: Location to store error on failure
1687 * @user_data: Function specific data
1688 * Returns: TRUE on success, FALSE on failure
1690 * Getter for "PersistentGroups" property.
1692 dbus_bool_t wpas_dbus_getter_persistent_groups(DBusMessageIter *iter,
1696 struct wpa_supplicant *wpa_s = user_data;
1697 struct wpa_ssid *ssid;
1699 unsigned int i = 0, num = 0;
1700 dbus_bool_t success = FALSE;
1702 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
1703 if (network_is_persistent_group(ssid))
1706 paths = os_calloc(num, sizeof(char *));
1708 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
1712 /* Loop through configured networks and append object path of each */
1713 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) {
1714 if (!network_is_persistent_group(ssid))
1716 paths[i] = os_zalloc(WPAS_DBUS_OBJECT_PATH_MAX);
1717 if (paths[i] == NULL) {
1718 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY,
1722 /* Construct the object path for this network. */
1723 os_snprintf(paths[i++], WPAS_DBUS_OBJECT_PATH_MAX,
1724 "%s/" WPAS_DBUS_NEW_PERSISTENT_GROUPS_PART "/%d",
1725 wpa_s->dbus_new_path, ssid->id);
1728 success = wpas_dbus_simple_array_property_getter(iter,
1729 DBUS_TYPE_OBJECT_PATH,
1734 os_free(paths[--i]);
1741 * wpas_dbus_getter_persistent_group_properties - Get options for a persistent
1743 * @iter: Pointer to incoming dbus message iter
1744 * @error: Location to store error on failure
1745 * @user_data: Function specific data
1746 * Returns: TRUE on success, FALSE on failure
1748 * Getter for "Properties" property of a persistent group.
1750 dbus_bool_t wpas_dbus_getter_persistent_group_properties(DBusMessageIter *iter,
1754 struct network_handler_args *net = user_data;
1756 /* Leveraging the fact that persistent group object is still
1757 * represented in same manner as network within.
1759 return wpas_dbus_getter_network_properties(iter, error, net);
1764 * wpas_dbus_setter_persistent_group_properties - Get options for a persistent
1766 * @iter: Pointer to incoming dbus message iter
1767 * @error: Location to store error on failure
1768 * @user_data: Function specific data
1769 * Returns: TRUE on success, FALSE on failure
1771 * Setter for "Properties" property of a persistent group.
1773 dbus_bool_t wpas_dbus_setter_persistent_group_properties(DBusMessageIter *iter,
1777 struct network_handler_args *net = user_data;
1778 struct wpa_ssid *ssid = net->ssid;
1779 DBusMessageIter variant_iter;
1782 * Leveraging the fact that persistent group object is still
1783 * represented in same manner as network within.
1785 dbus_message_iter_recurse(iter, &variant_iter);
1786 return set_network_properties(net->wpa_s, ssid, &variant_iter, error);
1791 * wpas_dbus_new_iface_add_persistent_group - Add a new configured
1793 * @message: Pointer to incoming dbus message
1794 * @wpa_s: wpa_supplicant structure for a network interface
1795 * Returns: A dbus message containing the object path of the new
1798 * Handler function for "AddPersistentGroup" method call of a P2P Device
1801 DBusMessage * wpas_dbus_handler_add_persistent_group(
1802 DBusMessage *message, struct wpa_supplicant *wpa_s)
1804 DBusMessage *reply = NULL;
1805 DBusMessageIter iter;
1806 struct wpa_ssid *ssid = NULL;
1807 char path_buf[WPAS_DBUS_OBJECT_PATH_MAX], *path = path_buf;
1810 dbus_message_iter_init(message, &iter);
1812 ssid = wpa_config_add_network(wpa_s->conf);
1814 wpa_printf(MSG_ERROR, "dbus: %s: "
1815 "Cannot add new persistent group", __func__);
1816 reply = wpas_dbus_error_unknown_error(
1818 "wpa_supplicant could not add "
1819 "a persistent group on this interface.");
1823 /* Mark the ssid as being a persistent group before the notification */
1825 ssid->p2p_persistent_group = 1;
1826 wpas_notify_persistent_group_added(wpa_s, ssid);
1828 wpa_config_set_network_defaults(ssid);
1830 dbus_error_init(&error);
1831 if (!set_network_properties(wpa_s, ssid, &iter, &error)) {
1832 wpa_printf(MSG_DEBUG, "dbus: %s: "
1833 "Control interface could not set persistent group "
1834 "properties", __func__);
1835 reply = wpas_dbus_reply_new_from_error(message, &error,
1836 DBUS_ERROR_INVALID_ARGS,
1837 "Failed to set network "
1839 dbus_error_free(&error);
1843 /* Construct the object path for this network. */
1844 os_snprintf(path, WPAS_DBUS_OBJECT_PATH_MAX,
1845 "%s/" WPAS_DBUS_NEW_PERSISTENT_GROUPS_PART "/%d",
1846 wpa_s->dbus_new_path, ssid->id);
1848 reply = dbus_message_new_method_return(message);
1849 if (reply == NULL) {
1850 reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
1854 if (!dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH, &path,
1855 DBUS_TYPE_INVALID)) {
1856 dbus_message_unref(reply);
1857 reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
1866 wpas_notify_persistent_group_removed(wpa_s, ssid);
1867 wpa_config_remove_network(wpa_s->conf, ssid->id);
1874 * wpas_dbus_handler_remove_persistent_group - Remove a configured persistent
1876 * @message: Pointer to incoming dbus message
1877 * @wpa_s: wpa_supplicant structure for a network interface
1878 * Returns: NULL on success or dbus error on failure
1880 * Handler function for "RemovePersistentGroup" method call of a P2P Device
1883 DBusMessage * wpas_dbus_handler_remove_persistent_group(
1884 DBusMessage *message, struct wpa_supplicant *wpa_s)
1886 DBusMessage *reply = NULL;
1888 char *iface = NULL, *persistent_group_id;
1890 struct wpa_ssid *ssid;
1892 dbus_message_get_args(message, NULL, DBUS_TYPE_OBJECT_PATH, &op,
1896 * Extract the network ID and ensure the network is actually a child of
1899 iface = wpas_dbus_new_decompose_object_path(
1900 op, WPAS_DBUS_NEW_PERSISTENT_GROUPS_PART,
1901 &persistent_group_id);
1902 if (iface == NULL || persistent_group_id == NULL ||
1903 os_strcmp(iface, wpa_s->dbus_new_path) != 0) {
1904 reply = wpas_dbus_error_invalid_args(message, op);
1908 id = strtoul(persistent_group_id, NULL, 10);
1909 if (errno == EINVAL) {
1910 reply = wpas_dbus_error_invalid_args(message, op);
1914 ssid = wpa_config_get_network(wpa_s->conf, id);
1916 reply = wpas_dbus_error_persistent_group_unknown(message);
1920 wpas_notify_persistent_group_removed(wpa_s, ssid);
1922 if (wpa_config_remove_network(wpa_s->conf, id) < 0) {
1923 wpa_printf(MSG_ERROR, "dbus: %s: "
1924 "error occurred when removing persistent group %d",
1926 reply = wpas_dbus_error_unknown_error(
1928 "error removing the specified persistent group on "
1939 static void remove_persistent_group(struct wpa_supplicant *wpa_s,
1940 struct wpa_ssid *ssid)
1942 wpas_notify_persistent_group_removed(wpa_s, ssid);
1944 if (wpa_config_remove_network(wpa_s->conf, ssid->id) < 0) {
1945 wpa_printf(MSG_ERROR, "dbus: %s: "
1946 "error occurred when removing persistent group %d",
1947 __func__, ssid->id);
1954 * wpas_dbus_handler_remove_all_persistent_groups - Remove all configured
1956 * @message: Pointer to incoming dbus message
1957 * @wpa_s: wpa_supplicant structure for a network interface
1958 * Returns: NULL on success or dbus error on failure
1960 * Handler function for "RemoveAllPersistentGroups" method call of a
1961 * P2P Device interface.
1963 DBusMessage * wpas_dbus_handler_remove_all_persistent_groups(
1964 DBusMessage *message, struct wpa_supplicant *wpa_s)
1966 struct wpa_ssid *ssid, *next;
1967 struct wpa_config *config;
1969 config = wpa_s->conf;
1970 ssid = config->ssid;
1973 if (network_is_persistent_group(ssid))
1974 remove_persistent_group(wpa_s, ssid);
1982 * Group object properties accessor methods
1985 dbus_bool_t wpas_dbus_getter_p2p_group_members(DBusMessageIter *iter,
1989 struct wpa_supplicant *wpa_s = user_data;
1990 struct wpa_ssid *ssid;
1991 unsigned int num_members;
1996 dbus_bool_t success = FALSE;
1998 /* Verify correct role for this property */
1999 if (wpas_get_p2p_role(wpa_s) != WPAS_P2P_ROLE_GO) {
2000 return wpas_dbus_simple_array_property_getter(
2001 iter, DBUS_TYPE_OBJECT_PATH, NULL, 0, error);
2004 ssid = wpa_s->conf->ssid;
2005 /* At present WPAS P2P_GO mode only applicable for p2p_go */
2006 if (ssid->mode != WPAS_MODE_P2P_GO &&
2007 ssid->mode != WPAS_MODE_AP &&
2008 ssid->mode != WPAS_MODE_P2P_GROUP_FORMATION)
2011 num_members = p2p_get_group_num_members(wpa_s->p2p_group);
2013 paths = os_calloc(num_members, sizeof(char *));
2018 while ((addr = p2p_iterate_group_members(wpa_s->p2p_group, &next))) {
2019 paths[i] = os_zalloc(WPAS_DBUS_OBJECT_PATH_MAX);
2022 os_snprintf(paths[i], WPAS_DBUS_OBJECT_PATH_MAX,
2023 "%s/" WPAS_DBUS_NEW_P2P_PEERS_PART
2025 wpa_s->parent->dbus_new_path, MAC2STR(addr));
2029 success = wpas_dbus_simple_array_property_getter(iter,
2030 DBUS_TYPE_OBJECT_PATH,
2034 for (i = 0; i < num_members; i++)
2040 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
2042 for (i = 0; i < num_members; i++)
2050 dbus_bool_t wpas_dbus_getter_p2p_group_ssid(DBusMessageIter *iter,
2051 DBusError *error, void *user_data)
2053 struct wpa_supplicant *wpa_s = user_data;
2054 if (wpa_s->current_ssid == NULL)
2056 return wpas_dbus_simple_array_property_getter(
2057 iter, DBUS_TYPE_BYTE, wpa_s->current_ssid->ssid,
2058 wpa_s->current_ssid->ssid_len, error);
2062 dbus_bool_t wpas_dbus_getter_p2p_group_bssid(DBusMessageIter *iter,
2066 struct wpa_supplicant *wpa_s = user_data;
2067 u8 role = wpas_get_p2p_role(wpa_s);
2070 if (role == WPAS_P2P_ROLE_CLIENT) {
2071 if (wpa_s->current_ssid == NULL)
2073 p_bssid = wpa_s->current_ssid->bssid;
2075 if (wpa_s->ap_iface == NULL)
2077 p_bssid = wpa_s->ap_iface->bss[0]->own_addr;
2080 return wpas_dbus_simple_array_property_getter(iter, DBUS_TYPE_BYTE,
2086 dbus_bool_t wpas_dbus_getter_p2p_group_frequency(DBusMessageIter *iter,
2090 struct wpa_supplicant *wpa_s = user_data;
2092 u8 role = wpas_get_p2p_role(wpa_s);
2094 if (role == WPAS_P2P_ROLE_CLIENT) {
2095 if (wpa_s->go_params == NULL)
2097 op_freq = wpa_s->go_params->freq;
2099 if (wpa_s->ap_iface == NULL)
2101 op_freq = wpa_s->ap_iface->freq;
2104 return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_UINT16,
2109 dbus_bool_t wpas_dbus_getter_p2p_group_passphrase(DBusMessageIter *iter,
2113 struct wpa_supplicant *wpa_s = user_data;
2114 u8 role = wpas_get_p2p_role(wpa_s);
2115 char *p_pass = NULL;
2117 /* Verify correct role for this property */
2118 if (role == WPAS_P2P_ROLE_GO) {
2119 if (wpa_s->current_ssid == NULL)
2121 p_pass = wpa_s->current_ssid->passphrase;
2125 return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING,
2131 dbus_bool_t wpas_dbus_getter_p2p_group_psk(DBusMessageIter *iter,
2132 DBusError *error, void *user_data)
2134 struct wpa_supplicant *wpa_s = user_data;
2135 u8 role = wpas_get_p2p_role(wpa_s);
2139 /* Verify correct role for this property */
2140 if (role == WPAS_P2P_ROLE_CLIENT) {
2141 if (wpa_s->current_ssid == NULL)
2143 p_psk = wpa_s->current_ssid->psk;
2147 return wpas_dbus_simple_array_property_getter(iter, DBUS_TYPE_BYTE,
2148 &p_psk, psk_len, error);
2152 dbus_bool_t wpas_dbus_getter_p2p_group_vendor_ext(DBusMessageIter *iter,
2156 struct wpa_supplicant *wpa_s = user_data;
2157 struct hostapd_data *hapd;
2158 struct wpabuf *vendor_ext[MAX_WPS_VENDOR_EXTENSIONS];
2159 unsigned int i, num_vendor_ext = 0;
2161 os_memset(vendor_ext, 0, sizeof(vendor_ext));
2163 /* Verify correct role for this property */
2164 if (wpas_get_p2p_role(wpa_s) == WPAS_P2P_ROLE_GO) {
2165 if (wpa_s->ap_iface == NULL)
2167 hapd = wpa_s->ap_iface->bss[0];
2169 /* Parse WPS Vendor Extensions sent in Beacon/Probe Response */
2170 for (i = 0; i < MAX_WPS_VENDOR_EXTENSIONS; i++) {
2171 if (hapd->conf->wps_vendor_ext[i] == NULL)
2173 vendor_ext[num_vendor_ext++] =
2174 hapd->conf->wps_vendor_ext[i];
2178 /* Return vendor extensions or no data */
2179 return wpas_dbus_simple_array_array_property_getter(iter,
2187 dbus_bool_t wpas_dbus_setter_p2p_group_vendor_ext(DBusMessageIter *iter,
2191 struct wpa_supplicant *wpa_s = user_data;
2192 DBusMessageIter variant_iter, iter_dict, array_iter, sub;
2193 struct wpa_dbus_dict_entry entry = { .type = DBUS_TYPE_STRING };
2195 struct hostapd_data *hapd = NULL;
2197 if (wpas_get_p2p_role(wpa_s) == WPAS_P2P_ROLE_GO &&
2198 wpa_s->ap_iface != NULL)
2199 hapd = wpa_s->ap_iface->bss[0];
2203 dbus_message_iter_recurse(iter, &variant_iter);
2204 if (dbus_message_iter_get_arg_type(&variant_iter) != DBUS_TYPE_ARRAY)
2208 * This is supposed to be array of bytearrays (aay), but the earlier
2209 * implementation used a dict with "WPSVendorExtensions" as the key in
2210 * this setter function which does not match the format used by the
2211 * getter function. For backwards compatibility, allow both formats to
2212 * be used in the setter.
2214 if (dbus_message_iter_get_element_type(&variant_iter) ==
2216 /* This is the proper format matching the getter */
2217 struct wpabuf *vals[MAX_WPS_VENDOR_EXTENSIONS];
2219 dbus_message_iter_recurse(&variant_iter, &array_iter);
2221 if (dbus_message_iter_get_arg_type(&array_iter) !=
2223 dbus_message_iter_get_element_type(&array_iter) !=
2225 wpa_printf(MSG_DEBUG,
2226 "dbus: Not an array of array of bytes");
2231 os_memset(vals, 0, sizeof(vals));
2233 while (dbus_message_iter_get_arg_type(&array_iter) ==
2238 if (i == MAX_WPS_VENDOR_EXTENSIONS) {
2239 wpa_printf(MSG_DEBUG,
2240 "dbus: Too many WPSVendorExtensions values");
2241 i = MAX_WPS_VENDOR_EXTENSIONS + 1;
2245 dbus_message_iter_recurse(&array_iter, &sub);
2246 dbus_message_iter_get_fixed_array(&sub, &val, &len);
2247 wpa_hexdump(MSG_DEBUG, "dbus: WPSVendorExtentions[]",
2249 vals[i] = wpabuf_alloc_copy(val, len);
2250 if (vals[i] == NULL) {
2251 i = MAX_WPS_VENDOR_EXTENSIONS + 1;
2255 dbus_message_iter_next(&array_iter);
2258 if (i > MAX_WPS_VENDOR_EXTENSIONS) {
2259 for (i = 0; i < MAX_WPS_VENDOR_EXTENSIONS; i++)
2260 wpabuf_free(vals[i]);
2264 for (i = 0; i < MAX_WPS_VENDOR_EXTENSIONS; i++) {
2265 wpabuf_free(hapd->conf->wps_vendor_ext[i]);
2266 hapd->conf->wps_vendor_ext[i] = vals[i];
2269 hostapd_update_wps(hapd);
2274 if (dbus_message_iter_get_element_type(&variant_iter) !=
2275 DBUS_TYPE_DICT_ENTRY)
2278 wpa_printf(MSG_DEBUG,
2279 "dbus: Try to use backwards compatibility version of WPSVendorExtensions setter");
2280 if (!wpa_dbus_dict_open_read(&variant_iter, &iter_dict, error))
2283 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
2284 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry)) {
2285 dbus_set_error_const(error, DBUS_ERROR_INVALID_ARGS,
2286 "invalid message format");
2290 if (os_strcmp(entry.key, "WPSVendorExtensions") == 0) {
2291 if (entry.type != DBUS_TYPE_ARRAY ||
2292 entry.array_type != WPAS_DBUS_TYPE_BINARRAY ||
2293 entry.array_len > MAX_WPS_VENDOR_EXTENSIONS)
2296 for (i = 0; i < MAX_WPS_VENDOR_EXTENSIONS; i++) {
2297 wpabuf_free(hapd->conf->wps_vendor_ext[i]);
2298 if (i < entry.array_len) {
2299 hapd->conf->wps_vendor_ext[i] =
2300 entry.binarray_value[i];
2301 entry.binarray_value[i] = NULL;
2303 hapd->conf->wps_vendor_ext[i] = NULL;
2306 hostapd_update_wps(hapd);
2310 wpa_dbus_dict_entry_clear(&entry);
2316 wpa_dbus_dict_entry_clear(&entry);
2317 dbus_set_error_const(error, DBUS_ERROR_INVALID_ARGS,
2318 "invalid message format");
2323 DBusMessage * wpas_dbus_handler_p2p_add_service(DBusMessage *message,
2324 struct wpa_supplicant *wpa_s)
2326 DBusMessageIter iter_dict;
2327 DBusMessage *reply = NULL;
2328 DBusMessageIter iter;
2329 struct wpa_dbus_dict_entry entry;
2332 char *service = NULL;
2333 struct wpabuf *query = NULL;
2334 struct wpabuf *resp = NULL;
2337 dbus_message_iter_init(message, &iter);
2339 if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
2342 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
2343 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
2346 if (!os_strcmp(entry.key, "service_type") &&
2347 (entry.type == DBUS_TYPE_STRING)) {
2348 if (!os_strcmp(entry.str_value, "upnp"))
2350 else if (!os_strcmp(entry.str_value, "bonjour"))
2354 } else if (!os_strcmp(entry.key, "version") &&
2355 entry.type == DBUS_TYPE_INT32) {
2356 version = entry.uint32_value;
2357 } else if (!os_strcmp(entry.key, "service") &&
2358 (entry.type == DBUS_TYPE_STRING)) {
2360 service = os_strdup(entry.str_value);
2361 } else if (!os_strcmp(entry.key, "query")) {
2362 if ((entry.type != DBUS_TYPE_ARRAY) ||
2363 (entry.array_type != DBUS_TYPE_BYTE))
2365 query = wpabuf_alloc_copy(
2366 entry.bytearray_value,
2368 } else if (!os_strcmp(entry.key, "response")) {
2369 if ((entry.type != DBUS_TYPE_ARRAY) ||
2370 (entry.array_type != DBUS_TYPE_BYTE))
2372 resp = wpabuf_alloc_copy(entry.bytearray_value,
2375 wpa_dbus_dict_entry_clear(&entry);
2379 if (version <= 0 || service == NULL)
2382 if (wpas_p2p_service_add_upnp(wpa_s, version, service) != 0)
2385 } else if (bonjour == 1) {
2386 if (query == NULL || resp == NULL)
2389 if (wpas_p2p_service_add_bonjour(wpa_s, query, resp) < 0)
2399 wpa_dbus_dict_entry_clear(&entry);
2404 return wpas_dbus_error_invalid_args(message, NULL);
2408 DBusMessage * wpas_dbus_handler_p2p_delete_service(
2409 DBusMessage *message, struct wpa_supplicant *wpa_s)
2411 DBusMessageIter iter_dict;
2412 DBusMessage *reply = NULL;
2413 DBusMessageIter iter;
2414 struct wpa_dbus_dict_entry entry;
2418 char *service = NULL;
2419 struct wpabuf *query = NULL;
2422 dbus_message_iter_init(message, &iter);
2424 if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
2427 if (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
2428 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
2431 if (!os_strcmp(entry.key, "service_type") &&
2432 (entry.type == DBUS_TYPE_STRING)) {
2433 if (!os_strcmp(entry.str_value, "upnp"))
2435 else if (!os_strcmp(entry.str_value, "bonjour"))
2439 wpa_dbus_dict_entry_clear(&entry);
2443 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
2444 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
2446 if (!os_strcmp(entry.key, "version") &&
2447 entry.type == DBUS_TYPE_INT32)
2448 version = entry.uint32_value;
2449 else if (!os_strcmp(entry.key, "service") &&
2450 entry.type == DBUS_TYPE_STRING) {
2452 service = os_strdup(entry.str_value);
2456 wpa_dbus_dict_entry_clear(&entry);
2459 if (version <= 0 || service == NULL)
2462 ret = wpas_p2p_service_del_upnp(wpa_s, version, service);
2465 } else if (bonjour == 1) {
2466 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
2467 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
2470 if (!os_strcmp(entry.key, "query")) {
2471 if ((entry.type != DBUS_TYPE_ARRAY) ||
2472 (entry.array_type != DBUS_TYPE_BYTE))
2475 query = wpabuf_alloc_copy(
2476 entry.bytearray_value,
2481 wpa_dbus_dict_entry_clear(&entry);
2487 ret = wpas_p2p_service_del_bonjour(wpa_s, query);
2497 wpa_dbus_dict_entry_clear(&entry);
2501 return wpas_dbus_error_invalid_args(message, NULL);
2505 DBusMessage * wpas_dbus_handler_p2p_flush_service(DBusMessage *message,
2506 struct wpa_supplicant *wpa_s)
2508 wpas_p2p_service_flush(wpa_s);
2513 DBusMessage * wpas_dbus_handler_p2p_service_sd_req(
2514 DBusMessage *message, struct wpa_supplicant *wpa_s)
2516 DBusMessageIter iter_dict;
2517 DBusMessage *reply = NULL;
2518 DBusMessageIter iter;
2519 struct wpa_dbus_dict_entry entry;
2521 char *service = NULL;
2522 char *peer_object_path = NULL;
2523 struct wpabuf *tlv = NULL;
2526 u8 addr_buf[ETH_ALEN], *addr;
2528 dbus_message_iter_init(message, &iter);
2530 if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
2533 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
2534 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
2536 if (!os_strcmp(entry.key, "peer_object") &&
2537 entry.type == DBUS_TYPE_OBJECT_PATH) {
2538 peer_object_path = os_strdup(entry.str_value);
2539 } else if (!os_strcmp(entry.key, "service_type") &&
2540 entry.type == DBUS_TYPE_STRING) {
2541 if (!os_strcmp(entry.str_value, "upnp"))
2545 } else if (!os_strcmp(entry.key, "version") &&
2546 entry.type == DBUS_TYPE_INT32) {
2547 version = entry.uint32_value;
2548 } else if (!os_strcmp(entry.key, "service") &&
2549 entry.type == DBUS_TYPE_STRING) {
2550 service = os_strdup(entry.str_value);
2551 } else if (!os_strcmp(entry.key, "tlv")) {
2552 if (entry.type != DBUS_TYPE_ARRAY ||
2553 entry.array_type != DBUS_TYPE_BYTE)
2555 tlv = wpabuf_alloc_copy(entry.bytearray_value,
2560 wpa_dbus_dict_entry_clear(&entry);
2563 if (!peer_object_path) {
2566 if (parse_peer_object_path(peer_object_path, addr_buf) < 0 ||
2567 !p2p_peer_known(wpa_s->global->p2p, addr_buf))
2574 if (version <= 0 || service == NULL)
2577 ref = wpas_p2p_sd_request_upnp(wpa_s, addr, version, service);
2581 ref = wpas_p2p_sd_request(wpa_s, addr, tlv);
2586 reply = dbus_message_new_method_return(message);
2587 dbus_message_append_args(reply, DBUS_TYPE_UINT64,
2588 &ref, DBUS_TYPE_INVALID);
2590 reply = wpas_dbus_error_unknown_error(
2591 message, "Unable to send SD request");
2595 os_free(peer_object_path);
2598 wpa_dbus_dict_entry_clear(&entry);
2602 reply = wpas_dbus_error_invalid_args(message, NULL);
2607 DBusMessage * wpas_dbus_handler_p2p_service_sd_res(
2608 DBusMessage *message, struct wpa_supplicant *wpa_s)
2610 DBusMessageIter iter_dict;
2611 DBusMessage *reply = NULL;
2612 DBusMessageIter iter;
2613 struct wpa_dbus_dict_entry entry;
2614 char *peer_object_path = NULL;
2615 struct wpabuf *tlv = NULL;
2620 dbus_message_iter_init(message, &iter);
2622 if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
2625 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
2626 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
2629 if (!os_strcmp(entry.key, "peer_object") &&
2630 entry.type == DBUS_TYPE_OBJECT_PATH) {
2631 peer_object_path = os_strdup(entry.str_value);
2632 } else if (!os_strcmp(entry.key, "frequency") &&
2633 entry.type == DBUS_TYPE_INT32) {
2634 freq = entry.uint32_value;
2635 } else if (!os_strcmp(entry.key, "dialog_token") &&
2636 (entry.type == DBUS_TYPE_UINT32 ||
2637 entry.type == DBUS_TYPE_INT32)) {
2638 dlg_tok = entry.uint32_value;
2639 } else if (!os_strcmp(entry.key, "tlvs")) {
2640 if (entry.type != DBUS_TYPE_ARRAY ||
2641 entry.array_type != DBUS_TYPE_BYTE)
2643 tlv = wpabuf_alloc_copy(entry.bytearray_value,
2648 wpa_dbus_dict_entry_clear(&entry);
2650 if (parse_peer_object_path(peer_object_path, addr) < 0 ||
2651 !p2p_peer_known(wpa_s->global->p2p, addr) ||
2655 wpas_p2p_sd_response(wpa_s, freq, addr, (u8) dlg_tok, tlv);
2658 os_free(peer_object_path);
2661 wpa_dbus_dict_entry_clear(&entry);
2663 reply = wpas_dbus_error_invalid_args(message, NULL);
2668 DBusMessage * wpas_dbus_handler_p2p_service_sd_cancel_req(
2669 DBusMessage *message, struct wpa_supplicant *wpa_s)
2671 DBusMessageIter iter;
2674 dbus_message_iter_init(message, &iter);
2675 dbus_message_iter_get_basic(&iter, &req);
2680 if (wpas_p2p_sd_cancel_request(wpa_s, req) < 0)
2685 return wpas_dbus_error_invalid_args(message, NULL);
2689 DBusMessage * wpas_dbus_handler_p2p_service_update(
2690 DBusMessage *message, struct wpa_supplicant *wpa_s)
2692 wpas_p2p_sd_service_update(wpa_s);
2697 DBusMessage * wpas_dbus_handler_p2p_serv_disc_external(
2698 DBusMessage *message, struct wpa_supplicant *wpa_s)
2700 DBusMessageIter iter;
2703 dbus_message_iter_init(message, &iter);
2704 dbus_message_iter_get_basic(&iter, &ext);
2706 wpa_s->p2p_sd_over_ctrl_iface = ext;
2713 #ifdef CONFIG_WIFI_DISPLAY
2715 dbus_bool_t wpas_dbus_getter_global_wfd_ies(DBusMessageIter *iter,
2716 DBusError *error, void *user_data)
2718 struct wpa_global *global = user_data;
2722 ie = wifi_display_get_wfd_ie(global);
2724 return wpas_dbus_simple_array_property_getter(iter,
2728 ret = wpas_dbus_simple_array_property_getter(iter, DBUS_TYPE_BYTE,
2730 wpabuf_len(ie), error);
2737 dbus_bool_t wpas_dbus_setter_global_wfd_ies(DBusMessageIter *iter,
2738 DBusError *error, void *user_data)
2740 struct wpa_global *global = user_data;
2741 DBusMessageIter variant, array;
2742 struct wpabuf *ie = NULL;
2746 if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_VARIANT)
2749 dbus_message_iter_recurse(iter, &variant);
2750 if (dbus_message_iter_get_arg_type(&variant) != DBUS_TYPE_ARRAY)
2753 dbus_message_iter_recurse(&variant, &array);
2754 dbus_message_iter_get_fixed_array(&array, &data, &len);
2756 wifi_display_enable(global, 0);
2757 wifi_display_deinit(global);
2762 ie = wpabuf_alloc(len);
2766 wpabuf_put_data(ie, data, len);
2767 if (wifi_display_subelem_set_from_ies(global, ie) != 0)
2770 if (global->wifi_display == 0)
2771 wifi_display_enable(global, 1);
2779 dbus_set_error_const(error, DBUS_ERROR_INVALID_ARGS,
2780 "invalid message format");
2784 #endif /* CONFIG_WIFI_DISPLAY */