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