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