1 /*
2 * WPA Supplicant / dbus-based control interface (P2P)
3 * Copyright (c) 2011-2012, Intel Corporation
4 *
5 * This software may be distributed under the terms of the BSD license.
6 * See README for more details.
7 */
8
9 #include "includes.h"
10
11 #include "utils/includes.h"
12 #include "common.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"
18 #include "dbus_new.h"
19 #include "dbus_new_handlers.h"
20 #include "dbus_new_handlers_p2p.h"
21 #include "dbus_dict_helpers.h"
22 #include "p2p/p2p.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"
27
28 #include "../p2p_supplicant.h"
29 #include "../wifi_display.h"
30
31 /**
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
37 */
parse_peer_object_path(const char * peer_path,u8 addr[ETH_ALEN])38 static int parse_peer_object_path(const char *peer_path, u8 addr[ETH_ALEN])
39 {
40 const char *p;
41
42 if (!peer_path)
43 return -1;
44 p = os_strrchr(peer_path, '/');
45 if (!p)
46 return -1;
47 p++;
48 return hwaddr_compact_aton(p, addr);
49 }
50
51
52 /**
53 * wpas_dbus_error_persistent_group_unknown - Return a new PersistentGroupUnknown
54 * error message
55 * @message: Pointer to incoming dbus message this error refers to
56 * Returns: a dbus error message
57 *
58 * Convenience function to create and return an invalid persistent group error.
59 */
60 static DBusMessage *
wpas_dbus_error_persistent_group_unknown(DBusMessage * message)61 wpas_dbus_error_persistent_group_unknown(DBusMessage *message)
62 {
63 return dbus_message_new_error(
64 message, WPAS_DBUS_ERROR_NETWORK_UNKNOWN,
65 "There is no such persistent group in this P2P device.");
66 }
67
68
wpas_dbus_handler_p2p_find(DBusMessage * message,struct wpa_supplicant * wpa_s)69 DBusMessage * wpas_dbus_handler_p2p_find(DBusMessage *message,
70 struct wpa_supplicant *wpa_s)
71 {
72 struct wpa_dbus_dict_entry entry;
73 DBusMessage *reply = NULL;
74 DBusMessageIter iter;
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;
79 unsigned int i;
80 u8 *req_dev_types = NULL;
81
82 dbus_message_iter_init(message, &iter);
83 entry.key = NULL;
84
85 if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
86 goto error;
87
88 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
89 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
90 goto error;
91
92 if (os_strcmp(entry.key, "Timeout") == 0 &&
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)
98 goto error_clear;
99
100 os_free(req_dev_types);
101 req_dev_types =
102 os_malloc(WPS_DEV_TYPE_LEN * entry.array_len);
103 if (!req_dev_types)
104 goto error_clear;
105
106 for (i = 0; i < entry.array_len; i++) {
107 if (wpabuf_len(entry.binarray_value[i]) !=
108 WPS_DEV_TYPE_LEN)
109 goto error_clear;
110 os_memcpy(req_dev_types + i * WPS_DEV_TYPE_LEN,
111 wpabuf_head(entry.binarray_value[i]),
112 WPS_DEV_TYPE_LEN);
113 }
114 num_req_dev_types = entry.array_len;
115 } else if (os_strcmp(entry.key, "DiscoveryType") == 0 &&
116 entry.type == DBUS_TYPE_STRING) {
117 if (os_strcmp(entry.str_value, "start_with_full") == 0)
118 type = P2P_FIND_START_WITH_FULL;
119 else if (os_strcmp(entry.str_value, "social") == 0)
120 type = P2P_FIND_ONLY_SOCIAL;
121 else if (os_strcmp(entry.str_value, "progressive") == 0)
122 type = P2P_FIND_PROGRESSIVE;
123 else
124 goto error_clear;
125 } else
126 goto error_clear;
127 wpa_dbus_dict_entry_clear(&entry);
128 }
129
130 wpa_s = wpa_s->global->p2p_init_wpa_s;
131
132 wpas_p2p_find(wpa_s, timeout, type, num_req_dev_types, req_dev_types,
133 NULL, 0, 0, NULL, 0);
134 os_free(req_dev_types);
135 return reply;
136
137 error_clear:
138 wpa_dbus_dict_entry_clear(&entry);
139 error:
140 os_free(req_dev_types);
141 reply = wpas_dbus_error_invalid_args(message, entry.key);
142 return reply;
143 }
144
145
wpas_dbus_handler_p2p_stop_find(DBusMessage * message,struct wpa_supplicant * wpa_s)146 DBusMessage * wpas_dbus_handler_p2p_stop_find(DBusMessage *message,
147 struct wpa_supplicant *wpa_s)
148 {
149 wpas_p2p_stop_find(wpa_s->global->p2p_init_wpa_s);
150 return NULL;
151 }
152
153
wpas_dbus_handler_p2p_rejectpeer(DBusMessage * message,struct wpa_supplicant * wpa_s)154 DBusMessage * wpas_dbus_handler_p2p_rejectpeer(DBusMessage *message,
155 struct wpa_supplicant *wpa_s)
156 {
157 DBusMessageIter iter;
158 char *peer_object_path = NULL;
159 u8 peer_addr[ETH_ALEN];
160
161 dbus_message_iter_init(message, &iter);
162 dbus_message_iter_get_basic(&iter, &peer_object_path);
163
164 if (parse_peer_object_path(peer_object_path, peer_addr) < 0)
165 return wpas_dbus_error_invalid_args(message, NULL);
166
167 wpa_s = wpa_s->global->p2p_init_wpa_s;
168
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.");
172
173 return NULL;
174 }
175
176
wpas_dbus_handler_p2p_listen(DBusMessage * message,struct wpa_supplicant * wpa_s)177 DBusMessage * wpas_dbus_handler_p2p_listen(DBusMessage *message,
178 struct wpa_supplicant *wpa_s)
179 {
180 dbus_int32_t timeout = 0;
181
182 if (!dbus_message_get_args(message, NULL, DBUS_TYPE_INT32, &timeout,
183 DBUS_TYPE_INVALID))
184 return wpas_dbus_error_no_memory(message);
185
186 wpa_s = wpa_s->global->p2p_init_wpa_s;
187
188 if (wpas_p2p_listen(wpa_s, (unsigned int) timeout)) {
189 return dbus_message_new_error(message,
190 WPAS_DBUS_ERROR_UNKNOWN_ERROR,
191 "Could not start P2P listen");
192 }
193
194 return NULL;
195 }
196
197
wpas_dbus_handler_p2p_extendedlisten(DBusMessage * message,struct wpa_supplicant * wpa_s)198 DBusMessage * wpas_dbus_handler_p2p_extendedlisten(
199 DBusMessage *message, struct wpa_supplicant *wpa_s)
200 {
201 unsigned int period = 0, interval = 0;
202 struct wpa_dbus_dict_entry entry;
203 DBusMessageIter iter;
204 DBusMessageIter iter_dict;
205
206 dbus_message_iter_init(message, &iter);
207 entry.key = NULL;
208
209 if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
210 goto error;
211
212 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
213 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
214 goto error;
215
216 if (os_strcmp(entry.key, "period") == 0 &&
217 entry.type == DBUS_TYPE_INT32)
218 period = entry.uint32_value;
219 else if (os_strcmp(entry.key, "interval") == 0 &&
220 entry.type == DBUS_TYPE_INT32)
221 interval = entry.uint32_value;
222 else
223 goto error_clear;
224 wpa_dbus_dict_entry_clear(&entry);
225 }
226
227 wpa_s = wpa_s->global->p2p_init_wpa_s;
228
229 if (wpas_p2p_ext_listen(wpa_s, period, interval))
230 return wpas_dbus_error_unknown_error(
231 message, "failed to initiate a p2p_ext_listen.");
232
233 return NULL;
234
235 error_clear:
236 wpa_dbus_dict_entry_clear(&entry);
237 error:
238 return wpas_dbus_error_invalid_args(message, entry.key);
239 }
240
241
wpas_dbus_handler_p2p_presence_request(DBusMessage * message,struct wpa_supplicant * wpa_s)242 DBusMessage * wpas_dbus_handler_p2p_presence_request(
243 DBusMessage *message, struct wpa_supplicant *wpa_s)
244 {
245 unsigned int dur1 = 0, int1 = 0, dur2 = 0, int2 = 0;
246 struct wpa_dbus_dict_entry entry;
247 DBusMessageIter iter;
248 DBusMessageIter iter_dict;
249
250 dbus_message_iter_init(message, &iter);
251 entry.key = NULL;
252
253 if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
254 goto error;
255
256 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
257 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
258 goto error;
259
260 if (os_strcmp(entry.key, "duration1") == 0 &&
261 entry.type == DBUS_TYPE_INT32)
262 dur1 = entry.uint32_value;
263 else if (os_strcmp(entry.key, "interval1") == 0 &&
264 entry.type == DBUS_TYPE_INT32)
265 int1 = entry.uint32_value;
266 else if (os_strcmp(entry.key, "duration2") == 0 &&
267 entry.type == DBUS_TYPE_INT32)
268 dur2 = entry.uint32_value;
269 else if (os_strcmp(entry.key, "interval2") == 0 &&
270 entry.type == DBUS_TYPE_INT32)
271 int2 = entry.uint32_value;
272 else
273 goto error_clear;
274
275 wpa_dbus_dict_entry_clear(&entry);
276 }
277
278 if (wpas_p2p_presence_req(wpa_s, dur1, int1, dur2, int2) < 0)
279 return wpas_dbus_error_unknown_error(message,
280 "Failed to invoke presence request.");
281
282 return NULL;
283
284 error_clear:
285 wpa_dbus_dict_entry_clear(&entry);
286 error:
287 return wpas_dbus_error_invalid_args(message, entry.key);
288 }
289
290
wpas_dbus_handler_p2p_group_add(DBusMessage * message,struct wpa_supplicant * wpa_s)291 DBusMessage * wpas_dbus_handler_p2p_group_add(DBusMessage *message,
292 struct wpa_supplicant *wpa_s)
293 {
294 DBusMessageIter iter_dict;
295 DBusMessage *reply = NULL;
296 DBusMessageIter iter;
297 struct wpa_dbus_dict_entry entry;
298 char *pg_object_path = NULL;
299 int persistent_group = 0;
300 int freq = 0;
301 char *iface = NULL;
302 unsigned int group_id = 0;
303 struct wpa_ssid *ssid;
304
305 dbus_message_iter_init(message, &iter);
306
307 if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
308 goto inv_args;
309
310 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
311 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
312 goto inv_args;
313
314 if (os_strcmp(entry.key, "persistent") == 0 &&
315 entry.type == DBUS_TYPE_BOOLEAN) {
316 persistent_group = entry.bool_value;
317 } else if (os_strcmp(entry.key, "frequency") == 0 &&
318 entry.type == DBUS_TYPE_INT32) {
319 freq = entry.int32_value;
320 if (freq <= 0)
321 goto inv_args_clear;
322 } else if (os_strcmp(entry.key, "persistent_group_object") ==
323 0 &&
324 entry.type == DBUS_TYPE_OBJECT_PATH)
325 pg_object_path = os_strdup(entry.str_value);
326 else
327 goto inv_args_clear;
328
329 wpa_dbus_dict_entry_clear(&entry);
330 }
331
332 wpa_s = wpa_s->global->p2p_init_wpa_s;
333
334 if (pg_object_path != NULL) {
335 char *net_id_str;
336
337 /*
338 * A persistent group Object Path is defined meaning we want
339 * to re-invoke a persistent group.
340 */
341
342 iface = wpas_dbus_new_decompose_object_path(
343 pg_object_path, WPAS_DBUS_NEW_PERSISTENT_GROUPS_PART,
344 &net_id_str);
345 if (iface == NULL || net_id_str == NULL ||
346 !wpa_s->parent->dbus_new_path ||
347 os_strcmp(iface, wpa_s->parent->dbus_new_path) != 0) {
348 reply =
349 wpas_dbus_error_invalid_args(message,
350 pg_object_path);
351 goto out;
352 }
353
354 group_id = strtoul(net_id_str, NULL, 10);
355 if (errno == EINVAL) {
356 reply = wpas_dbus_error_invalid_args(
357 message, pg_object_path);
358 goto out;
359 }
360
361 /* Get the SSID structure from the persistent group id */
362 ssid = wpa_config_get_network(wpa_s->conf, group_id);
363 if (ssid == NULL || ssid->disabled != 2)
364 goto inv_args;
365
366 if (wpas_p2p_group_add_persistent(wpa_s, ssid, 0, freq, 0, 0, 0,
367 0, 0, NULL, 0, 0)) {
368 reply = wpas_dbus_error_unknown_error(
369 message,
370 "Failed to reinvoke a persistent group");
371 goto out;
372 }
373 } else if (wpas_p2p_group_add(wpa_s, persistent_group, freq, 0, 0, 0,
374 0))
375 goto inv_args;
376
377 out:
378 os_free(pg_object_path);
379 os_free(iface);
380 return reply;
381 inv_args_clear:
382 wpa_dbus_dict_entry_clear(&entry);
383 inv_args:
384 reply = wpas_dbus_error_invalid_args(message, NULL);
385 goto out;
386 }
387
388
wpas_dbus_handler_p2p_disconnect(DBusMessage * message,struct wpa_supplicant * wpa_s)389 DBusMessage * wpas_dbus_handler_p2p_disconnect(DBusMessage *message,
390 struct wpa_supplicant *wpa_s)
391 {
392 if (wpas_p2p_disconnect(wpa_s))
393 return wpas_dbus_error_unknown_error(message,
394 "failed to disconnect");
395
396 return NULL;
397 }
398
399
wpa_dbus_p2p_check_enabled(struct wpa_supplicant * wpa_s,DBusMessage * message,DBusMessage ** out_reply,DBusError * error)400 static dbus_bool_t wpa_dbus_p2p_check_enabled(struct wpa_supplicant *wpa_s,
401 DBusMessage *message,
402 DBusMessage **out_reply,
403 DBusError *error)
404 {
405 /* Return an error message or an error if P2P isn't available */
406 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL) {
407 if (out_reply) {
408 *out_reply = dbus_message_new_error(
409 message, DBUS_ERROR_FAILED,
410 "P2P is not available for this interface");
411 }
412 dbus_set_error_const(error, DBUS_ERROR_FAILED,
413 "P2P is not available for this interface");
414 return FALSE;
415 }
416 return TRUE;
417 }
418
419
wpas_dbus_handler_p2p_remove_client(DBusMessage * message,struct wpa_supplicant * wpa_s)420 DBusMessage * wpas_dbus_handler_p2p_remove_client(DBusMessage *message,
421 struct wpa_supplicant *wpa_s)
422 {
423 DBusMessageIter iter_dict;
424 DBusMessage *reply = NULL;
425 DBusMessageIter iter;
426 struct wpa_dbus_dict_entry entry;
427 char *peer_object_path = NULL;
428 char *interface_addr = NULL;
429 u8 peer_addr[ETH_ALEN];
430
431 if (!wpa_dbus_p2p_check_enabled(wpa_s, message, &reply, NULL))
432 return reply;
433
434 dbus_message_iter_init(message, &iter);
435
436 if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
437 goto err;
438
439 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
440 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
441 goto err;
442
443 if (os_strcmp(entry.key, "peer") == 0 &&
444 entry.type == DBUS_TYPE_OBJECT_PATH) {
445 os_free(peer_object_path);
446 peer_object_path = os_strdup(entry.str_value);
447 wpa_dbus_dict_entry_clear(&entry);
448 } else if (os_strcmp(entry.key, "iface") == 0 &&
449 entry.type == DBUS_TYPE_STRING) {
450 os_free(interface_addr);
451 interface_addr = os_strdup(entry.str_value);
452 wpa_dbus_dict_entry_clear(&entry);
453 } else {
454 wpa_dbus_dict_entry_clear(&entry);
455 goto err;
456 }
457 }
458
459 if ((!peer_object_path && !interface_addr) ||
460 (peer_object_path &&
461 (parse_peer_object_path(peer_object_path, peer_addr) < 0 ||
462 !p2p_peer_known(wpa_s->global->p2p, peer_addr))) ||
463 (interface_addr && hwaddr_aton(interface_addr, peer_addr) < 0))
464 goto err;
465
466 wpas_p2p_remove_client(wpa_s, peer_addr, interface_addr != NULL);
467 reply = NULL;
468 out:
469 os_free(peer_object_path);
470 os_free(interface_addr);
471 return reply;
472 err:
473 reply = wpas_dbus_error_invalid_args(message, "Invalid address format");
474 goto out;
475 }
476
477
wpas_dbus_handler_p2p_flush(DBusMessage * message,struct wpa_supplicant * wpa_s)478 DBusMessage * wpas_dbus_handler_p2p_flush(DBusMessage *message,
479 struct wpa_supplicant *wpa_s)
480 {
481 DBusMessage *reply = NULL;
482
483 if (!wpa_dbus_p2p_check_enabled(wpa_s, message, &reply, NULL))
484 return reply;
485
486 wpa_s = wpa_s->global->p2p_init_wpa_s;
487
488 os_memset(wpa_s->p2p_auth_invite, 0, ETH_ALEN);
489 wpa_s->force_long_sd = 0;
490 p2p_flush(wpa_s->global->p2p);
491
492 return NULL;
493 }
494
495
wpas_dbus_handler_p2p_connect(DBusMessage * message,struct wpa_supplicant * wpa_s)496 DBusMessage * wpas_dbus_handler_p2p_connect(DBusMessage *message,
497 struct wpa_supplicant *wpa_s)
498 {
499 DBusMessageIter iter_dict;
500 DBusMessage *reply = NULL;
501 DBusMessageIter iter;
502 struct wpa_dbus_dict_entry entry;
503 char *peer_object_path = NULL;
504 int persistent_group = 0;
505 int join = 0;
506 int authorize_only = 0;
507 int go_intent = -1;
508 int freq = 0;
509 u8 addr[ETH_ALEN];
510 char *pin = NULL;
511 enum p2p_wps_method wps_method = WPS_NOT_READY;
512 int new_pin;
513 char *err_msg = NULL;
514 char *iface = NULL;
515
516 if (!wpa_dbus_p2p_check_enabled(wpa_s, message, &reply, NULL))
517 return reply;
518
519 dbus_message_iter_init(message, &iter);
520
521 if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
522 goto inv_args;
523
524 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
525 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
526 goto inv_args;
527
528 if (os_strcmp(entry.key, "peer") == 0 &&
529 entry.type == DBUS_TYPE_OBJECT_PATH) {
530 peer_object_path = os_strdup(entry.str_value);
531 } else if (os_strcmp(entry.key, "persistent") == 0 &&
532 entry.type == DBUS_TYPE_BOOLEAN) {
533 persistent_group = entry.bool_value;
534 } else if (os_strcmp(entry.key, "join") == 0 &&
535 entry.type == DBUS_TYPE_BOOLEAN) {
536 join = entry.bool_value;
537 } else if (os_strcmp(entry.key, "authorize_only") == 0 &&
538 entry.type == DBUS_TYPE_BOOLEAN) {
539 authorize_only = entry.bool_value;
540 } else if (os_strcmp(entry.key, "frequency") == 0 &&
541 entry.type == DBUS_TYPE_INT32) {
542 freq = entry.int32_value;
543 if (freq <= 0)
544 goto inv_args_clear;
545 } else if (os_strcmp(entry.key, "go_intent") == 0 &&
546 entry.type == DBUS_TYPE_INT32) {
547 go_intent = entry.int32_value;
548 if ((go_intent < 0) || (go_intent > 15))
549 goto inv_args_clear;
550 } else if (os_strcmp(entry.key, "wps_method") == 0 &&
551 entry.type == DBUS_TYPE_STRING) {
552 if (os_strcmp(entry.str_value, "pbc") == 0)
553 wps_method = WPS_PBC;
554 else if (os_strcmp(entry.str_value, "pin") == 0)
555 wps_method = WPS_PIN_DISPLAY;
556 else if (os_strcmp(entry.str_value, "display") == 0)
557 wps_method = WPS_PIN_DISPLAY;
558 else if (os_strcmp(entry.str_value, "keypad") == 0)
559 wps_method = WPS_PIN_KEYPAD;
560 else
561 goto inv_args_clear;
562 } else if (os_strcmp(entry.key, "pin") == 0 &&
563 entry.type == DBUS_TYPE_STRING) {
564 pin = os_strdup(entry.str_value);
565 } else
566 goto inv_args_clear;
567
568 wpa_dbus_dict_entry_clear(&entry);
569 }
570
571 if (wps_method == WPS_NOT_READY ||
572 parse_peer_object_path(peer_object_path, addr) < 0 ||
573 !p2p_peer_known(wpa_s->global->p2p, addr))
574 goto inv_args;
575
576 /*
577 * Validate the wps_method specified and the pin value.
578 */
579 if ((!pin || !pin[0]) && wps_method == WPS_PIN_KEYPAD)
580 goto inv_args;
581
582 wpa_s = wpa_s->global->p2p_init_wpa_s;
583
584 new_pin = wpas_p2p_connect(wpa_s, addr, pin, wps_method,
585 persistent_group, 0, join, authorize_only,
586 go_intent, freq, 0, -1, 0, 0, 0, 0, NULL, 0);
587
588 if (new_pin >= 0) {
589 char npin[9];
590 char *generated_pin;
591
592 os_snprintf(npin, sizeof(npin), "%08d", new_pin);
593 generated_pin = npin;
594 reply = dbus_message_new_method_return(message);
595 dbus_message_append_args(reply, DBUS_TYPE_STRING,
596 &generated_pin, DBUS_TYPE_INVALID);
597 } else {
598 switch (new_pin) {
599 case -2:
600 err_msg =
601 "connect failed due to channel unavailability.";
602 iface = WPAS_DBUS_ERROR_CONNECT_CHANNEL_UNAVAILABLE;
603 break;
604
605 case -3:
606 err_msg = "connect failed due to unsupported channel.";
607 iface = WPAS_DBUS_ERROR_CONNECT_CHANNEL_UNSUPPORTED;
608 break;
609
610 default:
611 err_msg = "connect failed due to unspecified error.";
612 iface = WPAS_DBUS_ERROR_CONNECT_UNSPECIFIED_ERROR;
613 break;
614 }
615
616 /*
617 * TODO:
618 * Do we need specialized errors corresponding to above
619 * error conditions as against just returning a different
620 * error message?
621 */
622 reply = dbus_message_new_error(message, iface, err_msg);
623 }
624
625 out:
626 os_free(peer_object_path);
627 os_free(pin);
628 return reply;
629 inv_args_clear:
630 wpa_dbus_dict_entry_clear(&entry);
631 inv_args:
632 reply = wpas_dbus_error_invalid_args(message, NULL);
633 goto out;
634 }
635
636
637 /**
638 * wpas_dbus_handler_p2p_cancel - Cancel P2P group formation
639 * @message: Pointer to incoming dbus message
640 * @wpa_s: %wpa_supplicant data structure
641 * Returns: NULL on success or DBus error on failure
642 *
643 * Handler for "Cancel" method call. Returns NULL if P2P cancel succeeds or DBus
644 * error on P2P cancel failure
645 */
wpas_dbus_handler_p2p_cancel(DBusMessage * message,struct wpa_supplicant * wpa_s)646 DBusMessage * wpas_dbus_handler_p2p_cancel(DBusMessage *message,
647 struct wpa_supplicant *wpa_s)
648 {
649 if (wpas_p2p_cancel(wpa_s))
650 return wpas_dbus_error_unknown_error(message,
651 "P2P cancel failed");
652
653 return NULL;
654 }
655
656
wpas_dbus_handler_p2p_invite(DBusMessage * message,struct wpa_supplicant * wpa_s)657 DBusMessage * wpas_dbus_handler_p2p_invite(DBusMessage *message,
658 struct wpa_supplicant *wpa_s)
659 {
660 DBusMessageIter iter_dict;
661 DBusMessage *reply = NULL;
662 DBusMessageIter iter;
663 struct wpa_dbus_dict_entry entry;
664 char *peer_object_path = NULL;
665 char *pg_object_path = NULL;
666 char *iface = NULL;
667 u8 peer_addr[ETH_ALEN];
668 unsigned int group_id = 0;
669 int persistent = 0;
670 struct wpa_ssid *ssid;
671
672 if (!wpa_dbus_p2p_check_enabled(wpa_s, message, &reply, NULL))
673 return reply;
674
675 dbus_message_iter_init(message, &iter);
676
677 if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
678 goto err;
679
680 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
681 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
682 goto err;
683
684 if (os_strcmp(entry.key, "peer") == 0 &&
685 entry.type == DBUS_TYPE_OBJECT_PATH) {
686 peer_object_path = os_strdup(entry.str_value);
687 wpa_dbus_dict_entry_clear(&entry);
688 } else if (os_strcmp(entry.key, "persistent_group_object") ==
689 0 &&
690 entry.type == DBUS_TYPE_OBJECT_PATH) {
691 pg_object_path = os_strdup(entry.str_value);
692 persistent = 1;
693 wpa_dbus_dict_entry_clear(&entry);
694 } else {
695 wpa_dbus_dict_entry_clear(&entry);
696 goto err;
697 }
698 }
699
700 if (parse_peer_object_path(peer_object_path, peer_addr) < 0 ||
701 !p2p_peer_known(wpa_s->global->p2p, peer_addr))
702 goto err;
703
704 wpa_s = wpa_s->global->p2p_init_wpa_s;
705
706 if (persistent) {
707 char *net_id_str;
708 /*
709 * A group ID is defined meaning we want to re-invoke a
710 * persistent group
711 */
712
713 iface = wpas_dbus_new_decompose_object_path(
714 pg_object_path,
715 WPAS_DBUS_NEW_PERSISTENT_GROUPS_PART,
716 &net_id_str);
717 if (iface == NULL || net_id_str == NULL ||
718 !wpa_s->parent->dbus_new_path ||
719 os_strcmp(iface, wpa_s->parent->dbus_new_path) != 0) {
720 reply = wpas_dbus_error_invalid_args(message,
721 pg_object_path);
722 goto out;
723 }
724
725 group_id = strtoul(net_id_str, NULL, 10);
726 if (errno == EINVAL) {
727 reply = wpas_dbus_error_invalid_args(
728 message, pg_object_path);
729 goto out;
730 }
731
732 /* Get the SSID structure from the persistent group id */
733 ssid = wpa_config_get_network(wpa_s->conf, group_id);
734 if (ssid == NULL || ssid->disabled != 2)
735 goto err;
736
737 if (wpas_p2p_invite(wpa_s, peer_addr, ssid, NULL, 0, 0, 0, 0, 0,
738 0) < 0) {
739 reply = wpas_dbus_error_unknown_error(
740 message,
741 "Failed to reinvoke a persistent group");
742 goto out;
743 }
744 } else {
745 /*
746 * No group ID means propose to a peer to join my active group
747 */
748 if (wpas_p2p_invite_group(wpa_s, wpa_s->ifname,
749 peer_addr, NULL)) {
750 reply = wpas_dbus_error_unknown_error(
751 message, "Failed to join to an active group");
752 goto out;
753 }
754 }
755
756 out:
757 os_free(iface);
758 os_free(pg_object_path);
759 os_free(peer_object_path);
760 return reply;
761
762 err:
763 reply = wpas_dbus_error_invalid_args(message, NULL);
764 goto out;
765 }
766
767
wpas_dbus_handler_p2p_prov_disc_req(DBusMessage * message,struct wpa_supplicant * wpa_s)768 DBusMessage * wpas_dbus_handler_p2p_prov_disc_req(DBusMessage *message,
769 struct wpa_supplicant *wpa_s)
770 {
771 DBusMessageIter iter;
772 char *peer_object_path = NULL;
773 char *config_method = NULL;
774 u8 peer_addr[ETH_ALEN];
775
776 dbus_message_iter_init(message, &iter);
777 dbus_message_iter_get_basic(&iter, &peer_object_path);
778
779 if (parse_peer_object_path(peer_object_path, peer_addr) < 0)
780 return wpas_dbus_error_invalid_args(message, NULL);
781
782 dbus_message_iter_next(&iter);
783 dbus_message_iter_get_basic(&iter, &config_method);
784
785 /*
786 * Validation checks on config_method are being duplicated here
787 * to be able to return invalid args reply since the error code
788 * from p2p module are not granular enough (yet).
789 */
790 if (os_strcmp(config_method, "display") &&
791 os_strcmp(config_method, "keypad") &&
792 os_strcmp(config_method, "pbc") &&
793 os_strcmp(config_method, "pushbutton"))
794 return wpas_dbus_error_invalid_args(message, NULL);
795
796 wpa_s = wpa_s->global->p2p_init_wpa_s;
797
798 if (wpas_p2p_prov_disc(wpa_s, peer_addr, config_method,
799 WPAS_P2P_PD_FOR_GO_NEG, NULL) < 0)
800 return wpas_dbus_error_unknown_error(message,
801 "Failed to send provision discovery request");
802
803 return NULL;
804 }
805
806
807 /*
808 * P2P Device property accessor methods.
809 */
810
wpas_dbus_getter_p2p_device_config(const struct wpa_dbus_property_desc * property_desc,DBusMessageIter * iter,DBusError * error,void * user_data)811 dbus_bool_t wpas_dbus_getter_p2p_device_config(
812 const struct wpa_dbus_property_desc *property_desc,
813 DBusMessageIter *iter, DBusError *error, void *user_data)
814 {
815 struct wpa_supplicant *wpa_s = user_data;
816 DBusMessageIter variant_iter, dict_iter;
817 DBusMessageIter iter_secdev_dict_entry, iter_secdev_dict_val,
818 iter_secdev_dict_array;
819 const char *dev_name;
820 int num_vendor_extensions = 0;
821 int i;
822 const struct wpabuf *vendor_ext[P2P_MAX_WPS_VENDOR_EXT];
823
824 if (!wpa_dbus_p2p_check_enabled(wpa_s, NULL, NULL, error))
825 return FALSE;
826
827 wpa_s = wpa_s->global->p2p_init_wpa_s;
828
829 if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
830 "a{sv}", &variant_iter) ||
831 !wpa_dbus_dict_open_write(&variant_iter, &dict_iter))
832 goto err_no_mem;
833
834 /* DeviceName */
835 dev_name = wpa_s->conf->device_name;
836 if (dev_name &&
837 !wpa_dbus_dict_append_string(&dict_iter, "DeviceName", dev_name))
838 goto err_no_mem;
839
840 /* Primary device type */
841 if (!wpa_dbus_dict_append_byte_array(&dict_iter, "PrimaryDeviceType",
842 (char *) wpa_s->conf->device_type,
843 WPS_DEV_TYPE_LEN))
844 goto err_no_mem;
845
846 /* Secondary device types */
847 if (wpa_s->conf->num_sec_device_types) {
848 if (!wpa_dbus_dict_begin_array(&dict_iter,
849 "SecondaryDeviceTypes",
850 DBUS_TYPE_ARRAY_AS_STRING
851 DBUS_TYPE_BYTE_AS_STRING,
852 &iter_secdev_dict_entry,
853 &iter_secdev_dict_val,
854 &iter_secdev_dict_array))
855 goto err_no_mem;
856
857 for (i = 0; i < wpa_s->conf->num_sec_device_types; i++)
858 wpa_dbus_dict_bin_array_add_element(
859 &iter_secdev_dict_array,
860 wpa_s->conf->sec_device_type[i],
861 WPS_DEV_TYPE_LEN);
862
863 if (!wpa_dbus_dict_end_array(&dict_iter,
864 &iter_secdev_dict_entry,
865 &iter_secdev_dict_val,
866 &iter_secdev_dict_array))
867 goto err_no_mem;
868 }
869
870 /* Vendor Extensions */
871 for (i = 0; i < P2P_MAX_WPS_VENDOR_EXT; i++) {
872 if (wpa_s->conf->wps_vendor_ext[i] == NULL)
873 continue;
874 vendor_ext[num_vendor_extensions++] =
875 wpa_s->conf->wps_vendor_ext[i];
876 }
877
878 if ((num_vendor_extensions &&
879 !wpa_dbus_dict_append_wpabuf_array(&dict_iter,
880 "VendorExtension",
881 vendor_ext,
882 num_vendor_extensions)) ||
883 !wpa_dbus_dict_append_uint32(&dict_iter, "GOIntent",
884 wpa_s->conf->p2p_go_intent) ||
885 !wpa_dbus_dict_append_bool(&dict_iter, "PersistentReconnect",
886 wpa_s->conf->persistent_reconnect) ||
887 !wpa_dbus_dict_append_uint32(&dict_iter, "ListenRegClass",
888 wpa_s->conf->p2p_listen_reg_class) ||
889 !wpa_dbus_dict_append_uint32(&dict_iter, "ListenChannel",
890 wpa_s->conf->p2p_listen_channel) ||
891 !wpa_dbus_dict_append_uint32(&dict_iter, "OperRegClass",
892 wpa_s->conf->p2p_oper_reg_class) ||
893 !wpa_dbus_dict_append_uint32(&dict_iter, "OperChannel",
894 wpa_s->conf->p2p_oper_channel) ||
895 (wpa_s->conf->p2p_ssid_postfix &&
896 !wpa_dbus_dict_append_string(&dict_iter, "SsidPostfix",
897 wpa_s->conf->p2p_ssid_postfix)) ||
898 !wpa_dbus_dict_append_bool(&dict_iter, "IntraBss",
899 wpa_s->conf->p2p_intra_bss) ||
900 !wpa_dbus_dict_append_uint32(&dict_iter, "GroupIdle",
901 wpa_s->conf->p2p_group_idle) ||
902 !wpa_dbus_dict_append_uint32(&dict_iter, "disassoc_low_ack",
903 wpa_s->conf->disassoc_low_ack) ||
904 !wpa_dbus_dict_append_bool(&dict_iter, "NoGroupIface",
905 wpa_s->conf->p2p_no_group_iface) ||
906 !wpa_dbus_dict_append_uint32(&dict_iter, "p2p_search_delay",
907 wpa_s->conf->p2p_search_delay) ||
908 !wpa_dbus_dict_close_write(&variant_iter, &dict_iter) ||
909 !dbus_message_iter_close_container(iter, &variant_iter))
910 goto err_no_mem;
911
912 return TRUE;
913
914 err_no_mem:
915 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
916 return FALSE;
917 }
918
919
wpas_dbus_setter_p2p_device_config(const struct wpa_dbus_property_desc * property_desc,DBusMessageIter * iter,DBusError * error,void * user_data)920 dbus_bool_t wpas_dbus_setter_p2p_device_config(
921 const struct wpa_dbus_property_desc *property_desc,
922 DBusMessageIter *iter, DBusError *error, void *user_data)
923 {
924 struct wpa_supplicant *wpa_s = user_data;
925 DBusMessageIter variant_iter, iter_dict;
926 struct wpa_dbus_dict_entry entry = {.type = DBUS_TYPE_STRING };
927 unsigned int i;
928
929 if (!wpa_dbus_p2p_check_enabled(wpa_s, NULL, NULL, error))
930 return FALSE;
931
932 wpa_s = wpa_s->global->p2p_init_wpa_s;
933
934 dbus_message_iter_recurse(iter, &variant_iter);
935 if (!wpa_dbus_dict_open_read(&variant_iter, &iter_dict, error))
936 return FALSE;
937
938 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
939 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry)) {
940 dbus_set_error_const(error, DBUS_ERROR_INVALID_ARGS,
941 "invalid message format");
942 return FALSE;
943 }
944
945 if (os_strcmp(entry.key, "DeviceName") == 0) {
946 char *devname;
947
948 if (entry.type != DBUS_TYPE_STRING ||
949 os_strlen(entry.str_value) > WPS_DEV_NAME_MAX_LEN)
950 goto error;
951
952 devname = os_strdup(entry.str_value);
953 if (devname == NULL)
954 goto err_no_mem_clear;
955
956 os_free(wpa_s->conf->device_name);
957 wpa_s->conf->device_name = devname;
958
959 wpa_s->conf->changed_parameters |=
960 CFG_CHANGED_DEVICE_NAME;
961 } else if (os_strcmp(entry.key, "PrimaryDeviceType") == 0) {
962 if (entry.type != DBUS_TYPE_ARRAY ||
963 entry.array_type != DBUS_TYPE_BYTE ||
964 entry.array_len != WPS_DEV_TYPE_LEN)
965 goto error;
966
967 os_memcpy(wpa_s->conf->device_type,
968 entry.bytearray_value,
969 WPS_DEV_TYPE_LEN);
970 wpa_s->conf->changed_parameters |=
971 CFG_CHANGED_DEVICE_TYPE;
972 } else if (os_strcmp(entry.key, "SecondaryDeviceTypes") == 0) {
973 if (entry.type != DBUS_TYPE_ARRAY ||
974 entry.array_type != WPAS_DBUS_TYPE_BINARRAY ||
975 entry.array_len > MAX_SEC_DEVICE_TYPES)
976 goto error;
977
978 for (i = 0; i < entry.array_len; i++)
979 if (wpabuf_len(entry.binarray_value[i]) !=
980 WPS_DEV_TYPE_LEN)
981 goto err_no_mem_clear;
982 for (i = 0; i < entry.array_len; i++)
983 os_memcpy(wpa_s->conf->sec_device_type[i],
984 wpabuf_head(entry.binarray_value[i]),
985 WPS_DEV_TYPE_LEN);
986 wpa_s->conf->num_sec_device_types = entry.array_len;
987 wpa_s->conf->changed_parameters |=
988 CFG_CHANGED_SEC_DEVICE_TYPE;
989 } else if (os_strcmp(entry.key, "VendorExtension") == 0) {
990 if (entry.type != DBUS_TYPE_ARRAY ||
991 entry.array_type != WPAS_DBUS_TYPE_BINARRAY ||
992 (entry.array_len > P2P_MAX_WPS_VENDOR_EXT))
993 goto error;
994
995 wpa_s->conf->changed_parameters |=
996 CFG_CHANGED_VENDOR_EXTENSION;
997
998 for (i = 0; i < P2P_MAX_WPS_VENDOR_EXT; i++) {
999 wpabuf_free(wpa_s->conf->wps_vendor_ext[i]);
1000 if (i < entry.array_len) {
1001 wpa_s->conf->wps_vendor_ext[i] =
1002 entry.binarray_value[i];
1003 entry.binarray_value[i] = NULL;
1004 } else
1005 wpa_s->conf->wps_vendor_ext[i] = NULL;
1006 }
1007 } else if (os_strcmp(entry.key, "GOIntent") == 0 &&
1008 entry.type == DBUS_TYPE_UINT32 &&
1009 (entry.uint32_value <= 15))
1010 wpa_s->conf->p2p_go_intent = entry.uint32_value;
1011 else if (os_strcmp(entry.key, "PersistentReconnect") == 0 &&
1012 entry.type == DBUS_TYPE_BOOLEAN)
1013 wpa_s->conf->persistent_reconnect = entry.bool_value;
1014 else if (os_strcmp(entry.key, "ListenRegClass") == 0 &&
1015 entry.type == DBUS_TYPE_UINT32) {
1016 wpa_s->conf->p2p_listen_reg_class = entry.uint32_value;
1017 wpa_s->conf->changed_parameters |=
1018 CFG_CHANGED_P2P_LISTEN_CHANNEL;
1019 } else if (os_strcmp(entry.key, "ListenChannel") == 0 &&
1020 entry.type == DBUS_TYPE_UINT32) {
1021 wpa_s->conf->p2p_listen_channel = entry.uint32_value;
1022 wpa_s->conf->changed_parameters |=
1023 CFG_CHANGED_P2P_LISTEN_CHANNEL;
1024 } else if (os_strcmp(entry.key, "OperRegClass") == 0 &&
1025 entry.type == DBUS_TYPE_UINT32) {
1026 wpa_s->conf->p2p_oper_reg_class = entry.uint32_value;
1027 wpa_s->conf->changed_parameters |=
1028 CFG_CHANGED_P2P_OPER_CHANNEL;
1029 } else if (os_strcmp(entry.key, "OperChannel") == 0 &&
1030 entry.type == DBUS_TYPE_UINT32) {
1031 wpa_s->conf->p2p_oper_channel = entry.uint32_value;
1032 wpa_s->conf->changed_parameters |=
1033 CFG_CHANGED_P2P_OPER_CHANNEL;
1034 } else if (os_strcmp(entry.key, "SsidPostfix") == 0) {
1035 char *postfix;
1036
1037 if (entry.type != DBUS_TYPE_STRING)
1038 goto error;
1039
1040 postfix = os_strdup(entry.str_value);
1041 if (!postfix)
1042 goto err_no_mem_clear;
1043
1044 os_free(wpa_s->conf->p2p_ssid_postfix);
1045 wpa_s->conf->p2p_ssid_postfix = postfix;
1046
1047 wpa_s->conf->changed_parameters |=
1048 CFG_CHANGED_P2P_SSID_POSTFIX;
1049 } else if (os_strcmp(entry.key, "IntraBss") == 0 &&
1050 entry.type == DBUS_TYPE_BOOLEAN) {
1051 wpa_s->conf->p2p_intra_bss = entry.bool_value;
1052 wpa_s->conf->changed_parameters |=
1053 CFG_CHANGED_P2P_INTRA_BSS;
1054 } else if (os_strcmp(entry.key, "GroupIdle") == 0 &&
1055 entry.type == DBUS_TYPE_UINT32)
1056 wpa_s->conf->p2p_group_idle = entry.uint32_value;
1057 else if (os_strcmp(entry.key, "disassoc_low_ack") == 0 &&
1058 entry.type == DBUS_TYPE_UINT32)
1059 wpa_s->conf->disassoc_low_ack = entry.uint32_value;
1060 else if (os_strcmp(entry.key, "NoGroupIface") == 0 &&
1061 entry.type == DBUS_TYPE_BOOLEAN)
1062 wpa_s->conf->p2p_no_group_iface = entry.bool_value;
1063 else if (os_strcmp(entry.key, "p2p_search_delay") == 0 &&
1064 entry.type == DBUS_TYPE_UINT32)
1065 wpa_s->conf->p2p_search_delay = entry.uint32_value;
1066 else
1067 goto error;
1068
1069 wpa_dbus_dict_entry_clear(&entry);
1070 }
1071
1072 if (wpa_s->conf->changed_parameters) {
1073 /* Some changed parameters requires to update config*/
1074 wpa_supplicant_update_config(wpa_s);
1075 }
1076
1077 return TRUE;
1078
1079 error:
1080 dbus_set_error_const(error, DBUS_ERROR_INVALID_ARGS,
1081 "invalid message format");
1082 wpa_dbus_dict_entry_clear(&entry);
1083 return FALSE;
1084
1085 err_no_mem_clear:
1086 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
1087 wpa_dbus_dict_entry_clear(&entry);
1088 return FALSE;
1089 }
1090
1091
wpas_dbus_getter_p2p_peers(const struct wpa_dbus_property_desc * property_desc,DBusMessageIter * iter,DBusError * error,void * user_data)1092 dbus_bool_t wpas_dbus_getter_p2p_peers(
1093 const struct wpa_dbus_property_desc *property_desc,
1094 DBusMessageIter *iter, DBusError *error, void *user_data)
1095 {
1096 struct wpa_supplicant *wpa_s = user_data;
1097 struct p2p_data *p2p = wpa_s->global->p2p;
1098 int next = 0, i = 0;
1099 int num = 0, out_of_mem = 0;
1100 const u8 *addr;
1101 const struct p2p_peer_info *peer_info = NULL;
1102 dbus_bool_t success = FALSE;
1103
1104 struct dl_list peer_objpath_list;
1105 struct peer_objpath_node {
1106 struct dl_list list;
1107 char path[WPAS_DBUS_OBJECT_PATH_MAX];
1108 } *node, *tmp;
1109
1110 char **peer_obj_paths = NULL;
1111
1112 if (!wpa_dbus_p2p_check_enabled(wpa_s, NULL, NULL, error) ||
1113 !wpa_s->parent->parent->dbus_new_path)
1114 return FALSE;
1115
1116 dl_list_init(&peer_objpath_list);
1117
1118 /* Get the first peer info */
1119 peer_info = p2p_get_peer_found(p2p, NULL, next);
1120
1121 /* Get next and accumulate them */
1122 next = 1;
1123 while (peer_info != NULL) {
1124 node = os_zalloc(sizeof(struct peer_objpath_node));
1125 if (!node) {
1126 out_of_mem = 1;
1127 goto error;
1128 }
1129
1130 addr = peer_info->p2p_device_addr;
1131 os_snprintf(node->path, WPAS_DBUS_OBJECT_PATH_MAX,
1132 "%s/" WPAS_DBUS_NEW_P2P_PEERS_PART
1133 "/" COMPACT_MACSTR,
1134 wpa_s->parent->parent->dbus_new_path,
1135 MAC2STR(addr));
1136 dl_list_add_tail(&peer_objpath_list, &node->list);
1137 num++;
1138
1139 peer_info = p2p_get_peer_found(p2p, addr, next);
1140 }
1141
1142 /*
1143 * Now construct the peer object paths in a form suitable for
1144 * array_property_getter helper below.
1145 */
1146 peer_obj_paths = os_calloc(num, sizeof(char *));
1147
1148 if (!peer_obj_paths) {
1149 out_of_mem = 1;
1150 goto error;
1151 }
1152
1153 dl_list_for_each_safe(node, tmp, &peer_objpath_list,
1154 struct peer_objpath_node, list)
1155 peer_obj_paths[i++] = node->path;
1156
1157 success = wpas_dbus_simple_array_property_getter(iter,
1158 DBUS_TYPE_OBJECT_PATH,
1159 peer_obj_paths, num,
1160 error);
1161
1162 error:
1163 if (peer_obj_paths)
1164 os_free(peer_obj_paths);
1165
1166 dl_list_for_each_safe(node, tmp, &peer_objpath_list,
1167 struct peer_objpath_node, list) {
1168 dl_list_del(&node->list);
1169 os_free(node);
1170 }
1171 if (out_of_mem)
1172 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
1173
1174 return success;
1175 }
1176
1177
1178 enum wpas_p2p_role {
1179 WPAS_P2P_ROLE_DEVICE,
1180 WPAS_P2P_ROLE_GO,
1181 WPAS_P2P_ROLE_CLIENT,
1182 };
1183
wpas_get_p2p_role(struct wpa_supplicant * wpa_s)1184 static enum wpas_p2p_role wpas_get_p2p_role(struct wpa_supplicant *wpa_s)
1185 {
1186 struct wpa_ssid *ssid = wpa_s->current_ssid;
1187
1188 if (!ssid)
1189 return WPAS_P2P_ROLE_DEVICE;
1190 if (wpa_s->wpa_state != WPA_COMPLETED)
1191 return WPAS_P2P_ROLE_DEVICE;
1192
1193 switch (ssid->mode) {
1194 case WPAS_MODE_P2P_GO:
1195 case WPAS_MODE_P2P_GROUP_FORMATION:
1196 return WPAS_P2P_ROLE_GO;
1197 case WPAS_MODE_INFRA:
1198 if (ssid->p2p_group)
1199 return WPAS_P2P_ROLE_CLIENT;
1200 return WPAS_P2P_ROLE_DEVICE;
1201 default:
1202 return WPAS_P2P_ROLE_DEVICE;
1203 }
1204 }
1205
1206
wpas_dbus_getter_p2p_role(const struct wpa_dbus_property_desc * property_desc,DBusMessageIter * iter,DBusError * error,void * user_data)1207 dbus_bool_t wpas_dbus_getter_p2p_role(
1208 const struct wpa_dbus_property_desc *property_desc,
1209 DBusMessageIter *iter, DBusError *error, void *user_data)
1210 {
1211 struct wpa_supplicant *wpa_s = user_data;
1212 char *str;
1213
1214 switch (wpas_get_p2p_role(wpa_s)) {
1215 case WPAS_P2P_ROLE_GO:
1216 str = "GO";
1217 break;
1218 case WPAS_P2P_ROLE_CLIENT:
1219 str = "client";
1220 break;
1221 default:
1222 str = "device";
1223 break;
1224 }
1225
1226 return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING, &str,
1227 error);
1228 }
1229
1230
wpas_dbus_getter_p2p_group(const struct wpa_dbus_property_desc * property_desc,DBusMessageIter * iter,DBusError * error,void * user_data)1231 dbus_bool_t wpas_dbus_getter_p2p_group(
1232 const struct wpa_dbus_property_desc *property_desc,
1233 DBusMessageIter *iter, DBusError *error, void *user_data)
1234 {
1235 struct wpa_supplicant *wpa_s = user_data;
1236 char path_buf[WPAS_DBUS_OBJECT_PATH_MAX];
1237 char *dbus_groupobj_path = path_buf;
1238
1239 if (wpa_s->dbus_groupobj_path == NULL)
1240 os_snprintf(dbus_groupobj_path, WPAS_DBUS_OBJECT_PATH_MAX,
1241 "/");
1242 else
1243 os_snprintf(dbus_groupobj_path, WPAS_DBUS_OBJECT_PATH_MAX,
1244 "%s", wpa_s->dbus_groupobj_path);
1245
1246 return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_OBJECT_PATH,
1247 &dbus_groupobj_path, error);
1248 }
1249
1250
wpas_dbus_getter_p2p_peergo(const struct wpa_dbus_property_desc * property_desc,DBusMessageIter * iter,DBusError * error,void * user_data)1251 dbus_bool_t wpas_dbus_getter_p2p_peergo(
1252 const struct wpa_dbus_property_desc *property_desc,
1253 DBusMessageIter *iter, DBusError *error, void *user_data)
1254 {
1255 struct wpa_supplicant *wpa_s = user_data;
1256 char go_peer_obj_path[WPAS_DBUS_OBJECT_PATH_MAX], *path;
1257
1258 if (!wpa_s->parent->parent->dbus_new_path)
1259 return FALSE;
1260
1261 if (wpas_get_p2p_role(wpa_s) != WPAS_P2P_ROLE_CLIENT)
1262 os_snprintf(go_peer_obj_path, WPAS_DBUS_OBJECT_PATH_MAX, "/");
1263 else
1264 os_snprintf(go_peer_obj_path, WPAS_DBUS_OBJECT_PATH_MAX,
1265 "%s/" WPAS_DBUS_NEW_P2P_PEERS_PART "/"
1266 COMPACT_MACSTR,
1267 wpa_s->parent->parent->dbus_new_path,
1268 MAC2STR(wpa_s->go_dev_addr));
1269
1270 path = go_peer_obj_path;
1271 return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_OBJECT_PATH,
1272 &path, error);
1273 }
1274
1275
1276 /*
1277 * Peer object properties accessor methods
1278 */
1279
wpas_dbus_getter_p2p_peer_device_name(const struct wpa_dbus_property_desc * property_desc,DBusMessageIter * iter,DBusError * error,void * user_data)1280 dbus_bool_t wpas_dbus_getter_p2p_peer_device_name(
1281 const struct wpa_dbus_property_desc *property_desc,
1282 DBusMessageIter *iter, DBusError *error, void *user_data)
1283 {
1284 struct peer_handler_args *peer_args = user_data;
1285 const struct p2p_peer_info *info;
1286 char *tmp;
1287
1288 if (!wpa_dbus_p2p_check_enabled(peer_args->wpa_s, NULL, NULL, error))
1289 return FALSE;
1290
1291 /* get the peer info */
1292 info = p2p_get_peer_found(peer_args->wpa_s->global->p2p,
1293 peer_args->p2p_device_addr, 0);
1294 if (info == NULL) {
1295 dbus_set_error(error, DBUS_ERROR_FAILED,
1296 "failed to find peer");
1297 return FALSE;
1298 }
1299
1300 tmp = os_strdup(info->device_name);
1301 if (!tmp) {
1302 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
1303 return FALSE;
1304 }
1305
1306 if (!wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING, &tmp,
1307 error)) {
1308 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
1309 os_free(tmp);
1310 return FALSE;
1311 }
1312
1313 os_free(tmp);
1314 return TRUE;
1315 }
1316
1317
wpas_dbus_getter_p2p_peer_manufacturer(const struct wpa_dbus_property_desc * property_desc,DBusMessageIter * iter,DBusError * error,void * user_data)1318 dbus_bool_t wpas_dbus_getter_p2p_peer_manufacturer(
1319 const struct wpa_dbus_property_desc *property_desc,
1320 DBusMessageIter *iter, DBusError *error, void *user_data)
1321 {
1322 struct peer_handler_args *peer_args = user_data;
1323 const struct p2p_peer_info *info;
1324 char *tmp;
1325
1326 if (!wpa_dbus_p2p_check_enabled(peer_args->wpa_s, NULL, NULL, error))
1327 return FALSE;
1328
1329 /* get the peer info */
1330 info = p2p_get_peer_found(peer_args->wpa_s->global->p2p,
1331 peer_args->p2p_device_addr, 0);
1332 if (info == NULL) {
1333 dbus_set_error(error, DBUS_ERROR_FAILED, "failed to find peer");
1334 return FALSE;
1335 }
1336
1337 tmp = os_strdup(info->manufacturer);
1338 if (!tmp) {
1339 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
1340 return FALSE;
1341 }
1342
1343 if (!wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING, &tmp,
1344 error)) {
1345 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
1346 os_free(tmp);
1347 return FALSE;
1348 }
1349
1350 os_free(tmp);
1351 return TRUE;
1352 }
1353
1354
wpas_dbus_getter_p2p_peer_modelname(const struct wpa_dbus_property_desc * property_desc,DBusMessageIter * iter,DBusError * error,void * user_data)1355 dbus_bool_t wpas_dbus_getter_p2p_peer_modelname(
1356 const struct wpa_dbus_property_desc *property_desc,
1357 DBusMessageIter *iter, DBusError *error, void *user_data)
1358 {
1359 struct peer_handler_args *peer_args = user_data;
1360 const struct p2p_peer_info *info;
1361 char *tmp;
1362
1363 if (!wpa_dbus_p2p_check_enabled(peer_args->wpa_s, NULL, NULL, error))
1364 return FALSE;
1365
1366 /* get the peer info */
1367 info = p2p_get_peer_found(peer_args->wpa_s->global->p2p,
1368 peer_args->p2p_device_addr, 0);
1369 if (info == NULL) {
1370 dbus_set_error(error, DBUS_ERROR_FAILED, "failed to find peer");
1371 return FALSE;
1372 }
1373
1374 tmp = os_strdup(info->model_name);
1375 if (!tmp) {
1376 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
1377 return FALSE;
1378 }
1379
1380 if (!wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING, &tmp,
1381 error)) {
1382 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
1383 os_free(tmp);
1384 return FALSE;
1385 }
1386
1387 os_free(tmp);
1388 return TRUE;
1389 }
1390
1391
wpas_dbus_getter_p2p_peer_modelnumber(const struct wpa_dbus_property_desc * property_desc,DBusMessageIter * iter,DBusError * error,void * user_data)1392 dbus_bool_t wpas_dbus_getter_p2p_peer_modelnumber(
1393 const struct wpa_dbus_property_desc *property_desc,
1394 DBusMessageIter *iter, DBusError *error, void *user_data)
1395 {
1396 struct peer_handler_args *peer_args = user_data;
1397 const struct p2p_peer_info *info;
1398 char *tmp;
1399
1400 if (!wpa_dbus_p2p_check_enabled(peer_args->wpa_s, NULL, NULL, error))
1401 return FALSE;
1402
1403 /* get the peer info */
1404 info = p2p_get_peer_found(peer_args->wpa_s->global->p2p,
1405 peer_args->p2p_device_addr, 0);
1406 if (info == NULL) {
1407 dbus_set_error(error, DBUS_ERROR_FAILED, "failed to find peer");
1408 return FALSE;
1409 }
1410
1411 tmp = os_strdup(info->model_number);
1412 if (!tmp) {
1413 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
1414 return FALSE;
1415 }
1416
1417 if (!wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING, &tmp,
1418 error)) {
1419 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
1420 os_free(tmp);
1421 return FALSE;
1422 }
1423
1424 os_free(tmp);
1425 return TRUE;
1426 }
1427
1428
wpas_dbus_getter_p2p_peer_serialnumber(const struct wpa_dbus_property_desc * property_desc,DBusMessageIter * iter,DBusError * error,void * user_data)1429 dbus_bool_t wpas_dbus_getter_p2p_peer_serialnumber(
1430 const struct wpa_dbus_property_desc *property_desc,
1431 DBusMessageIter *iter, DBusError *error, void *user_data)
1432 {
1433 struct peer_handler_args *peer_args = user_data;
1434 const struct p2p_peer_info *info;
1435 char *tmp;
1436
1437 if (!wpa_dbus_p2p_check_enabled(peer_args->wpa_s, NULL, NULL, error))
1438 return FALSE;
1439
1440 /* get the peer info */
1441 info = p2p_get_peer_found(peer_args->wpa_s->global->p2p,
1442 peer_args->p2p_device_addr, 0);
1443 if (info == NULL) {
1444 dbus_set_error(error, DBUS_ERROR_FAILED, "failed to find peer");
1445 return FALSE;
1446 }
1447
1448 tmp = os_strdup(info->serial_number);
1449 if (!tmp) {
1450 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
1451 return FALSE;
1452 }
1453
1454 if (!wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING, &tmp,
1455 error)) {
1456 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
1457 os_free(tmp);
1458 return FALSE;
1459 }
1460
1461 os_free(tmp);
1462 return TRUE;
1463 }
1464
1465
wpas_dbus_getter_p2p_peer_primary_device_type(const struct wpa_dbus_property_desc * property_desc,DBusMessageIter * iter,DBusError * error,void * user_data)1466 dbus_bool_t wpas_dbus_getter_p2p_peer_primary_device_type(
1467 const struct wpa_dbus_property_desc *property_desc,
1468 DBusMessageIter *iter, DBusError *error, void *user_data)
1469 {
1470 struct peer_handler_args *peer_args = user_data;
1471 const struct p2p_peer_info *info;
1472
1473 info = p2p_get_peer_found(peer_args->wpa_s->global->p2p,
1474 peer_args->p2p_device_addr, 0);
1475 if (info == NULL) {
1476 dbus_set_error(error, DBUS_ERROR_FAILED,
1477 "failed to find peer");
1478 return FALSE;
1479 }
1480
1481 if (!wpas_dbus_simple_array_property_getter(iter, DBUS_TYPE_BYTE,
1482 (char *)
1483 info->pri_dev_type,
1484 WPS_DEV_TYPE_LEN, error)) {
1485 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
1486 return FALSE;
1487 }
1488
1489 return TRUE;
1490 }
1491
1492
wpas_dbus_getter_p2p_peer_config_method(const struct wpa_dbus_property_desc * property_desc,DBusMessageIter * iter,DBusError * error,void * user_data)1493 dbus_bool_t wpas_dbus_getter_p2p_peer_config_method(
1494 const struct wpa_dbus_property_desc *property_desc,
1495 DBusMessageIter *iter, DBusError *error, void *user_data)
1496 {
1497 struct peer_handler_args *peer_args = user_data;
1498 const struct p2p_peer_info *info;
1499
1500 info = p2p_get_peer_found(peer_args->wpa_s->global->p2p,
1501 peer_args->p2p_device_addr, 0);
1502 if (info == NULL) {
1503 dbus_set_error(error, DBUS_ERROR_FAILED,
1504 "failed to find peer");
1505 return FALSE;
1506 }
1507
1508 if (!wpas_dbus_simple_property_getter(iter, DBUS_TYPE_UINT16,
1509 &info->config_methods, error)) {
1510 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
1511 return FALSE;
1512 }
1513
1514 return TRUE;
1515 }
1516
1517
wpas_dbus_getter_p2p_peer_level(const struct wpa_dbus_property_desc * property_desc,DBusMessageIter * iter,DBusError * error,void * user_data)1518 dbus_bool_t wpas_dbus_getter_p2p_peer_level(
1519 const struct wpa_dbus_property_desc *property_desc,
1520 DBusMessageIter *iter, DBusError *error, void *user_data)
1521 {
1522 struct peer_handler_args *peer_args = user_data;
1523 const struct p2p_peer_info *info;
1524
1525 info = p2p_get_peer_found(peer_args->wpa_s->global->p2p,
1526 peer_args->p2p_device_addr, 0);
1527 if (info == NULL) {
1528 dbus_set_error(error, DBUS_ERROR_FAILED,
1529 "failed to find peer");
1530 return FALSE;
1531 }
1532
1533 if (!wpas_dbus_simple_property_getter(iter, DBUS_TYPE_INT32,
1534 &info->level, error)) {
1535 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
1536 return FALSE;
1537 }
1538
1539 return TRUE;
1540 }
1541
1542
wpas_dbus_getter_p2p_peer_device_capability(const struct wpa_dbus_property_desc * property_desc,DBusMessageIter * iter,DBusError * error,void * user_data)1543 dbus_bool_t wpas_dbus_getter_p2p_peer_device_capability(
1544 const struct wpa_dbus_property_desc *property_desc,
1545 DBusMessageIter *iter, DBusError *error, void *user_data)
1546 {
1547 struct peer_handler_args *peer_args = user_data;
1548 const struct p2p_peer_info *info;
1549
1550 info = p2p_get_peer_found(peer_args->wpa_s->global->p2p,
1551 peer_args->p2p_device_addr, 0);
1552 if (info == NULL) {
1553 dbus_set_error(error, DBUS_ERROR_FAILED,
1554 "failed to find peer");
1555 return FALSE;
1556 }
1557
1558 if (!wpas_dbus_simple_property_getter(iter, DBUS_TYPE_BYTE,
1559 &info->dev_capab, error)) {
1560 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
1561 return FALSE;
1562 }
1563
1564 return TRUE;
1565 }
1566
1567
wpas_dbus_getter_p2p_peer_group_capability(const struct wpa_dbus_property_desc * property_desc,DBusMessageIter * iter,DBusError * error,void * user_data)1568 dbus_bool_t wpas_dbus_getter_p2p_peer_group_capability(
1569 const struct wpa_dbus_property_desc *property_desc,
1570 DBusMessageIter *iter, DBusError *error, void *user_data)
1571 {
1572 struct peer_handler_args *peer_args = user_data;
1573 const struct p2p_peer_info *info;
1574
1575 info = p2p_get_peer_found(peer_args->wpa_s->global->p2p,
1576 peer_args->p2p_device_addr, 0);
1577 if (info == NULL) {
1578 dbus_set_error(error, DBUS_ERROR_FAILED,
1579 "failed to find peer");
1580 return FALSE;
1581 }
1582
1583 if (!wpas_dbus_simple_property_getter(iter, DBUS_TYPE_BYTE,
1584 &info->group_capab, error)) {
1585 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
1586 return FALSE;
1587 }
1588
1589 return TRUE;
1590 }
1591
1592
wpas_dbus_getter_p2p_peer_secondary_device_types(const struct wpa_dbus_property_desc * property_desc,DBusMessageIter * iter,DBusError * error,void * user_data)1593 dbus_bool_t wpas_dbus_getter_p2p_peer_secondary_device_types(
1594 const struct wpa_dbus_property_desc *property_desc,
1595 DBusMessageIter *iter, DBusError *error, void *user_data)
1596 {
1597 struct peer_handler_args *peer_args = user_data;
1598 const struct p2p_peer_info *info;
1599 DBusMessageIter variant_iter, array_iter;
1600
1601 info = p2p_get_peer_found(peer_args->wpa_s->global->p2p,
1602 peer_args->p2p_device_addr, 0);
1603 if (info == NULL) {
1604 dbus_set_error(error, DBUS_ERROR_FAILED, "failed to find peer");
1605 return FALSE;
1606 }
1607
1608 if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
1609 DBUS_TYPE_ARRAY_AS_STRING
1610 DBUS_TYPE_ARRAY_AS_STRING
1611 DBUS_TYPE_BYTE_AS_STRING,
1612 &variant_iter) ||
1613 !dbus_message_iter_open_container(&variant_iter, DBUS_TYPE_ARRAY,
1614 DBUS_TYPE_ARRAY_AS_STRING
1615 DBUS_TYPE_BYTE_AS_STRING,
1616 &array_iter)) {
1617 dbus_set_error(error, DBUS_ERROR_FAILED,
1618 "%s: failed to construct message 1", __func__);
1619 return FALSE;
1620 }
1621
1622 if (info->wps_sec_dev_type_list_len) {
1623 const u8 *sec_dev_type_list = info->wps_sec_dev_type_list;
1624 int num_sec_device_types =
1625 info->wps_sec_dev_type_list_len / WPS_DEV_TYPE_LEN;
1626 int i;
1627 DBusMessageIter inner_array_iter;
1628
1629 for (i = 0; i < num_sec_device_types; i++) {
1630 if (!dbus_message_iter_open_container(
1631 &array_iter, DBUS_TYPE_ARRAY,
1632 DBUS_TYPE_BYTE_AS_STRING,
1633 &inner_array_iter) ||
1634 !dbus_message_iter_append_fixed_array(
1635 &inner_array_iter, DBUS_TYPE_BYTE,
1636 &sec_dev_type_list, WPS_DEV_TYPE_LEN) ||
1637 !dbus_message_iter_close_container(
1638 &array_iter, &inner_array_iter)) {
1639 dbus_set_error(error, DBUS_ERROR_FAILED,
1640 "%s: failed to construct message 2 (%d)",
1641 __func__, i);
1642 return FALSE;
1643 }
1644
1645 sec_dev_type_list += WPS_DEV_TYPE_LEN;
1646 }
1647 }
1648
1649 if (!dbus_message_iter_close_container(&variant_iter, &array_iter) ||
1650 !dbus_message_iter_close_container(iter, &variant_iter)) {
1651 dbus_set_error(error, DBUS_ERROR_FAILED,
1652 "%s: failed to construct message 3", __func__);
1653 return FALSE;
1654 }
1655
1656 return TRUE;
1657 }
1658
1659
wpas_dbus_getter_p2p_peer_vendor_extension(const struct wpa_dbus_property_desc * property_desc,DBusMessageIter * iter,DBusError * error,void * user_data)1660 dbus_bool_t wpas_dbus_getter_p2p_peer_vendor_extension(
1661 const struct wpa_dbus_property_desc *property_desc,
1662 DBusMessageIter *iter, DBusError *error, void *user_data)
1663 {
1664 struct wpabuf *vendor_extension[P2P_MAX_WPS_VENDOR_EXT];
1665 unsigned int i, num = 0;
1666 struct peer_handler_args *peer_args = user_data;
1667 const struct p2p_peer_info *info;
1668
1669 info = p2p_get_peer_found(peer_args->wpa_s->global->p2p,
1670 peer_args->p2p_device_addr, 0);
1671 if (info == NULL) {
1672 dbus_set_error(error, DBUS_ERROR_FAILED,
1673 "failed to find peer");
1674 return FALSE;
1675 }
1676
1677 /* Add WPS vendor extensions attribute */
1678 os_memset(vendor_extension, 0, sizeof(vendor_extension));
1679 for (i = 0; i < P2P_MAX_WPS_VENDOR_EXT; i++) {
1680 if (info->wps_vendor_ext[i] == NULL)
1681 continue;
1682 vendor_extension[num] = info->wps_vendor_ext[i];
1683 num++;
1684 }
1685
1686 if (!wpas_dbus_simple_array_array_property_getter(iter, DBUS_TYPE_BYTE,
1687 vendor_extension,
1688 num, error))
1689 return FALSE;
1690
1691 return TRUE;
1692 }
1693
1694
wpas_dbus_getter_p2p_peer_ies(const struct wpa_dbus_property_desc * property_desc,DBusMessageIter * iter,DBusError * error,void * user_data)1695 dbus_bool_t wpas_dbus_getter_p2p_peer_ies(
1696 const struct wpa_dbus_property_desc *property_desc,
1697 DBusMessageIter *iter, DBusError *error, void *user_data)
1698 {
1699 struct peer_handler_args *peer_args = user_data;
1700 const struct p2p_peer_info *info;
1701
1702 info = p2p_get_peer_found(peer_args->wpa_s->global->p2p,
1703 peer_args->p2p_device_addr, 0);
1704 if (info == NULL) {
1705 dbus_set_error(error, DBUS_ERROR_FAILED,
1706 "failed to find peer");
1707 return FALSE;
1708 }
1709
1710 if (info->wfd_subelems == NULL)
1711 return wpas_dbus_simple_array_property_getter(iter,
1712 DBUS_TYPE_BYTE,
1713 NULL, 0, error);
1714
1715 return wpas_dbus_simple_array_property_getter(
1716 iter, DBUS_TYPE_BYTE, (char *) info->wfd_subelems->buf,
1717 info->wfd_subelems->used, error);
1718 }
1719
1720
wpas_dbus_getter_p2p_peer_device_address(const struct wpa_dbus_property_desc * property_desc,DBusMessageIter * iter,DBusError * error,void * user_data)1721 dbus_bool_t wpas_dbus_getter_p2p_peer_device_address(
1722 const struct wpa_dbus_property_desc *property_desc,
1723 DBusMessageIter *iter, DBusError *error, void *user_data)
1724 {
1725 struct peer_handler_args *peer_args = user_data;
1726 const struct p2p_peer_info *info;
1727
1728 info = p2p_get_peer_found(peer_args->wpa_s->global->p2p,
1729 peer_args->p2p_device_addr, 0);
1730 if (info == NULL) {
1731 dbus_set_error(error, DBUS_ERROR_FAILED,
1732 "failed to find peer");
1733 return FALSE;
1734 }
1735
1736 return wpas_dbus_simple_array_property_getter(
1737 iter, DBUS_TYPE_BYTE, (char *) info->p2p_device_addr,
1738 ETH_ALEN, error);
1739 }
1740
1741
1742 struct peer_group_data {
1743 struct wpa_supplicant *wpa_s;
1744 const struct p2p_peer_info *info;
1745 char **paths;
1746 unsigned int nb_paths;
1747 int error;
1748 };
1749
1750
match_group_where_peer_is_client(struct p2p_group * group,void * user_data)1751 static int match_group_where_peer_is_client(struct p2p_group *group,
1752 void *user_data)
1753 {
1754 struct peer_group_data *data = user_data;
1755 const struct p2p_group_config *cfg;
1756 struct wpa_supplicant *wpa_s_go;
1757 char **paths;
1758
1759 if (!p2p_group_is_client_connected(group, data->info->p2p_device_addr))
1760 return 1;
1761
1762 cfg = p2p_group_get_config(group);
1763
1764 wpa_s_go = wpas_get_p2p_go_iface(data->wpa_s, cfg->ssid,
1765 cfg->ssid_len);
1766 if (wpa_s_go == NULL)
1767 return 1;
1768
1769 paths = os_realloc_array(data->paths, data->nb_paths + 1,
1770 sizeof(char *));
1771 if (paths == NULL)
1772 goto out_of_memory;
1773
1774 data->paths = paths;
1775 data->paths[data->nb_paths] = wpa_s_go->dbus_groupobj_path;
1776 data->nb_paths++;
1777
1778 return 1;
1779
1780 out_of_memory:
1781 data->error = ENOMEM;
1782 return 0;
1783 }
1784
1785
wpas_dbus_getter_p2p_peer_groups(const struct wpa_dbus_property_desc * property_desc,DBusMessageIter * iter,DBusError * error,void * user_data)1786 dbus_bool_t wpas_dbus_getter_p2p_peer_groups(
1787 const struct wpa_dbus_property_desc *property_desc,
1788 DBusMessageIter *iter, DBusError *error, void *user_data)
1789 {
1790 struct peer_handler_args *peer_args = user_data;
1791 const struct p2p_peer_info *info;
1792 struct peer_group_data data;
1793 struct wpa_supplicant *wpa_s, *wpa_s_go;
1794 dbus_bool_t success = FALSE;
1795
1796 info = p2p_get_peer_found(peer_args->wpa_s->global->p2p,
1797 peer_args->p2p_device_addr, 0);
1798 if (info == NULL) {
1799 dbus_set_error(error, DBUS_ERROR_FAILED,
1800 "failed to find peer");
1801 return FALSE;
1802 }
1803
1804 os_memset(&data, 0, sizeof(data));
1805
1806 wpa_s = peer_args->wpa_s;
1807 wpa_s = wpa_s->global->p2p_init_wpa_s;
1808
1809 wpa_s_go = wpas_get_p2p_client_iface(wpa_s, info->p2p_device_addr);
1810 if (wpa_s_go) {
1811 data.paths = os_calloc(1, sizeof(char *));
1812 if (data.paths == NULL)
1813 goto out_of_memory;
1814 data.paths[0] = wpa_s_go->dbus_groupobj_path;
1815 data.nb_paths = 1;
1816 }
1817
1818 data.wpa_s = peer_args->wpa_s;
1819 data.info = info;
1820
1821 p2p_loop_on_all_groups(peer_args->wpa_s->global->p2p,
1822 match_group_where_peer_is_client, &data);
1823 if (data.error)
1824 goto out_of_memory;
1825
1826 if (data.paths == NULL) {
1827 return wpas_dbus_simple_array_property_getter(
1828 iter, DBUS_TYPE_OBJECT_PATH, NULL, 0, error);
1829 }
1830
1831 success = wpas_dbus_simple_array_property_getter(iter,
1832 DBUS_TYPE_OBJECT_PATH,
1833 data.paths,
1834 data.nb_paths, error);
1835 goto out;
1836
1837 out_of_memory:
1838 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
1839 out:
1840 os_free(data.paths);
1841 return success;
1842 }
1843
1844
1845 /**
1846 * wpas_dbus_getter_persistent_groups - Get array of persistent group objects
1847 * @iter: Pointer to incoming dbus message iter
1848 * @error: Location to store error on failure
1849 * @user_data: Function specific data
1850 * Returns: TRUE on success, FALSE on failure
1851 *
1852 * Getter for "PersistentGroups" property.
1853 */
wpas_dbus_getter_persistent_groups(const struct wpa_dbus_property_desc * property_desc,DBusMessageIter * iter,DBusError * error,void * user_data)1854 dbus_bool_t wpas_dbus_getter_persistent_groups(
1855 const struct wpa_dbus_property_desc *property_desc,
1856 DBusMessageIter *iter, DBusError *error, void *user_data)
1857 {
1858 struct wpa_supplicant *wpa_s = user_data;
1859 struct wpa_ssid *ssid;
1860 char **paths;
1861 unsigned int i = 0, num = 0;
1862 dbus_bool_t success = FALSE;
1863
1864 wpa_s = wpa_s->global->p2p_init_wpa_s;
1865 if (!wpa_s->parent->dbus_new_path)
1866 return FALSE;
1867
1868 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
1869 if (network_is_persistent_group(ssid))
1870 num++;
1871
1872 paths = os_calloc(num, sizeof(char *));
1873 if (!paths) {
1874 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
1875 return FALSE;
1876 }
1877
1878 /* Loop through configured networks and append object path of each */
1879 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) {
1880 if (!network_is_persistent_group(ssid))
1881 continue;
1882 paths[i] = os_zalloc(WPAS_DBUS_OBJECT_PATH_MAX);
1883 if (paths[i] == NULL) {
1884 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY,
1885 "no memory");
1886 goto out;
1887 }
1888 /* Construct the object path for this network. */
1889 os_snprintf(paths[i++], WPAS_DBUS_OBJECT_PATH_MAX,
1890 "%s/" WPAS_DBUS_NEW_PERSISTENT_GROUPS_PART "/%d",
1891 wpa_s->parent->dbus_new_path, ssid->id);
1892 }
1893
1894 success = wpas_dbus_simple_array_property_getter(iter,
1895 DBUS_TYPE_OBJECT_PATH,
1896 paths, num, error);
1897
1898 out:
1899 while (i)
1900 os_free(paths[--i]);
1901 os_free(paths);
1902 return success;
1903 }
1904
1905
1906 /**
1907 * wpas_dbus_getter_persistent_group_properties - Get options for a persistent
1908 * group
1909 * @iter: Pointer to incoming dbus message iter
1910 * @error: Location to store error on failure
1911 * @user_data: Function specific data
1912 * Returns: TRUE on success, FALSE on failure
1913 *
1914 * Getter for "Properties" property of a persistent group.
1915 */
wpas_dbus_getter_persistent_group_properties(const struct wpa_dbus_property_desc * property_desc,DBusMessageIter * iter,DBusError * error,void * user_data)1916 dbus_bool_t wpas_dbus_getter_persistent_group_properties(
1917 const struct wpa_dbus_property_desc *property_desc,
1918 DBusMessageIter *iter, DBusError *error, void *user_data)
1919 {
1920 struct network_handler_args *net = user_data;
1921
1922 /* Leveraging the fact that persistent group object is still
1923 * represented in same manner as network within.
1924 */
1925 return wpas_dbus_getter_network_properties(property_desc, iter, error, net);
1926 }
1927
1928
1929 /**
1930 * wpas_dbus_setter_persistent_group_properties - Set options for a persistent
1931 * group
1932 * @iter: Pointer to incoming dbus message iter
1933 * @error: Location to store error on failure
1934 * @user_data: Function specific data
1935 * Returns: TRUE on success, FALSE on failure
1936 *
1937 * Setter for "Properties" property of a persistent group.
1938 */
wpas_dbus_setter_persistent_group_properties(const struct wpa_dbus_property_desc * property_desc,DBusMessageIter * iter,DBusError * error,void * user_data)1939 dbus_bool_t wpas_dbus_setter_persistent_group_properties(
1940 const struct wpa_dbus_property_desc *property_desc,
1941 DBusMessageIter *iter, DBusError *error, void *user_data)
1942 {
1943 struct network_handler_args *net = user_data;
1944 struct wpa_ssid *ssid = net->ssid;
1945 DBusMessageIter variant_iter;
1946
1947 /*
1948 * Leveraging the fact that persistent group object is still
1949 * represented in same manner as network within.
1950 */
1951 dbus_message_iter_recurse(iter, &variant_iter);
1952 return set_network_properties(net->wpa_s, ssid, &variant_iter, error);
1953 }
1954
1955
1956 /**
1957 * wpas_dbus_new_iface_add_persistent_group - Add a new configured
1958 * persistent_group
1959 * @message: Pointer to incoming dbus message
1960 * @wpa_s: wpa_supplicant structure for a network interface
1961 * Returns: A dbus message containing the object path of the new
1962 * persistent group
1963 *
1964 * Handler function for "AddPersistentGroup" method call of a P2P Device
1965 * interface.
1966 */
wpas_dbus_handler_add_persistent_group(DBusMessage * message,struct wpa_supplicant * wpa_s)1967 DBusMessage * wpas_dbus_handler_add_persistent_group(
1968 DBusMessage *message, struct wpa_supplicant *wpa_s)
1969 {
1970 DBusMessage *reply = NULL;
1971 DBusMessageIter iter;
1972 struct wpa_ssid *ssid = NULL;
1973 char path_buf[WPAS_DBUS_OBJECT_PATH_MAX], *path = path_buf;
1974 DBusError error;
1975
1976 dbus_message_iter_init(message, &iter);
1977
1978 wpa_s = wpa_s->global->p2p_init_wpa_s;
1979 if (wpa_s->parent->dbus_new_path)
1980 ssid = wpa_config_add_network(wpa_s->conf);
1981 if (ssid == NULL) {
1982 wpa_printf(MSG_ERROR,
1983 "dbus: %s: Cannot add new persistent group",
1984 __func__);
1985 reply = wpas_dbus_error_unknown_error(
1986 message,
1987 "wpa_supplicant could not add a persistent group on this interface.");
1988 goto err;
1989 }
1990
1991 /* Mark the ssid as being a persistent group before the notification */
1992 ssid->disabled = 2;
1993 ssid->p2p_persistent_group = 1;
1994 wpas_notify_persistent_group_added(wpa_s, ssid);
1995
1996 wpa_config_set_network_defaults(ssid);
1997
1998 dbus_error_init(&error);
1999 if (!set_network_properties(wpa_s, ssid, &iter, &error)) {
2000 wpa_printf(MSG_DEBUG,
2001 "dbus: %s: Control interface could not set persistent group properties",
2002 __func__);
2003 reply = wpas_dbus_reply_new_from_error(
2004 message, &error, DBUS_ERROR_INVALID_ARGS,
2005 "Failed to set network properties");
2006 dbus_error_free(&error);
2007 goto err;
2008 }
2009
2010 /* Construct the object path for this network. */
2011 os_snprintf(path, WPAS_DBUS_OBJECT_PATH_MAX,
2012 "%s/" WPAS_DBUS_NEW_PERSISTENT_GROUPS_PART "/%d",
2013 wpa_s->parent->dbus_new_path, ssid->id);
2014
2015 reply = dbus_message_new_method_return(message);
2016 if (reply == NULL) {
2017 reply = wpas_dbus_error_no_memory(message);
2018 goto err;
2019 }
2020 if (!dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH, &path,
2021 DBUS_TYPE_INVALID)) {
2022 dbus_message_unref(reply);
2023 reply = wpas_dbus_error_no_memory(message);
2024 goto err;
2025 }
2026
2027 return reply;
2028
2029 err:
2030 if (ssid) {
2031 wpas_notify_persistent_group_removed(wpa_s, ssid);
2032 wpa_config_remove_network(wpa_s->conf, ssid->id);
2033 }
2034 return reply;
2035 }
2036
2037
2038 /**
2039 * wpas_dbus_handler_remove_persistent_group - Remove a configured persistent
2040 * group
2041 * @message: Pointer to incoming dbus message
2042 * @wpa_s: wpa_supplicant structure for a network interface
2043 * Returns: NULL on success or dbus error on failure
2044 *
2045 * Handler function for "RemovePersistentGroup" method call of a P2P Device
2046 * interface.
2047 */
wpas_dbus_handler_remove_persistent_group(DBusMessage * message,struct wpa_supplicant * wpa_s)2048 DBusMessage * wpas_dbus_handler_remove_persistent_group(
2049 DBusMessage *message, struct wpa_supplicant *wpa_s)
2050 {
2051 DBusMessage *reply = NULL;
2052 const char *op;
2053 char *iface = NULL, *persistent_group_id;
2054 int id;
2055 struct wpa_ssid *ssid;
2056
2057 dbus_message_get_args(message, NULL, DBUS_TYPE_OBJECT_PATH, &op,
2058 DBUS_TYPE_INVALID);
2059
2060 wpa_s = wpa_s->global->p2p_init_wpa_s;
2061
2062 /*
2063 * Extract the network ID and ensure the network is actually a child of
2064 * this interface.
2065 */
2066 iface = wpas_dbus_new_decompose_object_path(
2067 op, WPAS_DBUS_NEW_PERSISTENT_GROUPS_PART,
2068 &persistent_group_id);
2069 if (iface == NULL || persistent_group_id == NULL ||
2070 !wpa_s->parent->dbus_new_path ||
2071 os_strcmp(iface, wpa_s->parent->dbus_new_path) != 0) {
2072 reply = wpas_dbus_error_invalid_args(message, op);
2073 goto out;
2074 }
2075
2076 id = strtoul(persistent_group_id, NULL, 10);
2077 if (errno == EINVAL) {
2078 reply = wpas_dbus_error_invalid_args(message, op);
2079 goto out;
2080 }
2081
2082 ssid = wpa_config_get_network(wpa_s->conf, id);
2083 if (ssid == NULL) {
2084 reply = wpas_dbus_error_persistent_group_unknown(message);
2085 goto out;
2086 }
2087
2088 wpas_notify_persistent_group_removed(wpa_s, ssid);
2089
2090 if (wpa_config_remove_network(wpa_s->conf, id) < 0) {
2091 wpa_printf(MSG_ERROR,
2092 "dbus: %s: error occurred when removing persistent group %d",
2093 __func__, id);
2094 reply = wpas_dbus_error_unknown_error(
2095 message,
2096 "error removing the specified persistent group on this interface.");
2097 goto out;
2098 }
2099
2100 out:
2101 os_free(iface);
2102 return reply;
2103 }
2104
2105
remove_persistent_group(struct wpa_supplicant * wpa_s,struct wpa_ssid * ssid)2106 static void remove_persistent_group(struct wpa_supplicant *wpa_s,
2107 struct wpa_ssid *ssid)
2108 {
2109 wpas_notify_persistent_group_removed(wpa_s, ssid);
2110
2111 if (wpa_config_remove_network(wpa_s->conf, ssid->id) < 0) {
2112 wpa_printf(MSG_ERROR,
2113 "dbus: %s: error occurred when removing persistent group %d",
2114 __func__, ssid->id);
2115 return;
2116 }
2117 }
2118
2119
2120 /**
2121 * wpas_dbus_handler_remove_all_persistent_groups - Remove all configured
2122 * persistent groups
2123 * @message: Pointer to incoming dbus message
2124 * @wpa_s: wpa_supplicant structure for a network interface
2125 * Returns: NULL on success or dbus error on failure
2126 *
2127 * Handler function for "RemoveAllPersistentGroups" method call of a
2128 * P2P Device interface.
2129 */
wpas_dbus_handler_remove_all_persistent_groups(DBusMessage * message,struct wpa_supplicant * wpa_s)2130 DBusMessage * wpas_dbus_handler_remove_all_persistent_groups(
2131 DBusMessage *message, struct wpa_supplicant *wpa_s)
2132 {
2133 struct wpa_ssid *ssid, *next;
2134 struct wpa_config *config;
2135
2136 wpa_s = wpa_s->global->p2p_init_wpa_s;
2137
2138 config = wpa_s->conf;
2139 ssid = config->ssid;
2140 while (ssid) {
2141 next = ssid->next;
2142 if (network_is_persistent_group(ssid))
2143 remove_persistent_group(wpa_s, ssid);
2144 ssid = next;
2145 }
2146 return NULL;
2147 }
2148
2149
2150 /*
2151 * Group object properties accessor methods
2152 */
2153
wpas_dbus_getter_p2p_group_members(const struct wpa_dbus_property_desc * property_desc,DBusMessageIter * iter,DBusError * error,void * user_data)2154 dbus_bool_t wpas_dbus_getter_p2p_group_members(
2155 const struct wpa_dbus_property_desc *property_desc,
2156 DBusMessageIter *iter, DBusError *error, void *user_data)
2157 {
2158 struct wpa_supplicant *wpa_s = user_data;
2159 struct wpa_ssid *ssid;
2160 unsigned int num_members;
2161 char **paths;
2162 unsigned int i;
2163 void *next = NULL;
2164 const u8 *addr;
2165 dbus_bool_t success = FALSE;
2166
2167 if (!wpa_s->parent->parent->dbus_new_path)
2168 return FALSE;
2169
2170 /* Verify correct role for this property */
2171 if (wpas_get_p2p_role(wpa_s) != WPAS_P2P_ROLE_GO) {
2172 return wpas_dbus_simple_array_property_getter(
2173 iter, DBUS_TYPE_OBJECT_PATH, NULL, 0, error);
2174 }
2175
2176 ssid = wpa_s->conf->ssid;
2177 /* At present WPAS P2P_GO mode only applicable for p2p_go */
2178 if (ssid->mode != WPAS_MODE_P2P_GO &&
2179 ssid->mode != WPAS_MODE_AP &&
2180 ssid->mode != WPAS_MODE_P2P_GROUP_FORMATION)
2181 return FALSE;
2182
2183 num_members = p2p_get_group_num_members(wpa_s->p2p_group);
2184
2185 paths = os_calloc(num_members, sizeof(char *));
2186 if (!paths)
2187 goto out_of_memory;
2188
2189 i = 0;
2190 while ((addr = p2p_iterate_group_members(wpa_s->p2p_group, &next))) {
2191 paths[i] = os_zalloc(WPAS_DBUS_OBJECT_PATH_MAX);
2192 if (!paths[i])
2193 goto out_of_memory;
2194 os_snprintf(paths[i], WPAS_DBUS_OBJECT_PATH_MAX,
2195 "%s/" WPAS_DBUS_NEW_P2P_PEERS_PART
2196 "/" COMPACT_MACSTR,
2197 wpa_s->parent->parent->dbus_new_path,
2198 MAC2STR(addr));
2199 i++;
2200 }
2201
2202 success = wpas_dbus_simple_array_property_getter(iter,
2203 DBUS_TYPE_OBJECT_PATH,
2204 paths, num_members,
2205 error);
2206
2207 for (i = 0; i < num_members; i++)
2208 os_free(paths[i]);
2209 os_free(paths);
2210 return success;
2211
2212 out_of_memory:
2213 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
2214 if (paths) {
2215 for (i = 0; i < num_members; i++)
2216 os_free(paths[i]);
2217 os_free(paths);
2218 }
2219 return FALSE;
2220 }
2221
2222
wpas_dbus_getter_p2p_group_ssid(const struct wpa_dbus_property_desc * property_desc,DBusMessageIter * iter,DBusError * error,void * user_data)2223 dbus_bool_t wpas_dbus_getter_p2p_group_ssid(
2224 const struct wpa_dbus_property_desc *property_desc,
2225 DBusMessageIter *iter, DBusError *error, void *user_data)
2226 {
2227 struct wpa_supplicant *wpa_s = user_data;
2228
2229 if (wpa_s->current_ssid == NULL)
2230 return FALSE;
2231 return wpas_dbus_simple_array_property_getter(
2232 iter, DBUS_TYPE_BYTE, wpa_s->current_ssid->ssid,
2233 wpa_s->current_ssid->ssid_len, error);
2234 }
2235
2236
wpas_dbus_getter_p2p_group_bssid(const struct wpa_dbus_property_desc * property_desc,DBusMessageIter * iter,DBusError * error,void * user_data)2237 dbus_bool_t wpas_dbus_getter_p2p_group_bssid(
2238 const struct wpa_dbus_property_desc *property_desc,
2239 DBusMessageIter *iter, DBusError *error, void *user_data)
2240 {
2241 struct wpa_supplicant *wpa_s = user_data;
2242 u8 role = wpas_get_p2p_role(wpa_s);
2243 u8 *p_bssid;
2244
2245 if (role == WPAS_P2P_ROLE_CLIENT) {
2246 if (wpa_s->current_ssid == NULL)
2247 return FALSE;
2248 p_bssid = wpa_s->current_ssid->bssid;
2249 } else {
2250 if (wpa_s->ap_iface == NULL)
2251 return FALSE;
2252 p_bssid = wpa_s->ap_iface->bss[0]->own_addr;
2253 }
2254
2255 return wpas_dbus_simple_array_property_getter(iter, DBUS_TYPE_BYTE,
2256 p_bssid, ETH_ALEN,
2257 error);
2258 }
2259
2260
wpas_dbus_getter_p2p_group_frequency(const struct wpa_dbus_property_desc * property_desc,DBusMessageIter * iter,DBusError * error,void * user_data)2261 dbus_bool_t wpas_dbus_getter_p2p_group_frequency(
2262 const struct wpa_dbus_property_desc *property_desc,
2263 DBusMessageIter *iter, DBusError *error, void *user_data)
2264 {
2265 struct wpa_supplicant *wpa_s = user_data;
2266 u16 op_freq;
2267 u8 role = wpas_get_p2p_role(wpa_s);
2268
2269 if (role == WPAS_P2P_ROLE_CLIENT) {
2270 if (wpa_s->go_params == NULL)
2271 return FALSE;
2272 op_freq = wpa_s->go_params->freq;
2273 } else {
2274 if (wpa_s->ap_iface == NULL)
2275 return FALSE;
2276 op_freq = wpa_s->ap_iface->freq;
2277 }
2278
2279 return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_UINT16,
2280 &op_freq, error);
2281 }
2282
2283
wpas_dbus_getter_p2p_group_passphrase(const struct wpa_dbus_property_desc * property_desc,DBusMessageIter * iter,DBusError * error,void * user_data)2284 dbus_bool_t wpas_dbus_getter_p2p_group_passphrase(
2285 const struct wpa_dbus_property_desc *property_desc,
2286 DBusMessageIter *iter, DBusError *error, void *user_data)
2287 {
2288 struct wpa_supplicant *wpa_s = user_data;
2289 char *p_pass;
2290 struct wpa_ssid *ssid = wpa_s->current_ssid;
2291
2292 if (ssid == NULL)
2293 return FALSE;
2294
2295 p_pass = ssid->passphrase;
2296 if (!p_pass)
2297 p_pass = "";
2298
2299 return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING,
2300 &p_pass, error);
2301
2302 }
2303
2304
wpas_dbus_getter_p2p_group_psk(const struct wpa_dbus_property_desc * property_desc,DBusMessageIter * iter,DBusError * error,void * user_data)2305 dbus_bool_t wpas_dbus_getter_p2p_group_psk(
2306 const struct wpa_dbus_property_desc *property_desc,
2307 DBusMessageIter *iter, DBusError *error, void *user_data)
2308 {
2309 struct wpa_supplicant *wpa_s = user_data;
2310 u8 *p_psk = NULL;
2311 u8 psk_len = 0;
2312 struct wpa_ssid *ssid = wpa_s->current_ssid;
2313
2314 if (ssid == NULL)
2315 return FALSE;
2316
2317 if (ssid->psk_set) {
2318 p_psk = ssid->psk;
2319 psk_len = sizeof(ssid->psk);
2320 }
2321
2322 return wpas_dbus_simple_array_property_getter(iter, DBUS_TYPE_BYTE,
2323 p_psk, psk_len, error);
2324 }
2325
2326
wpas_dbus_getter_p2p_group_vendor_ext(const struct wpa_dbus_property_desc * property_desc,DBusMessageIter * iter,DBusError * error,void * user_data)2327 dbus_bool_t wpas_dbus_getter_p2p_group_vendor_ext(
2328 const struct wpa_dbus_property_desc *property_desc,
2329 DBusMessageIter *iter, DBusError *error, void *user_data)
2330 {
2331 struct wpa_supplicant *wpa_s = user_data;
2332 struct hostapd_data *hapd;
2333 struct wpabuf *vendor_ext[MAX_WPS_VENDOR_EXTENSIONS];
2334 unsigned int i, num_vendor_ext = 0;
2335
2336 os_memset(vendor_ext, 0, sizeof(vendor_ext));
2337
2338 /* Verify correct role for this property */
2339 if (wpas_get_p2p_role(wpa_s) == WPAS_P2P_ROLE_GO) {
2340 if (wpa_s->ap_iface == NULL)
2341 return FALSE;
2342 hapd = wpa_s->ap_iface->bss[0];
2343
2344 /* Parse WPS Vendor Extensions sent in Beacon/Probe Response */
2345 for (i = 0; i < MAX_WPS_VENDOR_EXTENSIONS; i++) {
2346 if (hapd->conf->wps_vendor_ext[i] == NULL)
2347 continue;
2348 vendor_ext[num_vendor_ext++] =
2349 hapd->conf->wps_vendor_ext[i];
2350 }
2351 }
2352
2353 /* Return vendor extensions or no data */
2354 return wpas_dbus_simple_array_array_property_getter(iter,
2355 DBUS_TYPE_BYTE,
2356 vendor_ext,
2357 num_vendor_ext,
2358 error);
2359 }
2360
2361
wpas_dbus_setter_p2p_group_vendor_ext(const struct wpa_dbus_property_desc * property_desc,DBusMessageIter * iter,DBusError * error,void * user_data)2362 dbus_bool_t wpas_dbus_setter_p2p_group_vendor_ext(
2363 const struct wpa_dbus_property_desc *property_desc,
2364 DBusMessageIter *iter, DBusError *error, void *user_data)
2365 {
2366 struct wpa_supplicant *wpa_s = user_data;
2367 DBusMessageIter variant_iter, iter_dict, array_iter, sub;
2368 struct wpa_dbus_dict_entry entry = { .type = DBUS_TYPE_STRING };
2369 unsigned int i;
2370 struct hostapd_data *hapd = NULL;
2371
2372 if (wpas_get_p2p_role(wpa_s) == WPAS_P2P_ROLE_GO &&
2373 wpa_s->ap_iface != NULL)
2374 hapd = wpa_s->ap_iface->bss[0];
2375 else
2376 return FALSE;
2377
2378 dbus_message_iter_recurse(iter, &variant_iter);
2379 if (dbus_message_iter_get_arg_type(&variant_iter) != DBUS_TYPE_ARRAY)
2380 return FALSE;
2381
2382 /*
2383 * This is supposed to be array of bytearrays (aay), but the earlier
2384 * implementation used a dict with "WPSVendorExtensions" as the key in
2385 * this setter function which does not match the format used by the
2386 * getter function. For backwards compatibility, allow both formats to
2387 * be used in the setter.
2388 */
2389 if (dbus_message_iter_get_element_type(&variant_iter) ==
2390 DBUS_TYPE_ARRAY) {
2391 /* This is the proper format matching the getter */
2392 struct wpabuf *vals[MAX_WPS_VENDOR_EXTENSIONS];
2393
2394 dbus_message_iter_recurse(&variant_iter, &array_iter);
2395
2396 if (dbus_message_iter_get_arg_type(&array_iter) !=
2397 DBUS_TYPE_ARRAY ||
2398 dbus_message_iter_get_element_type(&array_iter) !=
2399 DBUS_TYPE_BYTE) {
2400 wpa_printf(MSG_DEBUG,
2401 "dbus: Not an array of array of bytes");
2402 return FALSE;
2403 }
2404
2405 i = 0;
2406 os_memset(vals, 0, sizeof(vals));
2407
2408 while (dbus_message_iter_get_arg_type(&array_iter) ==
2409 DBUS_TYPE_ARRAY) {
2410 char *val;
2411 int len;
2412
2413 if (i == MAX_WPS_VENDOR_EXTENSIONS) {
2414 wpa_printf(MSG_DEBUG,
2415 "dbus: Too many WPSVendorExtensions values");
2416 i = MAX_WPS_VENDOR_EXTENSIONS + 1;
2417 break;
2418 }
2419
2420 dbus_message_iter_recurse(&array_iter, &sub);
2421 dbus_message_iter_get_fixed_array(&sub, &val, &len);
2422 wpa_hexdump(MSG_DEBUG, "dbus: WPSVendorExtentions[]",
2423 val, len);
2424 vals[i] = wpabuf_alloc_copy(val, len);
2425 if (vals[i] == NULL) {
2426 i = MAX_WPS_VENDOR_EXTENSIONS + 1;
2427 break;
2428 }
2429 i++;
2430 dbus_message_iter_next(&array_iter);
2431 }
2432
2433 if (i > MAX_WPS_VENDOR_EXTENSIONS) {
2434 for (i = 0; i < MAX_WPS_VENDOR_EXTENSIONS; i++)
2435 wpabuf_free(vals[i]);
2436 return FALSE;
2437 }
2438
2439 for (i = 0; i < MAX_WPS_VENDOR_EXTENSIONS; i++) {
2440 wpabuf_free(hapd->conf->wps_vendor_ext[i]);
2441 hapd->conf->wps_vendor_ext[i] = vals[i];
2442 }
2443
2444 hostapd_update_wps(hapd);
2445
2446 return TRUE;
2447 }
2448
2449 if (dbus_message_iter_get_element_type(&variant_iter) !=
2450 DBUS_TYPE_DICT_ENTRY)
2451 return FALSE;
2452
2453 wpa_printf(MSG_DEBUG,
2454 "dbus: Try to use backwards compatibility version of WPSVendorExtensions setter");
2455 if (!wpa_dbus_dict_open_read(&variant_iter, &iter_dict, error))
2456 return FALSE;
2457
2458 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
2459 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry)) {
2460 dbus_set_error_const(error, DBUS_ERROR_INVALID_ARGS,
2461 "invalid message format");
2462 return FALSE;
2463 }
2464
2465 if (os_strcmp(entry.key, "WPSVendorExtensions") == 0) {
2466 if (entry.type != DBUS_TYPE_ARRAY ||
2467 entry.array_type != WPAS_DBUS_TYPE_BINARRAY ||
2468 entry.array_len > MAX_WPS_VENDOR_EXTENSIONS)
2469 goto error;
2470
2471 for (i = 0; i < MAX_WPS_VENDOR_EXTENSIONS; i++) {
2472 wpabuf_free(hapd->conf->wps_vendor_ext[i]);
2473 if (i < entry.array_len) {
2474 hapd->conf->wps_vendor_ext[i] =
2475 entry.binarray_value[i];
2476 entry.binarray_value[i] = NULL;
2477 } else
2478 hapd->conf->wps_vendor_ext[i] = NULL;
2479 }
2480
2481 hostapd_update_wps(hapd);
2482 } else
2483 goto error;
2484
2485 wpa_dbus_dict_entry_clear(&entry);
2486 }
2487
2488 return TRUE;
2489
2490 error:
2491 wpa_dbus_dict_entry_clear(&entry);
2492 dbus_set_error_const(error, DBUS_ERROR_INVALID_ARGS,
2493 "invalid message format");
2494 return FALSE;
2495 }
2496
2497
wpas_dbus_handler_p2p_add_service(DBusMessage * message,struct wpa_supplicant * wpa_s)2498 DBusMessage * wpas_dbus_handler_p2p_add_service(DBusMessage *message,
2499 struct wpa_supplicant *wpa_s)
2500 {
2501 DBusMessageIter iter_dict;
2502 DBusMessage *reply = NULL;
2503 DBusMessageIter iter;
2504 struct wpa_dbus_dict_entry entry;
2505 int upnp = 0;
2506 int bonjour = 0;
2507 char *service = NULL;
2508 struct wpabuf *query = NULL;
2509 struct wpabuf *resp = NULL;
2510 u8 version = 0;
2511
2512 dbus_message_iter_init(message, &iter);
2513
2514 if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
2515 goto error;
2516
2517 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
2518 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
2519 goto error;
2520
2521 if (os_strcmp(entry.key, "service_type") == 0 &&
2522 entry.type == DBUS_TYPE_STRING) {
2523 if (os_strcmp(entry.str_value, "upnp") == 0)
2524 upnp = 1;
2525 else if (os_strcmp(entry.str_value, "bonjour") == 0)
2526 bonjour = 1;
2527 else
2528 goto error_clear;
2529 } else if (os_strcmp(entry.key, "version") == 0 &&
2530 entry.type == DBUS_TYPE_INT32) {
2531 version = entry.uint32_value;
2532 } else if (os_strcmp(entry.key, "service") == 0 &&
2533 entry.type == DBUS_TYPE_STRING) {
2534 os_free(service);
2535 service = os_strdup(entry.str_value);
2536 } else if (os_strcmp(entry.key, "query") == 0) {
2537 if (entry.type != DBUS_TYPE_ARRAY ||
2538 entry.array_type != DBUS_TYPE_BYTE)
2539 goto error_clear;
2540 query = wpabuf_alloc_copy(
2541 entry.bytearray_value,
2542 entry.array_len);
2543 } else if (os_strcmp(entry.key, "response") == 0) {
2544 if (entry.type != DBUS_TYPE_ARRAY ||
2545 entry.array_type != DBUS_TYPE_BYTE)
2546 goto error_clear;
2547 resp = wpabuf_alloc_copy(entry.bytearray_value,
2548 entry.array_len);
2549 }
2550 wpa_dbus_dict_entry_clear(&entry);
2551 }
2552
2553 if (upnp == 1) {
2554 if (version <= 0 || service == NULL)
2555 goto error;
2556
2557 if (wpas_p2p_service_add_upnp(wpa_s, version, service) != 0)
2558 goto error;
2559
2560 } else if (bonjour == 1) {
2561 if (query == NULL || resp == NULL)
2562 goto error;
2563
2564 if (wpas_p2p_service_add_bonjour(wpa_s, query, resp) < 0)
2565 goto error;
2566 query = NULL;
2567 resp = NULL;
2568 } else
2569 goto error;
2570
2571 os_free(service);
2572 return reply;
2573 error_clear:
2574 wpa_dbus_dict_entry_clear(&entry);
2575 error:
2576 os_free(service);
2577 wpabuf_free(query);
2578 wpabuf_free(resp);
2579 return wpas_dbus_error_invalid_args(message, NULL);
2580 }
2581
2582
wpas_dbus_handler_p2p_delete_service(DBusMessage * message,struct wpa_supplicant * wpa_s)2583 DBusMessage * wpas_dbus_handler_p2p_delete_service(
2584 DBusMessage *message, struct wpa_supplicant *wpa_s)
2585 {
2586 DBusMessageIter iter_dict;
2587 DBusMessage *reply = NULL;
2588 DBusMessageIter iter;
2589 struct wpa_dbus_dict_entry entry;
2590 int upnp = 0;
2591 int bonjour = 0;
2592 int ret = 0;
2593 char *service = NULL;
2594 struct wpabuf *query = NULL;
2595 u8 version = 0;
2596
2597 dbus_message_iter_init(message, &iter);
2598
2599 if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
2600 goto error;
2601
2602 if (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
2603 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
2604 goto error;
2605
2606 if (os_strcmp(entry.key, "service_type") == 0 &&
2607 entry.type == DBUS_TYPE_STRING) {
2608 if (os_strcmp(entry.str_value, "upnp") == 0)
2609 upnp = 1;
2610 else if (os_strcmp(entry.str_value, "bonjour") == 0)
2611 bonjour = 1;
2612 else
2613 goto error_clear;
2614 wpa_dbus_dict_entry_clear(&entry);
2615 }
2616 }
2617 if (upnp == 1) {
2618 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
2619 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
2620 goto error;
2621 if (os_strcmp(entry.key, "version") == 0 &&
2622 entry.type == DBUS_TYPE_INT32)
2623 version = entry.uint32_value;
2624 else if (os_strcmp(entry.key, "service") == 0 &&
2625 entry.type == DBUS_TYPE_STRING) {
2626 os_free(service);
2627 service = os_strdup(entry.str_value);
2628 } else
2629 goto error_clear;
2630
2631 wpa_dbus_dict_entry_clear(&entry);
2632 }
2633
2634 if (version <= 0 || service == NULL)
2635 goto error;
2636
2637 ret = wpas_p2p_service_del_upnp(wpa_s, version, service);
2638 if (ret != 0)
2639 goto error;
2640 } else if (bonjour == 1) {
2641 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
2642 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
2643 goto error;
2644
2645 if (os_strcmp(entry.key, "query") == 0) {
2646 if (entry.type != DBUS_TYPE_ARRAY ||
2647 entry.array_type != DBUS_TYPE_BYTE)
2648 goto error_clear;
2649 wpabuf_free(query);
2650 query = wpabuf_alloc_copy(
2651 entry.bytearray_value,
2652 entry.array_len);
2653 } else
2654 goto error_clear;
2655
2656 wpa_dbus_dict_entry_clear(&entry);
2657 }
2658
2659 if (query == NULL)
2660 goto error;
2661
2662 ret = wpas_p2p_service_del_bonjour(wpa_s, query);
2663 if (ret != 0)
2664 goto error;
2665 } else
2666 goto error;
2667
2668 wpabuf_free(query);
2669 os_free(service);
2670 return reply;
2671 error_clear:
2672 wpa_dbus_dict_entry_clear(&entry);
2673 error:
2674 wpabuf_free(query);
2675 os_free(service);
2676 return wpas_dbus_error_invalid_args(message, NULL);
2677 }
2678
2679
wpas_dbus_handler_p2p_flush_service(DBusMessage * message,struct wpa_supplicant * wpa_s)2680 DBusMessage * wpas_dbus_handler_p2p_flush_service(DBusMessage *message,
2681 struct wpa_supplicant *wpa_s)
2682 {
2683 wpas_p2p_service_flush(wpa_s);
2684 return NULL;
2685 }
2686
2687
wpas_dbus_handler_p2p_service_sd_req(DBusMessage * message,struct wpa_supplicant * wpa_s)2688 DBusMessage * wpas_dbus_handler_p2p_service_sd_req(
2689 DBusMessage *message, struct wpa_supplicant *wpa_s)
2690 {
2691 DBusMessageIter iter_dict;
2692 DBusMessage *reply = NULL;
2693 DBusMessageIter iter;
2694 struct wpa_dbus_dict_entry entry;
2695 int upnp = 0;
2696 char *service = NULL;
2697 char *peer_object_path = NULL;
2698 struct wpabuf *tlv = NULL;
2699 u8 version = 0;
2700 u64 ref = 0;
2701 u8 addr_buf[ETH_ALEN], *addr;
2702
2703 dbus_message_iter_init(message, &iter);
2704
2705 if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
2706 goto error;
2707
2708 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
2709 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
2710 goto error;
2711 if (os_strcmp(entry.key, "peer_object") == 0 &&
2712 entry.type == DBUS_TYPE_OBJECT_PATH) {
2713 peer_object_path = os_strdup(entry.str_value);
2714 } else if (os_strcmp(entry.key, "service_type") == 0 &&
2715 entry.type == DBUS_TYPE_STRING) {
2716 if (os_strcmp(entry.str_value, "upnp") == 0)
2717 upnp = 1;
2718 else
2719 goto error_clear;
2720 } else if (os_strcmp(entry.key, "version") == 0 &&
2721 entry.type == DBUS_TYPE_INT32) {
2722 version = entry.uint32_value;
2723 } else if (os_strcmp(entry.key, "service") == 0 &&
2724 entry.type == DBUS_TYPE_STRING) {
2725 service = os_strdup(entry.str_value);
2726 } else if (os_strcmp(entry.key, "tlv") == 0) {
2727 if (entry.type != DBUS_TYPE_ARRAY ||
2728 entry.array_type != DBUS_TYPE_BYTE)
2729 goto error_clear;
2730 tlv = wpabuf_alloc_copy(entry.bytearray_value,
2731 entry.array_len);
2732 } else
2733 goto error_clear;
2734
2735 wpa_dbus_dict_entry_clear(&entry);
2736 }
2737
2738 if (!peer_object_path) {
2739 addr = NULL;
2740 } else {
2741 if (parse_peer_object_path(peer_object_path, addr_buf) < 0 ||
2742 !p2p_peer_known(wpa_s->global->p2p, addr_buf))
2743 goto error;
2744
2745 addr = addr_buf;
2746 }
2747
2748 if (upnp == 1) {
2749 if (version <= 0 || service == NULL)
2750 goto error;
2751
2752 ref = wpas_p2p_sd_request_upnp(wpa_s, addr, version, service);
2753 } else {
2754 if (tlv == NULL)
2755 goto error;
2756 ref = wpas_p2p_sd_request(wpa_s, addr, tlv);
2757 wpabuf_free(tlv);
2758 }
2759
2760 if (ref != 0) {
2761 reply = dbus_message_new_method_return(message);
2762 dbus_message_append_args(reply, DBUS_TYPE_UINT64,
2763 &ref, DBUS_TYPE_INVALID);
2764 } else {
2765 reply = wpas_dbus_error_unknown_error(
2766 message, "Unable to send SD request");
2767 }
2768 out:
2769 os_free(service);
2770 os_free(peer_object_path);
2771 return reply;
2772 error_clear:
2773 wpa_dbus_dict_entry_clear(&entry);
2774 error:
2775 if (tlv)
2776 wpabuf_free(tlv);
2777 reply = wpas_dbus_error_invalid_args(message, NULL);
2778 goto out;
2779 }
2780
2781
wpas_dbus_handler_p2p_service_sd_res(DBusMessage * message,struct wpa_supplicant * wpa_s)2782 DBusMessage * wpas_dbus_handler_p2p_service_sd_res(
2783 DBusMessage *message, struct wpa_supplicant *wpa_s)
2784 {
2785 DBusMessageIter iter_dict;
2786 DBusMessage *reply = NULL;
2787 DBusMessageIter iter;
2788 struct wpa_dbus_dict_entry entry;
2789 char *peer_object_path = NULL;
2790 struct wpabuf *tlv = NULL;
2791 int freq = 0;
2792 int dlg_tok = 0;
2793 u8 addr[ETH_ALEN];
2794
2795 dbus_message_iter_init(message, &iter);
2796
2797 if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
2798 goto error;
2799
2800 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
2801 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
2802 goto error;
2803
2804 if (os_strcmp(entry.key, "peer_object") == 0 &&
2805 entry.type == DBUS_TYPE_OBJECT_PATH) {
2806 peer_object_path = os_strdup(entry.str_value);
2807 } else if (os_strcmp(entry.key, "frequency") == 0 &&
2808 entry.type == DBUS_TYPE_INT32) {
2809 freq = entry.uint32_value;
2810 } else if (os_strcmp(entry.key, "dialog_token") == 0 &&
2811 (entry.type == DBUS_TYPE_UINT32 ||
2812 entry.type == DBUS_TYPE_INT32)) {
2813 dlg_tok = entry.uint32_value;
2814 } else if (os_strcmp(entry.key, "tlvs") == 0) {
2815 if (entry.type != DBUS_TYPE_ARRAY ||
2816 entry.array_type != DBUS_TYPE_BYTE)
2817 goto error_clear;
2818 tlv = wpabuf_alloc_copy(entry.bytearray_value,
2819 entry.array_len);
2820 } else
2821 goto error_clear;
2822
2823 wpa_dbus_dict_entry_clear(&entry);
2824 }
2825 if (parse_peer_object_path(peer_object_path, addr) < 0 ||
2826 !p2p_peer_known(wpa_s->global->p2p, addr) ||
2827 tlv == NULL)
2828 goto error;
2829
2830 wpas_p2p_sd_response(wpa_s, freq, addr, (u8) dlg_tok, tlv);
2831 wpabuf_free(tlv);
2832 out:
2833 os_free(peer_object_path);
2834 return reply;
2835 error_clear:
2836 wpa_dbus_dict_entry_clear(&entry);
2837 error:
2838 reply = wpas_dbus_error_invalid_args(message, NULL);
2839 goto out;
2840 }
2841
2842
wpas_dbus_handler_p2p_service_sd_cancel_req(DBusMessage * message,struct wpa_supplicant * wpa_s)2843 DBusMessage * wpas_dbus_handler_p2p_service_sd_cancel_req(
2844 DBusMessage *message, struct wpa_supplicant *wpa_s)
2845 {
2846 DBusMessageIter iter;
2847 u64 req = 0;
2848
2849 dbus_message_iter_init(message, &iter);
2850 dbus_message_iter_get_basic(&iter, &req);
2851
2852 if (req == 0)
2853 goto error;
2854
2855 if (wpas_p2p_sd_cancel_request(wpa_s, req) < 0)
2856 goto error;
2857
2858 return NULL;
2859 error:
2860 return wpas_dbus_error_invalid_args(message, NULL);
2861 }
2862
2863
wpas_dbus_handler_p2p_service_update(DBusMessage * message,struct wpa_supplicant * wpa_s)2864 DBusMessage * wpas_dbus_handler_p2p_service_update(
2865 DBusMessage *message, struct wpa_supplicant *wpa_s)
2866 {
2867 wpas_p2p_sd_service_update(wpa_s);
2868 return NULL;
2869 }
2870
2871
wpas_dbus_handler_p2p_serv_disc_external(DBusMessage * message,struct wpa_supplicant * wpa_s)2872 DBusMessage * wpas_dbus_handler_p2p_serv_disc_external(
2873 DBusMessage *message, struct wpa_supplicant *wpa_s)
2874 {
2875 DBusMessageIter iter;
2876 int ext = 0;
2877
2878 dbus_message_iter_init(message, &iter);
2879 dbus_message_iter_get_basic(&iter, &ext);
2880
2881 wpa_s->p2p_sd_over_ctrl_iface = ext;
2882
2883 return NULL;
2884
2885 }
2886
2887
2888 #ifdef CONFIG_WIFI_DISPLAY
2889
wpas_dbus_getter_global_wfd_ies(const struct wpa_dbus_property_desc * property_desc,DBusMessageIter * iter,DBusError * error,void * user_data)2890 dbus_bool_t wpas_dbus_getter_global_wfd_ies(
2891 const struct wpa_dbus_property_desc *property_desc,
2892 DBusMessageIter *iter, DBusError *error, void *user_data)
2893 {
2894 struct wpa_global *global = user_data;
2895 struct wpabuf *ie;
2896 dbus_bool_t ret;
2897
2898 ie = wifi_display_get_wfd_ie(global);
2899 if (ie == NULL)
2900 return wpas_dbus_simple_array_property_getter(iter,
2901 DBUS_TYPE_BYTE,
2902 NULL, 0, error);
2903
2904 ret = wpas_dbus_simple_array_property_getter(iter, DBUS_TYPE_BYTE,
2905 wpabuf_head(ie),
2906 wpabuf_len(ie), error);
2907 wpabuf_free(ie);
2908
2909 return ret;
2910 }
2911
2912
wpas_dbus_setter_global_wfd_ies(const struct wpa_dbus_property_desc * property_desc,DBusMessageIter * iter,DBusError * error,void * user_data)2913 dbus_bool_t wpas_dbus_setter_global_wfd_ies(
2914 const struct wpa_dbus_property_desc *property_desc,
2915 DBusMessageIter *iter, DBusError *error, void *user_data)
2916 {
2917 struct wpa_global *global = user_data;
2918 DBusMessageIter variant, array;
2919 struct wpabuf *ie = NULL;
2920 const u8 *data;
2921 int len;
2922
2923 if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_VARIANT)
2924 goto err;
2925
2926 dbus_message_iter_recurse(iter, &variant);
2927 if (dbus_message_iter_get_arg_type(&variant) != DBUS_TYPE_ARRAY)
2928 goto err;
2929
2930 dbus_message_iter_recurse(&variant, &array);
2931 dbus_message_iter_get_fixed_array(&array, &data, &len);
2932 if (len == 0) {
2933 wifi_display_enable(global, 0);
2934 wifi_display_deinit(global);
2935
2936 return TRUE;
2937 }
2938
2939 ie = wpabuf_alloc(len);
2940 if (ie == NULL)
2941 goto err;
2942
2943 wpabuf_put_data(ie, data, len);
2944 if (wifi_display_subelem_set_from_ies(global, ie) != 0)
2945 goto err;
2946
2947 if (global->wifi_display == 0)
2948 wifi_display_enable(global, 1);
2949
2950 wpabuf_free(ie);
2951
2952 return TRUE;
2953 err:
2954 wpabuf_free(ie);
2955
2956 dbus_set_error_const(error, DBUS_ERROR_INVALID_ARGS,
2957 "invalid message format");
2958 return FALSE;
2959 }
2960
2961 #endif /* CONFIG_WIFI_DISPLAY */
2962