]> git.ipfire.org Git - thirdparty/hostap.git/blob - wpa_supplicant/dbus/dbus_new_handlers.c
projects / thirdparty / hostap.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Export disconnect reason code to dbus
[thirdparty/hostap.git] / wpa_supplicant / dbus / dbus_new_handlers.c
1 /*
2 * WPA Supplicant / dbus-based control interface
3 * Copyright (c) 2006, Dan Williams <dcbw@redhat.com> and Red Hat, Inc.
4 * Copyright (c) 2009-2010, Witold Sowa <witold.sowa@gmail.com>
5 * Copyright (c) 2009, Jouni Malinen <j@w1.fi>
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
10 *
11 * Alternatively, this software may be distributed under the terms of BSD
12 * license.
13 *
14 * See README and COPYING for more details.
15 */
16
17 #include "includes.h"
18
19 #include "common.h"
20 #include "common/ieee802_11_defs.h"
21 #include "eap_peer/eap_methods.h"
22 #include "eapol_supp/eapol_supp_sm.h"
23 #include "rsn_supp/wpa.h"
24 #include "../config.h"
25 #include "../wpa_supplicant_i.h"
26 #include "../driver_i.h"
27 #include "../notify.h"
28 #include "../bss.h"
29 #include "../scan.h"
30 #include "../ctrl_iface.h"
31 #include "../autoscan.h"
32 #include "dbus_new_helpers.h"
33 #include "dbus_new.h"
34 #include "dbus_new_handlers.h"
35 #include "dbus_dict_helpers.h"
36 #include "dbus_common_i.h"
37
38 extern int wpa_debug_level;
39 extern int wpa_debug_show_keys;
40 extern int wpa_debug_timestamp;
41
42 static const char *debug_strings[] = {
43 "excessive", "msgdump", "debug", "info", "warning", "error", NULL
44 };
45
46
47 /**
48 * wpas_dbus_error_unknown_error - Return a new InvalidArgs error message
49 * @message: Pointer to incoming dbus message this error refers to
50 * @arg: Optional string appended to error message
51 * Returns: a dbus error message
52 *
53 * Convenience function to create and return an UnknownError
54 */
55 DBusMessage * wpas_dbus_error_unknown_error(DBusMessage *message,
56 const char *arg)
57 {
58 /*
59 * This function can be called as a result of a failure
60 * within internal getter calls, which will call this function
61 * with a NULL message parameter. However, dbus_message_new_error
62 * looks very unkindly (i.e, abort()) on a NULL message, so
63 * in this case, we should not call it.
64 */
65 if (message == NULL) {
66 wpa_printf(MSG_INFO, "dbus: wpas_dbus_error_unknown_error "
67 "called with NULL message (arg=%s)",
68 arg ? arg : "N/A");
69 return NULL;
70 }
71
72 return dbus_message_new_error(message, WPAS_DBUS_ERROR_UNKNOWN_ERROR,
73 arg);
74 }
75
76
77 /**
78 * wpas_dbus_error_iface_unknown - Return a new invalid interface error message
79 * @message: Pointer to incoming dbus message this error refers to
80 * Returns: A dbus error message
81 *
82 * Convenience function to create and return an invalid interface error
83 */
84 static DBusMessage * wpas_dbus_error_iface_unknown(DBusMessage *message)
85 {
86 return dbus_message_new_error(message, WPAS_DBUS_ERROR_IFACE_UNKNOWN,
87 "wpa_supplicant knows nothing about "
88 "this interface.");
89 }
90
91
92 /**
93 * wpas_dbus_error_network_unknown - Return a new NetworkUnknown error message
94 * @message: Pointer to incoming dbus message this error refers to
95 * Returns: a dbus error message
96 *
97 * Convenience function to create and return an invalid network error
98 */
99 static DBusMessage * wpas_dbus_error_network_unknown(DBusMessage *message)
100 {
101 return dbus_message_new_error(message, WPAS_DBUS_ERROR_NETWORK_UNKNOWN,
102 "There is no such a network in this "
103 "interface.");
104 }
105
106
107 /**
108 * wpas_dbus_error_invalid_args - Return a new InvalidArgs error message
109 * @message: Pointer to incoming dbus message this error refers to
110 * Returns: a dbus error message
111 *
112 * Convenience function to create and return an invalid options error
113 */
114 DBusMessage * wpas_dbus_error_invalid_args(DBusMessage *message,
115 const char *arg)
116 {
117 DBusMessage *reply;
118
119 reply = dbus_message_new_error(message, WPAS_DBUS_ERROR_INVALID_ARGS,
120 "Did not receive correct message "
121 "arguments.");
122 if (arg != NULL)
123 dbus_message_append_args(reply, DBUS_TYPE_STRING, &arg,
124 DBUS_TYPE_INVALID);
125
126 return reply;
127 }
128
129
130 static const char *dont_quote[] = {
131 "key_mgmt", "proto", "pairwise", "auth_alg", "group", "eap",
132 "opensc_engine_path", "pkcs11_engine_path", "pkcs11_module_path",
133 "bssid", NULL
134 };
135
136 static dbus_bool_t should_quote_opt(const char *key)
137 {
138 int i = 0;
139 while (dont_quote[i] != NULL) {
140 if (os_strcmp(key, dont_quote[i]) == 0)
141 return FALSE;
142 i++;
143 }
144 return TRUE;
145 }
146
147 /**
148 * get_iface_by_dbus_path - Get a new network interface
149 * @global: Pointer to global data from wpa_supplicant_init()
150 * @path: Pointer to a dbus object path representing an interface
151 * Returns: Pointer to the interface or %NULL if not found
152 */
153 static struct wpa_supplicant * get_iface_by_dbus_path(
154 struct wpa_global *global, const char *path)
155 {
156 struct wpa_supplicant *wpa_s;
157
158 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
159 if (os_strcmp(wpa_s->dbus_new_path, path) == 0)
160 return wpa_s;
161 }
162 return NULL;
163 }
164
165
166 /**
167 * set_network_properties - Set properties of a configured network
168 * @wpa_s: wpa_supplicant structure for a network interface
169 * @ssid: wpa_ssid structure for a configured network
170 * @iter: DBus message iterator containing dictionary of network
171 * properties to set.
172 * @error: On failure, an error describing the failure
173 * Returns: TRUE if the request succeeds, FALSE if it failed
174 *
175 * Sets network configuration with parameters given id DBus dictionary
176 */
177 dbus_bool_t set_network_properties(struct wpa_supplicant *wpa_s,
178 struct wpa_ssid *ssid,
179 DBusMessageIter *iter,
180 DBusError *error)
181 {
182 struct wpa_dbus_dict_entry entry = { .type = DBUS_TYPE_STRING };
183 DBusMessageIter iter_dict;
184 char *value = NULL;
185
186 if (!wpa_dbus_dict_open_read(iter, &iter_dict, error))
187 return FALSE;
188
189 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
190 size_t size = 50;
191 int ret;
192
193 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
194 goto error;
195
196 value = NULL;
197 if (entry.type == DBUS_TYPE_ARRAY &&
198 entry.array_type == DBUS_TYPE_BYTE) {
199 if (entry.array_len <= 0)
200 goto error;
201
202 size = entry.array_len * 2 + 1;
203 value = os_zalloc(size);
204 if (value == NULL)
205 goto error;
206
207 ret = wpa_snprintf_hex(value, size,
208 (u8 *) entry.bytearray_value,
209 entry.array_len);
210 if (ret <= 0)
211 goto error;
212 } else if (entry.type == DBUS_TYPE_STRING) {
213 if (should_quote_opt(entry.key)) {
214 size = os_strlen(entry.str_value);
215 if (size <= 0)
216 goto error;
217
218 size += 3;
219 value = os_zalloc(size);
220 if (value == NULL)
221 goto error;
222
223 ret = os_snprintf(value, size, "\"%s\"",
224 entry.str_value);
225 if (ret < 0 || (size_t) ret != (size - 1))
226 goto error;
227 } else {
228 value = os_strdup(entry.str_value);
229 if (value == NULL)
230 goto error;
231 }
232 } else if (entry.type == DBUS_TYPE_UINT32) {
233 value = os_zalloc(size);
234 if (value == NULL)
235 goto error;
236
237 ret = os_snprintf(value, size, "%u",
238 entry.uint32_value);
239 if (ret <= 0)
240 goto error;
241 } else if (entry.type == DBUS_TYPE_INT32) {
242 value = os_zalloc(size);
243 if (value == NULL)
244 goto error;
245
246 ret = os_snprintf(value, size, "%d",
247 entry.int32_value);
248 if (ret <= 0)
249 goto error;
250 } else
251 goto error;
252
253 if (wpa_config_set(ssid, entry.key, value, 0) < 0)
254 goto error;
255
256 if ((os_strcmp(entry.key, "psk") == 0 &&
257 value[0] == '"' && ssid->ssid_len) ||
258 (os_strcmp(entry.key, "ssid") == 0 && ssid->passphrase))
259 wpa_config_update_psk(ssid);
260 else if (os_strcmp(entry.key, "priority") == 0)
261 wpa_config_update_prio_list(wpa_s->conf);
262
263 os_free(value);
264 wpa_dbus_dict_entry_clear(&entry);
265 }
266
267 return TRUE;
268
269 error:
270 os_free(value);
271 wpa_dbus_dict_entry_clear(&entry);
272 dbus_set_error_const(error, DBUS_ERROR_INVALID_ARGS,
273 "invalid message format");
274 return FALSE;
275 }
276
277
278 /**
279 * wpas_dbus_simple_property_getter - Get basic type property
280 * @iter: Message iter to use when appending arguments
281 * @type: DBus type of property (must be basic type)
282 * @val: pointer to place holding property value
283 * @error: On failure an error describing the failure
284 * Returns: TRUE if the request was successful, FALSE if it failed
285 *
286 * Generic getter for basic type properties. Type is required to be basic.
287 */
288 dbus_bool_t wpas_dbus_simple_property_getter(DBusMessageIter *iter,
289 const int type,
290 const void *val,
291 DBusError *error)
292 {
293 DBusMessageIter variant_iter;
294
295 if (!dbus_type_is_basic(type)) {
296 dbus_set_error(error, DBUS_ERROR_FAILED,
297 "%s: given type is not basic", __func__);
298 return FALSE;
299 }
300
301 if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
302 wpa_dbus_type_as_string(type),
303 &variant_iter))
304 goto error;
305
306 if (!dbus_message_iter_append_basic(&variant_iter, type, val))
307 goto error;
308
309 if (!dbus_message_iter_close_container(iter, &variant_iter))
310 goto error;
311
312 return TRUE;
313
314 error:
315 dbus_set_error(error, DBUS_ERROR_FAILED,
316 "%s: error constructing reply", __func__);
317 return FALSE;
318 }
319
320
321 /**
322 * wpas_dbus_simple_property_setter - Set basic type property
323 * @message: Pointer to incoming dbus message
324 * @type: DBus type of property (must be basic type)
325 * @val: pointer to place where value being set will be stored
326 * Returns: TRUE if the request was successful, FALSE if it failed
327 *
328 * Generic setter for basic type properties. Type is required to be basic.
329 */
330 dbus_bool_t wpas_dbus_simple_property_setter(DBusMessageIter *iter,
331 DBusError *error,
332 const int type, void *val)
333 {
334 DBusMessageIter variant_iter;
335
336 if (!dbus_type_is_basic(type)) {
337 dbus_set_error(error, DBUS_ERROR_FAILED,
338 "%s: given type is not basic", __func__);
339 return FALSE;
340 }
341
342 /* Look at the new value */
343 dbus_message_iter_recurse(iter, &variant_iter);
344 if (dbus_message_iter_get_arg_type(&variant_iter) != type) {
345 dbus_set_error_const(error, DBUS_ERROR_FAILED,
346 "wrong property type");
347 return FALSE;
348 }
349 dbus_message_iter_get_basic(&variant_iter, val);
350
351 return TRUE;
352 }
353
354
355 /**
356 * wpas_dbus_simple_array_property_getter - Get array type property
357 * @iter: Pointer to incoming dbus message iterator
358 * @type: DBus type of property array elements (must be basic type)
359 * @array: pointer to array of elements to put into response message
360 * @array_len: length of above array
361 * @error: a pointer to an error to fill on failure
362 * Returns: TRUE if the request succeeded, FALSE if it failed
363 *
364 * Generic getter for array type properties. Array elements type is
365 * required to be basic.
366 */
367 dbus_bool_t wpas_dbus_simple_array_property_getter(DBusMessageIter *iter,
368 const int type,
369 const void *array,
370 size_t array_len,
371 DBusError *error)
372 {
373 DBusMessageIter variant_iter, array_iter;
374 char type_str[] = "a?"; /* ? will be replaced with subtype letter; */
375 const char *sub_type_str;
376 size_t element_size, i;
377
378 if (!dbus_type_is_basic(type)) {
379 dbus_set_error(error, DBUS_ERROR_FAILED,
380 "%s: given type is not basic", __func__);
381 return FALSE;
382 }
383
384 sub_type_str = wpa_dbus_type_as_string(type);
385 type_str[1] = sub_type_str[0];
386
387 if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
388 type_str, &variant_iter)) {
389 dbus_set_error(error, DBUS_ERROR_FAILED,
390 "%s: failed to construct message 1", __func__);
391 return FALSE;
392 }
393
394 if (!dbus_message_iter_open_container(&variant_iter, DBUS_TYPE_ARRAY,
395 sub_type_str, &array_iter)) {
396 dbus_set_error(error, DBUS_ERROR_FAILED,
397 "%s: failed to construct message 2", __func__);
398 return FALSE;
399 }
400
401 switch(type) {
402 case DBUS_TYPE_BYTE:
403 case DBUS_TYPE_BOOLEAN:
404 element_size = 1;
405 break;
406 case DBUS_TYPE_INT16:
407 case DBUS_TYPE_UINT16:
408 element_size = sizeof(uint16_t);
409 break;
410 case DBUS_TYPE_INT32:
411 case DBUS_TYPE_UINT32:
412 element_size = sizeof(uint32_t);
413 break;
414 case DBUS_TYPE_INT64:
415 case DBUS_TYPE_UINT64:
416 element_size = sizeof(uint64_t);
417 break;
418 case DBUS_TYPE_DOUBLE:
419 element_size = sizeof(double);
420 break;
421 case DBUS_TYPE_STRING:
422 case DBUS_TYPE_OBJECT_PATH:
423 element_size = sizeof(char *);
424 break;
425 default:
426 dbus_set_error(error, DBUS_ERROR_FAILED,
427 "%s: unknown element type %d", __func__, type);
428 return FALSE;
429 }
430
431 for (i = 0; i < array_len; i++) {
432 dbus_message_iter_append_basic(&array_iter, type,
433 array + i * element_size);
434 }
435
436 if (!dbus_message_iter_close_container(&variant_iter, &array_iter)) {
437 dbus_set_error(error, DBUS_ERROR_FAILED,
438 "%s: failed to construct message 3", __func__);
439 return FALSE;
440 }
441
442 if (!dbus_message_iter_close_container(iter, &variant_iter)) {
443 dbus_set_error(error, DBUS_ERROR_FAILED,
444 "%s: failed to construct message 4", __func__);
445 return FALSE;
446 }
447
448 return TRUE;
449 }
450
451
452 /**
453 * wpas_dbus_simple_array_array_property_getter - Get array array type property
454 * @iter: Pointer to incoming dbus message iterator
455 * @type: DBus type of property array elements (must be basic type)
456 * @array: pointer to array of elements to put into response message
457 * @array_len: length of above array
458 * @error: a pointer to an error to fill on failure
459 * Returns: TRUE if the request succeeded, FALSE if it failed
460 *
461 * Generic getter for array type properties. Array elements type is
462 * required to be basic.
463 */
464 dbus_bool_t wpas_dbus_simple_array_array_property_getter(DBusMessageIter *iter,
465 const int type,
466 struct wpabuf **array,
467 size_t array_len,
468 DBusError *error)
469 {
470 DBusMessageIter variant_iter, array_iter;
471 char type_str[] = "aa?";
472 char inner_type_str[] = "a?";
473 const char *sub_type_str;
474 size_t i;
475
476 if (!dbus_type_is_basic(type)) {
477 dbus_set_error(error, DBUS_ERROR_FAILED,
478 "%s: given type is not basic", __func__);
479 return FALSE;
480 }
481
482 sub_type_str = wpa_dbus_type_as_string(type);
483 type_str[2] = sub_type_str[0];
484 inner_type_str[1] = sub_type_str[0];
485
486 if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
487 type_str, &variant_iter)) {
488 dbus_set_error(error, DBUS_ERROR_FAILED,
489 "%s: failed to construct message 1", __func__);
490 return FALSE;
491 }
492 if (!dbus_message_iter_open_container(&variant_iter, DBUS_TYPE_ARRAY,
493 inner_type_str, &array_iter)) {
494 dbus_set_error(error, DBUS_ERROR_FAILED,
495 "%s: failed to construct message 2", __func__);
496 return FALSE;
497 }
498
499 for (i = 0; i < array_len; i++) {
500 wpa_dbus_dict_bin_array_add_element(&array_iter,
501 wpabuf_head(array[i]),
502 wpabuf_len(array[i]));
503
504 }
505
506 if (!dbus_message_iter_close_container(&variant_iter, &array_iter)) {
507 dbus_set_error(error, DBUS_ERROR_FAILED,
508 "%s: failed to close message 2", __func__);
509 return FALSE;
510 }
511
512 if (!dbus_message_iter_close_container(iter, &variant_iter)) {
513 dbus_set_error(error, DBUS_ERROR_FAILED,
514 "%s: failed to close message 1", __func__);
515 return FALSE;
516 }
517
518 return TRUE;
519 }
520
521
522 /**
523 * wpas_dbus_handler_create_interface - Request registration of a network iface
524 * @message: Pointer to incoming dbus message
525 * @global: %wpa_supplicant global data structure
526 * Returns: The object path of the new interface object,
527 * or a dbus error message with more information
528 *
529 * Handler function for "CreateInterface" method call. Handles requests
530 * by dbus clients to register a network interface that wpa_supplicant
531 * will manage.
532 */
533 DBusMessage * wpas_dbus_handler_create_interface(DBusMessage *message,
534 struct wpa_global *global)
535 {
536 DBusMessageIter iter_dict;
537 DBusMessage *reply = NULL;
538 DBusMessageIter iter;
539 struct wpa_dbus_dict_entry entry;
540 char *driver = NULL;
541 char *ifname = NULL;
542 char *confname = NULL;
543 char *bridge_ifname = NULL;
544
545 dbus_message_iter_init(message, &iter);
546
547 if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
548 goto error;
549 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
550 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
551 goto error;
552 if (!os_strcmp(entry.key, "Driver") &&
553 (entry.type == DBUS_TYPE_STRING)) {
554 driver = os_strdup(entry.str_value);
555 wpa_dbus_dict_entry_clear(&entry);
556 if (driver == NULL)
557 goto error;
558 } else if (!os_strcmp(entry.key, "Ifname") &&
559 (entry.type == DBUS_TYPE_STRING)) {
560 ifname = os_strdup(entry.str_value);
561 wpa_dbus_dict_entry_clear(&entry);
562 if (ifname == NULL)
563 goto error;
564 } else if (!os_strcmp(entry.key, "ConfigFile") &&
565 (entry.type == DBUS_TYPE_STRING)) {
566 confname = os_strdup(entry.str_value);
567 wpa_dbus_dict_entry_clear(&entry);
568 if (confname == NULL)
569 goto error;
570 } else if (!os_strcmp(entry.key, "BridgeIfname") &&
571 (entry.type == DBUS_TYPE_STRING)) {
572 bridge_ifname = os_strdup(entry.str_value);
573 wpa_dbus_dict_entry_clear(&entry);
574 if (bridge_ifname == NULL)
575 goto error;
576 } else {
577 wpa_dbus_dict_entry_clear(&entry);
578 goto error;
579 }
580 }
581
582 if (ifname == NULL)
583 goto error; /* Required Ifname argument missing */
584
585 /*
586 * Try to get the wpa_supplicant record for this iface, return
587 * an error if we already control it.
588 */
589 if (wpa_supplicant_get_iface(global, ifname) != NULL) {
590 reply = dbus_message_new_error(message,
591 WPAS_DBUS_ERROR_IFACE_EXISTS,
592 "wpa_supplicant already "
593 "controls this interface.");
594 } else {
595 struct wpa_supplicant *wpa_s;
596 struct wpa_interface iface;
597 os_memset(&iface, 0, sizeof(iface));
598 iface.driver = driver;
599 iface.ifname = ifname;
600 iface.confname = confname;
601 iface.bridge_ifname = bridge_ifname;
602 /* Otherwise, have wpa_supplicant attach to it. */
603 if ((wpa_s = wpa_supplicant_add_iface(global, &iface))) {
604 const char *path = wpa_s->dbus_new_path;
605 reply = dbus_message_new_method_return(message);
606 dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH,
607 &path, DBUS_TYPE_INVALID);
608 } else {
609 reply = wpas_dbus_error_unknown_error(
610 message, "wpa_supplicant couldn't grab this "
611 "interface.");
612 }
613 }
614
615 out:
616 os_free(driver);
617 os_free(ifname);
618 os_free(bridge_ifname);
619 return reply;
620
621 error:
622 reply = wpas_dbus_error_invalid_args(message, NULL);
623 goto out;
624 }
625
626
627 /**
628 * wpas_dbus_handler_remove_interface - Request deregistration of an interface
629 * @message: Pointer to incoming dbus message
630 * @global: wpa_supplicant global data structure
631 * Returns: a dbus message containing a UINT32 indicating success (1) or
632 * failure (0), or returns a dbus error message with more information
633 *
634 * Handler function for "removeInterface" method call. Handles requests
635 * by dbus clients to deregister a network interface that wpa_supplicant
636 * currently manages.
637 */
638 DBusMessage * wpas_dbus_handler_remove_interface(DBusMessage *message,
639 struct wpa_global *global)
640 {
641 struct wpa_supplicant *wpa_s;
642 char *path;
643 DBusMessage *reply = NULL;
644
645 dbus_message_get_args(message, NULL, DBUS_TYPE_OBJECT_PATH, &path,
646 DBUS_TYPE_INVALID);
647
648 wpa_s = get_iface_by_dbus_path(global, path);
649 if (wpa_s == NULL)
650 reply = wpas_dbus_error_iface_unknown(message);
651 else if (wpa_supplicant_remove_iface(global, wpa_s, 0)) {
652 reply = wpas_dbus_error_unknown_error(
653 message, "wpa_supplicant couldn't remove this "
654 "interface.");
655 }
656
657 return reply;
658 }
659
660
661 /**
662 * wpas_dbus_handler_get_interface - Get the object path for an interface name
663 * @message: Pointer to incoming dbus message
664 * @global: %wpa_supplicant global data structure
665 * Returns: The object path of the interface object,
666 * or a dbus error message with more information
667 *
668 * Handler function for "getInterface" method call.
669 */
670 DBusMessage * wpas_dbus_handler_get_interface(DBusMessage *message,
671 struct wpa_global *global)
672 {
673 DBusMessage *reply = NULL;
674 const char *ifname;
675 const char *path;
676 struct wpa_supplicant *wpa_s;
677
678 dbus_message_get_args(message, NULL, DBUS_TYPE_STRING, &ifname,
679 DBUS_TYPE_INVALID);
680
681 wpa_s = wpa_supplicant_get_iface(global, ifname);
682 if (wpa_s == NULL)
683 return wpas_dbus_error_iface_unknown(message);
684
685 path = wpa_s->dbus_new_path;
686 reply = dbus_message_new_method_return(message);
687 if (reply == NULL)
688 return dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
689 NULL);
690 if (!dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH, &path,
691 DBUS_TYPE_INVALID)) {
692 dbus_message_unref(reply);
693 return dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
694 NULL);
695 }
696
697 return reply;
698 }
699
700
701 /**
702 * wpas_dbus_getter_debug_level - Get debug level
703 * @iter: Pointer to incoming dbus message iter
704 * @error: Location to store error on failure
705 * @user_data: Function specific data
706 * Returns: TRUE on success, FALSE on failure
707 *
708 * Getter for "DebugLevel" property.
709 */
710 dbus_bool_t wpas_dbus_getter_debug_level(DBusMessageIter *iter,
711 DBusError *error,
712 void *user_data)
713 {
714 const char *str;
715 int idx = wpa_debug_level;
716
717 if (idx < 0)
718 idx = 0;
719 if (idx > 5)
720 idx = 5;
721 str = debug_strings[idx];
722 return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING,
723 &str, error);
724 }
725
726
727 /**
728 * wpas_dbus_getter_debug_timestamp - Get debug timestamp
729 * @iter: Pointer to incoming dbus message iter
730 * @error: Location to store error on failure
731 * @user_data: Function specific data
732 * Returns: TRUE on success, FALSE on failure
733 *
734 * Getter for "DebugTimestamp" property.
735 */
736 dbus_bool_t wpas_dbus_getter_debug_timestamp(DBusMessageIter *iter,
737 DBusError *error,
738 void *user_data)
739 {
740 return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_BOOLEAN,
741 &wpa_debug_timestamp, error);
742
743 }
744
745
746 /**
747 * wpas_dbus_getter_debug_show_keys - Get debug show keys
748 * @iter: Pointer to incoming dbus message iter
749 * @error: Location to store error on failure
750 * @user_data: Function specific data
751 * Returns: TRUE on success, FALSE on failure
752 *
753 * Getter for "DebugShowKeys" property.
754 */
755 dbus_bool_t wpas_dbus_getter_debug_show_keys(DBusMessageIter *iter,
756 DBusError *error,
757 void *user_data)
758 {
759 return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_BOOLEAN,
760 &wpa_debug_show_keys, error);
761
762 }
763
764 /**
765 * wpas_dbus_setter_debug_level - Set debug level
766 * @iter: Pointer to incoming dbus message iter
767 * @error: Location to store error on failure
768 * @user_data: Function specific data
769 * Returns: TRUE on success, FALSE on failure
770 *
771 * Setter for "DebugLevel" property.
772 */
773 dbus_bool_t wpas_dbus_setter_debug_level(DBusMessageIter *iter,
774 DBusError *error, void *user_data)
775 {
776 struct wpa_global *global = user_data;
777 const char *str = NULL;
778 int i, val = -1;
779
780 if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_STRING,
781 &str))
782 return FALSE;
783
784 for (i = 0; debug_strings[i]; i++)
785 if (os_strcmp(debug_strings[i], str) == 0) {
786 val = i;
787 break;
788 }
789
790 if (val < 0 ||
791 wpa_supplicant_set_debug_params(global, val, wpa_debug_timestamp,
792 wpa_debug_show_keys)) {
793 dbus_set_error_const(error, DBUS_ERROR_FAILED, "wrong debug "
794 "level value");
795 return FALSE;
796 }
797
798 return TRUE;
799 }
800
801
802 /**
803 * wpas_dbus_setter_debug_timestamp - Set debug timestamp
804 * @iter: Pointer to incoming dbus message iter
805 * @error: Location to store error on failure
806 * @user_data: Function specific data
807 * Returns: TRUE on success, FALSE on failure
808 *
809 * Setter for "DebugTimestamp" property.
810 */
811 dbus_bool_t wpas_dbus_setter_debug_timestamp(DBusMessageIter *iter,
812 DBusError *error,
813 void *user_data)
814 {
815 struct wpa_global *global = user_data;
816 dbus_bool_t val;
817
818 if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_BOOLEAN,
819 &val))
820 return FALSE;
821
822 wpa_supplicant_set_debug_params(global, wpa_debug_level, val ? 1 : 0,
823 wpa_debug_show_keys);
824 return TRUE;
825 }
826
827
828 /**
829 * wpas_dbus_setter_debug_show_keys - Set debug show keys
830 * @iter: Pointer to incoming dbus message iter
831 * @error: Location to store error on failure
832 * @user_data: Function specific data
833 * Returns: TRUE on success, FALSE on failure
834 *
835 * Setter for "DebugShowKeys" property.
836 */
837 dbus_bool_t wpas_dbus_setter_debug_show_keys(DBusMessageIter *iter,
838 DBusError *error,
839 void *user_data)
840 {
841 struct wpa_global *global = user_data;
842 dbus_bool_t val;
843
844 if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_BOOLEAN,
845 &val))
846 return FALSE;
847
848 wpa_supplicant_set_debug_params(global, wpa_debug_level,
849 wpa_debug_timestamp,
850 val ? 1 : 0);
851 return TRUE;
852 }
853
854
855 /**
856 * wpas_dbus_getter_interfaces - Request registered interfaces list
857 * @iter: Pointer to incoming dbus message iter
858 * @error: Location to store error on failure
859 * @user_data: Function specific data
860 * Returns: TRUE on success, FALSE on failure
861 *
862 * Getter for "Interfaces" property. Handles requests
863 * by dbus clients to return list of registered interfaces objects
864 * paths
865 */
866 dbus_bool_t wpas_dbus_getter_interfaces(DBusMessageIter *iter,
867 DBusError *error,
868 void *user_data)
869 {
870 struct wpa_global *global = user_data;
871 struct wpa_supplicant *wpa_s;
872 const char **paths;
873 unsigned int i = 0, num = 0;
874 dbus_bool_t success;
875
876 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next)
877 num++;
878
879 paths = os_zalloc(num * sizeof(char*));
880 if (!paths) {
881 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
882 return FALSE;
883 }
884
885 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next)
886 paths[i++] = wpa_s->dbus_new_path;
887
888 success = wpas_dbus_simple_array_property_getter(iter,
889 DBUS_TYPE_OBJECT_PATH,
890 paths, num, error);
891
892 os_free(paths);
893 return success;
894 }
895
896
897 /**
898 * wpas_dbus_getter_eap_methods - Request supported EAP methods list
899 * @iter: Pointer to incoming dbus message iter
900 * @error: Location to store error on failure
901 * @user_data: Function specific data
902 * Returns: TRUE on success, FALSE on failure
903 *
904 * Getter for "EapMethods" property. Handles requests
905 * by dbus clients to return list of strings with supported EAP methods
906 */
907 dbus_bool_t wpas_dbus_getter_eap_methods(DBusMessageIter *iter,
908 DBusError *error, void *user_data)
909 {
910 char **eap_methods;
911 size_t num_items = 0;
912 dbus_bool_t success;
913
914 eap_methods = eap_get_names_as_string_array(&num_items);
915 if (!eap_methods) {
916 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
917 return FALSE;
918 }
919
920 success = wpas_dbus_simple_array_property_getter(iter,
921 DBUS_TYPE_STRING,
922 eap_methods,
923 num_items, error);
924
925 while (num_items)
926 os_free(eap_methods[--num_items]);
927 os_free(eap_methods);
928 return success;
929 }
930
931
932 static int wpas_dbus_get_scan_type(DBusMessage *message, DBusMessageIter *var,
933 char **type, DBusMessage **reply)
934 {
935 if (dbus_message_iter_get_arg_type(var) != DBUS_TYPE_STRING) {
936 wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: "
937 "Type must be a string");
938 *reply = wpas_dbus_error_invalid_args(
939 message, "Wrong Type value type. String required");
940 return -1;
941 }
942 dbus_message_iter_get_basic(var, type);
943 return 0;
944 }
945
946
947 static int wpas_dbus_get_scan_ssids(DBusMessage *message, DBusMessageIter *var,
948 struct wpa_driver_scan_params *params,
949 DBusMessage **reply)
950 {
951 struct wpa_driver_scan_ssid *ssids = params->ssids;
952 size_t ssids_num = 0;
953 u8 *ssid;
954 DBusMessageIter array_iter, sub_array_iter;
955 char *val;
956 int len;
957
958 if (dbus_message_iter_get_arg_type(var) != DBUS_TYPE_ARRAY) {
959 wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: ssids "
960 "must be an array of arrays of bytes");
961 *reply = wpas_dbus_error_invalid_args(
962 message, "Wrong SSIDs value type. Array of arrays of "
963 "bytes required");
964 return -1;
965 }
966
967 dbus_message_iter_recurse(var, &array_iter);
968
969 if (dbus_message_iter_get_arg_type(&array_iter) != DBUS_TYPE_ARRAY ||
970 dbus_message_iter_get_element_type(&array_iter) != DBUS_TYPE_BYTE)
971 {
972 wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: ssids "
973 "must be an array of arrays of bytes");
974 *reply = wpas_dbus_error_invalid_args(
975 message, "Wrong SSIDs value type. Array of arrays of "
976 "bytes required");
977 return -1;
978 }
979
980 while (dbus_message_iter_get_arg_type(&array_iter) == DBUS_TYPE_ARRAY)
981 {
982 if (ssids_num >= WPAS_MAX_SCAN_SSIDS) {
983 wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: "
984 "Too many ssids specified on scan dbus "
985 "call");
986 *reply = wpas_dbus_error_invalid_args(
987 message, "Too many ssids specified. Specify "
988 "at most four");
989 return -1;
990 }
991
992 dbus_message_iter_recurse(&array_iter, &sub_array_iter);
993
994 dbus_message_iter_get_fixed_array(&sub_array_iter, &val, &len);
995
996 if (len > MAX_SSID_LEN) {
997 wpa_printf(MSG_DEBUG,
998 "wpas_dbus_handler_scan[dbus]: "
999 "SSID too long (len=%d max_len=%d)",
1000 len, MAX_SSID_LEN);
1001 *reply = wpas_dbus_error_invalid_args(
1002 message, "Invalid SSID: too long");
1003 return -1;
1004 }
1005
1006 if (len != 0) {
1007 ssid = os_malloc(len);
1008 if (ssid == NULL) {
1009 wpa_printf(MSG_DEBUG,
1010 "wpas_dbus_handler_scan[dbus]: "
1011 "out of memory. Cannot allocate "
1012 "memory for SSID");
1013 *reply = dbus_message_new_error(
1014 message, DBUS_ERROR_NO_MEMORY, NULL);
1015 return -1;
1016 }
1017 os_memcpy(ssid, val, len);
1018 } else {
1019 /* Allow zero-length SSIDs */
1020 ssid = NULL;
1021 }
1022
1023 ssids[ssids_num].ssid = ssid;
1024 ssids[ssids_num].ssid_len = len;
1025
1026 dbus_message_iter_next(&array_iter);
1027 ssids_num++;
1028 }
1029
1030 params->num_ssids = ssids_num;
1031 return 0;
1032 }
1033
1034
1035 static int wpas_dbus_get_scan_ies(DBusMessage *message, DBusMessageIter *var,
1036 struct wpa_driver_scan_params *params,
1037 DBusMessage **reply)
1038 {
1039 u8 *ies = NULL, *nies;
1040 int ies_len = 0;
1041 DBusMessageIter array_iter, sub_array_iter;
1042 char *val;
1043 int len;
1044
1045 if (dbus_message_iter_get_arg_type(var) != DBUS_TYPE_ARRAY) {
1046 wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: ies must "
1047 "be an array of arrays of bytes");
1048 *reply = wpas_dbus_error_invalid_args(
1049 message, "Wrong IEs value type. Array of arrays of "
1050 "bytes required");
1051 return -1;
1052 }
1053
1054 dbus_message_iter_recurse(var, &array_iter);
1055
1056 if (dbus_message_iter_get_arg_type(&array_iter) != DBUS_TYPE_ARRAY ||
1057 dbus_message_iter_get_element_type(&array_iter) != DBUS_TYPE_BYTE)
1058 {
1059 wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: ies must "
1060 "be an array of arrays of bytes");
1061 *reply = wpas_dbus_error_invalid_args(
1062 message, "Wrong IEs value type. Array required");
1063 return -1;
1064 }
1065
1066 while (dbus_message_iter_get_arg_type(&array_iter) == DBUS_TYPE_ARRAY)
1067 {
1068 dbus_message_iter_recurse(&array_iter, &sub_array_iter);
1069
1070 dbus_message_iter_get_fixed_array(&sub_array_iter, &val, &len);
1071 if (len == 0) {
1072 dbus_message_iter_next(&array_iter);
1073 continue;
1074 }
1075
1076 nies = os_realloc(ies, ies_len + len);
1077 if (nies == NULL) {
1078 wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: "
1079 "out of memory. Cannot allocate memory for "
1080 "IE");
1081 os_free(ies);
1082 *reply = dbus_message_new_error(
1083 message, DBUS_ERROR_NO_MEMORY, NULL);
1084 return -1;
1085 }
1086 ies = nies;
1087 os_memcpy(ies + ies_len, val, len);
1088 ies_len += len;
1089
1090 dbus_message_iter_next(&array_iter);
1091 }
1092
1093 params->extra_ies = ies;
1094 params->extra_ies_len = ies_len;
1095 return 0;
1096 }
1097
1098
1099 static int wpas_dbus_get_scan_channels(DBusMessage *message,
1100 DBusMessageIter *var,
1101 struct wpa_driver_scan_params *params,
1102 DBusMessage **reply)
1103 {
1104 DBusMessageIter array_iter, sub_array_iter;
1105 int *freqs = NULL, *nfreqs;
1106 int freqs_num = 0;
1107
1108 if (dbus_message_iter_get_arg_type(var) != DBUS_TYPE_ARRAY) {
1109 wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: "
1110 "Channels must be an array of structs");
1111 *reply = wpas_dbus_error_invalid_args(
1112 message, "Wrong Channels value type. Array of structs "
1113 "required");
1114 return -1;
1115 }
1116
1117 dbus_message_iter_recurse(var, &array_iter);
1118
1119 if (dbus_message_iter_get_arg_type(&array_iter) != DBUS_TYPE_STRUCT) {
1120 wpa_printf(MSG_DEBUG,
1121 "wpas_dbus_handler_scan[dbus]: Channels must be an "
1122 "array of structs");
1123 *reply = wpas_dbus_error_invalid_args(
1124 message, "Wrong Channels value type. Array of structs "
1125 "required");
1126 return -1;
1127 }
1128
1129 while (dbus_message_iter_get_arg_type(&array_iter) == DBUS_TYPE_STRUCT)
1130 {
1131 int freq, width;
1132
1133 dbus_message_iter_recurse(&array_iter, &sub_array_iter);
1134
1135 if (dbus_message_iter_get_arg_type(&sub_array_iter) !=
1136 DBUS_TYPE_UINT32) {
1137 wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: "
1138 "Channel must by specified by struct of "
1139 "two UINT32s %c",
1140 dbus_message_iter_get_arg_type(
1141 &sub_array_iter));
1142 *reply = wpas_dbus_error_invalid_args(
1143 message, "Wrong Channel struct. Two UINT32s "
1144 "required");
1145 os_free(freqs);
1146 return -1;
1147 }
1148 dbus_message_iter_get_basic(&sub_array_iter, &freq);
1149
1150 if (!dbus_message_iter_next(&sub_array_iter) ||
1151 dbus_message_iter_get_arg_type(&sub_array_iter) !=
1152 DBUS_TYPE_UINT32) {
1153 wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: "
1154 "Channel must by specified by struct of "
1155 "two UINT32s");
1156 *reply = wpas_dbus_error_invalid_args(
1157 message,
1158 "Wrong Channel struct. Two UINT32s required");
1159 os_free(freqs);
1160 return -1;
1161 }
1162
1163 dbus_message_iter_get_basic(&sub_array_iter, &width);
1164
1165 #define FREQS_ALLOC_CHUNK 32
1166 if (freqs_num % FREQS_ALLOC_CHUNK == 0) {
1167 nfreqs = os_realloc(freqs, sizeof(int) *
1168 (freqs_num + FREQS_ALLOC_CHUNK));
1169 if (nfreqs == NULL)
1170 os_free(freqs);
1171 freqs = nfreqs;
1172 }
1173 if (freqs == NULL) {
1174 wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: "
1175 "out of memory. can't allocate memory for "
1176 "freqs");
1177 *reply = dbus_message_new_error(
1178 message, DBUS_ERROR_NO_MEMORY, NULL);
1179 return -1;
1180 }
1181
1182 freqs[freqs_num] = freq;
1183
1184 freqs_num++;
1185 dbus_message_iter_next(&array_iter);
1186 }
1187
1188 nfreqs = os_realloc(freqs,
1189 sizeof(int) * (freqs_num + 1));
1190 if (nfreqs == NULL)
1191 os_free(freqs);
1192 freqs = nfreqs;
1193 if (freqs == NULL) {
1194 wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: "
1195 "out of memory. Can't allocate memory for freqs");
1196 *reply = dbus_message_new_error(
1197 message, DBUS_ERROR_NO_MEMORY, NULL);
1198 return -1;
1199 }
1200 freqs[freqs_num] = 0;
1201
1202 params->freqs = freqs;
1203 return 0;
1204 }
1205
1206
1207 /**
1208 * wpas_dbus_handler_scan - Request a wireless scan on an interface
1209 * @message: Pointer to incoming dbus message
1210 * @wpa_s: wpa_supplicant structure for a network interface
1211 * Returns: NULL indicating success or DBus error message on failure
1212 *
1213 * Handler function for "Scan" method call of a network device. Requests
1214 * that wpa_supplicant perform a wireless scan as soon as possible
1215 * on a particular wireless interface.
1216 */
1217 DBusMessage * wpas_dbus_handler_scan(DBusMessage *message,
1218 struct wpa_supplicant *wpa_s)
1219 {
1220 DBusMessage *reply = NULL;
1221 DBusMessageIter iter, dict_iter, entry_iter, variant_iter;
1222 char *key = NULL, *type = NULL;
1223 struct wpa_driver_scan_params params;
1224 size_t i;
1225
1226 os_memset(&params, 0, sizeof(params));
1227
1228 dbus_message_iter_init(message, &iter);
1229
1230 dbus_message_iter_recurse(&iter, &dict_iter);
1231
1232 while (dbus_message_iter_get_arg_type(&dict_iter) ==
1233 DBUS_TYPE_DICT_ENTRY) {
1234 dbus_message_iter_recurse(&dict_iter, &entry_iter);
1235 dbus_message_iter_get_basic(&entry_iter, &key);
1236 dbus_message_iter_next(&entry_iter);
1237 dbus_message_iter_recurse(&entry_iter, &variant_iter);
1238
1239 if (os_strcmp(key, "Type") == 0) {
1240 if (wpas_dbus_get_scan_type(message, &variant_iter,
1241 &type, &reply) < 0)
1242 goto out;
1243 } else if (os_strcmp(key, "SSIDs") == 0) {
1244 if (wpas_dbus_get_scan_ssids(message, &variant_iter,
1245 &params, &reply) < 0)
1246 goto out;
1247 } else if (os_strcmp(key, "IEs") == 0) {
1248 if (wpas_dbus_get_scan_ies(message, &variant_iter,
1249 &params, &reply) < 0)
1250 goto out;
1251 } else if (os_strcmp(key, "Channels") == 0) {
1252 if (wpas_dbus_get_scan_channels(message, &variant_iter,
1253 &params, &reply) < 0)
1254 goto out;
1255 } else {
1256 wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: "
1257 "Unknown argument %s", key);
1258 reply = wpas_dbus_error_invalid_args(message, key);
1259 goto out;
1260 }
1261
1262 dbus_message_iter_next(&dict_iter);
1263 }
1264
1265 if (!type) {
1266 wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: "
1267 "Scan type not specified");
1268 reply = wpas_dbus_error_invalid_args(message, key);
1269 goto out;
1270 }
1271
1272 if (!os_strcmp(type, "passive")) {
1273 if (params.num_ssids || params.extra_ies_len) {
1274 wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: "
1275 "SSIDs or IEs specified for passive scan.");
1276 reply = wpas_dbus_error_invalid_args(
1277 message, "You can specify only Channels in "
1278 "passive scan");
1279 goto out;
1280 } else if (params.freqs && params.freqs[0]) {
1281 wpa_supplicant_trigger_scan(wpa_s, &params);
1282 } else {
1283 wpa_s->scan_req = 2;
1284 wpa_supplicant_req_scan(wpa_s, 0, 0);
1285 }
1286 } else if (!os_strcmp(type, "active")) {
1287 if (!params.num_ssids) {
1288 /* Add wildcard ssid */
1289 params.num_ssids++;
1290 }
1291 #ifdef CONFIG_AUTOSCAN
1292 autoscan_deinit(wpa_s);
1293 #endif /* CONFIG_AUTOSCAN */
1294 wpa_supplicant_trigger_scan(wpa_s, &params);
1295 } else {
1296 wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: "
1297 "Unknown scan type: %s", type);
1298 reply = wpas_dbus_error_invalid_args(message,
1299 "Wrong scan type");
1300 goto out;
1301 }
1302
1303 out:
1304 for (i = 0; i < WPAS_MAX_SCAN_SSIDS; i++)
1305 os_free((u8 *) params.ssids[i].ssid);
1306 os_free((u8 *) params.extra_ies);
1307 os_free(params.freqs);
1308 return reply;
1309 }
1310
1311
1312 /*
1313 * wpas_dbus_handler_disconnect - Terminate the current connection
1314 * @message: Pointer to incoming dbus message
1315 * @wpa_s: wpa_supplicant structure for a network interface
1316 * Returns: NotConnected DBus error message if already not connected
1317 * or NULL otherwise.
1318 *
1319 * Handler function for "Disconnect" method call of network interface.
1320 */
1321 DBusMessage * wpas_dbus_handler_disconnect(DBusMessage *message,
1322 struct wpa_supplicant *wpa_s)
1323 {
1324 if (wpa_s->current_ssid != NULL) {
1325 wpa_s->disconnected = 1;
1326 wpa_supplicant_deauthenticate(wpa_s,
1327 WLAN_REASON_DEAUTH_LEAVING);
1328
1329 return NULL;
1330 }
1331
1332 return dbus_message_new_error(message, WPAS_DBUS_ERROR_NOT_CONNECTED,
1333 "This interface is not connected");
1334 }
1335
1336
1337 /**
1338 * wpas_dbus_new_iface_add_network - Add a new configured network
1339 * @message: Pointer to incoming dbus message
1340 * @wpa_s: wpa_supplicant structure for a network interface
1341 * Returns: A dbus message containing the object path of the new network
1342 *
1343 * Handler function for "AddNetwork" method call of a network interface.
1344 */
1345 DBusMessage * wpas_dbus_handler_add_network(DBusMessage *message,
1346 struct wpa_supplicant *wpa_s)
1347 {
1348 DBusMessage *reply = NULL;
1349 DBusMessageIter iter;
1350 struct wpa_ssid *ssid = NULL;
1351 char path_buf[WPAS_DBUS_OBJECT_PATH_MAX], *path = path_buf;
1352 DBusError error;
1353
1354 dbus_message_iter_init(message, &iter);
1355
1356 ssid = wpa_config_add_network(wpa_s->conf);
1357 if (ssid == NULL) {
1358 wpa_printf(MSG_ERROR, "wpas_dbus_handler_add_network[dbus]: "
1359 "can't add new interface.");
1360 reply = wpas_dbus_error_unknown_error(
1361 message,
1362 "wpa_supplicant could not add "
1363 "a network on this interface.");
1364 goto err;
1365 }
1366 wpas_notify_network_added(wpa_s, ssid);
1367 ssid->disabled = 1;
1368 wpa_config_set_network_defaults(ssid);
1369
1370 dbus_error_init(&error);
1371 if (!set_network_properties(wpa_s, ssid, &iter, &error)) {
1372 wpa_printf(MSG_DEBUG, "wpas_dbus_handler_add_network[dbus]:"
1373 "control interface couldn't set network "
1374 "properties");
1375 reply = wpas_dbus_reply_new_from_error(message, &error,
1376 DBUS_ERROR_INVALID_ARGS,
1377 "Failed to add network");
1378 dbus_error_free(&error);
1379 goto err;
1380 }
1381
1382 /* Construct the object path for this network. */
1383 os_snprintf(path, WPAS_DBUS_OBJECT_PATH_MAX,
1384 "%s/" WPAS_DBUS_NEW_NETWORKS_PART "/%d",
1385 wpa_s->dbus_new_path, ssid->id);
1386
1387 reply = dbus_message_new_method_return(message);
1388 if (reply == NULL) {
1389 reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
1390 NULL);
1391 goto err;
1392 }
1393 if (!dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH, &path,
1394 DBUS_TYPE_INVALID)) {
1395 dbus_message_unref(reply);
1396 reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
1397 NULL);
1398 goto err;
1399 }
1400
1401 return reply;
1402
1403 err:
1404 if (ssid) {
1405 wpas_notify_network_removed(wpa_s, ssid);
1406 wpa_config_remove_network(wpa_s->conf, ssid->id);
1407 }
1408 return reply;
1409 }
1410
1411
1412 /**
1413 * wpas_dbus_handler_remove_network - Remove a configured network
1414 * @message: Pointer to incoming dbus message
1415 * @wpa_s: wpa_supplicant structure for a network interface
1416 * Returns: NULL on success or dbus error on failure
1417 *
1418 * Handler function for "RemoveNetwork" method call of a network interface.
1419 */
1420 DBusMessage * wpas_dbus_handler_remove_network(DBusMessage *message,
1421 struct wpa_supplicant *wpa_s)
1422 {
1423 DBusMessage *reply = NULL;
1424 const char *op;
1425 char *iface = NULL, *net_id = NULL;
1426 int id;
1427 struct wpa_ssid *ssid;
1428
1429 dbus_message_get_args(message, NULL, DBUS_TYPE_OBJECT_PATH, &op,
1430 DBUS_TYPE_INVALID);
1431
1432 /* Extract the network ID and ensure the network */
1433 /* is actually a child of this interface */
1434 iface = wpas_dbus_new_decompose_object_path(op, 0, &net_id, NULL);
1435 if (iface == NULL || os_strcmp(iface, wpa_s->dbus_new_path) != 0) {
1436 reply = wpas_dbus_error_invalid_args(message, op);
1437 goto out;
1438 }
1439
1440 id = strtoul(net_id, NULL, 10);
1441 if (errno == EINVAL) {
1442 reply = wpas_dbus_error_invalid_args(message, op);
1443 goto out;
1444 }
1445
1446 ssid = wpa_config_get_network(wpa_s->conf, id);
1447 if (ssid == NULL) {
1448 reply = wpas_dbus_error_network_unknown(message);
1449 goto out;
1450 }
1451
1452 wpas_notify_network_removed(wpa_s, ssid);
1453
1454 if (wpa_config_remove_network(wpa_s->conf, id) < 0) {
1455 wpa_printf(MSG_ERROR,
1456 "wpas_dbus_handler_remove_network[dbus]: "
1457 "error occurred when removing network %d", id);
1458 reply = wpas_dbus_error_unknown_error(
1459 message, "error removing the specified network on "
1460 "this interface.");
1461 goto out;
1462 }
1463
1464 if (ssid == wpa_s->current_ssid)
1465 wpa_supplicant_deauthenticate(wpa_s,
1466 WLAN_REASON_DEAUTH_LEAVING);
1467
1468 out:
1469 os_free(iface);
1470 os_free(net_id);
1471 return reply;
1472 }
1473
1474
1475 static void remove_network(void *arg, struct wpa_ssid *ssid)
1476 {
1477 struct wpa_supplicant *wpa_s = arg;
1478
1479 wpas_notify_network_removed(wpa_s, ssid);
1480
1481 if (wpa_config_remove_network(wpa_s->conf, ssid->id) < 0) {
1482 wpa_printf(MSG_ERROR,
1483 "wpas_dbus_handler_remove_all_networks[dbus]: "
1484 "error occurred when removing network %d",
1485 ssid->id);
1486 return;
1487 }
1488
1489 if (ssid == wpa_s->current_ssid)
1490 wpa_supplicant_disassociate(wpa_s, WLAN_REASON_DEAUTH_LEAVING);
1491 }
1492
1493
1494 /**
1495 * wpas_dbus_handler_remove_all_networks - Remove all configured networks
1496 * @message: Pointer to incoming dbus message
1497 * @wpa_s: wpa_supplicant structure for a network interface
1498 * Returns: NULL on success or dbus error on failure
1499 *
1500 * Handler function for "RemoveAllNetworks" method call of a network interface.
1501 */
1502 DBusMessage * wpas_dbus_handler_remove_all_networks(
1503 DBusMessage *message, struct wpa_supplicant *wpa_s)
1504 {
1505 /* NB: could check for failure and return an error */
1506 wpa_config_foreach_network(wpa_s->conf, remove_network, wpa_s);
1507 return NULL;
1508 }
1509
1510
1511 /**
1512 * wpas_dbus_handler_select_network - Attempt association with a network
1513 * @message: Pointer to incoming dbus message
1514 * @wpa_s: wpa_supplicant structure for a network interface
1515 * Returns: NULL on success or dbus error on failure
1516 *
1517 * Handler function for "SelectNetwork" method call of network interface.
1518 */
1519 DBusMessage * wpas_dbus_handler_select_network(DBusMessage *message,
1520 struct wpa_supplicant *wpa_s)
1521 {
1522 DBusMessage *reply = NULL;
1523 const char *op;
1524 char *iface = NULL, *net_id = NULL;
1525 int id;
1526 struct wpa_ssid *ssid;
1527
1528 dbus_message_get_args(message, NULL, DBUS_TYPE_OBJECT_PATH, &op,
1529 DBUS_TYPE_INVALID);
1530
1531 /* Extract the network ID and ensure the network */
1532 /* is actually a child of this interface */
1533 iface = wpas_dbus_new_decompose_object_path(op, 0, &net_id, NULL);
1534 if (iface == NULL || os_strcmp(iface, wpa_s->dbus_new_path) != 0) {
1535 reply = wpas_dbus_error_invalid_args(message, op);
1536 goto out;
1537 }
1538
1539 id = strtoul(net_id, NULL, 10);
1540 if (errno == EINVAL) {
1541 reply = wpas_dbus_error_invalid_args(message, op);
1542 goto out;
1543 }
1544
1545 ssid = wpa_config_get_network(wpa_s->conf, id);
1546 if (ssid == NULL) {
1547 reply = wpas_dbus_error_network_unknown(message);
1548 goto out;
1549 }
1550
1551 /* Finally, associate with the network */
1552 wpa_supplicant_select_network(wpa_s, ssid);
1553
1554 out:
1555 os_free(iface);
1556 os_free(net_id);
1557 return reply;
1558 }
1559
1560
1561 /**
1562 * wpas_dbus_handler_network_reply - Reply to a NetworkRequest signal
1563 * @message: Pointer to incoming dbus message
1564 * @wpa_s: wpa_supplicant structure for a network interface
1565 * Returns: NULL on success or dbus error on failure
1566 *
1567 * Handler function for "NetworkReply" method call of network interface.
1568 */
1569 DBusMessage * wpas_dbus_handler_network_reply(DBusMessage *message,
1570 struct wpa_supplicant *wpa_s)
1571 {
1572 #ifdef IEEE8021X_EAPOL
1573 DBusMessage *reply = NULL;
1574 const char *op, *field, *value;
1575 char *iface = NULL, *net_id = NULL;
1576 int id;
1577 struct wpa_ssid *ssid;
1578
1579 if (!dbus_message_get_args(message, NULL,
1580 DBUS_TYPE_OBJECT_PATH, &op,
1581 DBUS_TYPE_STRING, &field,
1582 DBUS_TYPE_STRING, &value,
1583 DBUS_TYPE_INVALID))
1584 return wpas_dbus_error_invalid_args(message, NULL);
1585
1586 /* Extract the network ID and ensure the network */
1587 /* is actually a child of this interface */
1588 iface = wpas_dbus_new_decompose_object_path(op, 0, &net_id, NULL);
1589 if (iface == NULL || os_strcmp(iface, wpa_s->dbus_new_path) != 0) {
1590 reply = wpas_dbus_error_invalid_args(message, op);
1591 goto out;
1592 }
1593
1594 id = strtoul(net_id, NULL, 10);
1595 if (errno == EINVAL) {
1596 reply = wpas_dbus_error_invalid_args(message, net_id);
1597 goto out;
1598 }
1599
1600 ssid = wpa_config_get_network(wpa_s->conf, id);
1601 if (ssid == NULL) {
1602 reply = wpas_dbus_error_network_unknown(message);
1603 goto out;
1604 }
1605
1606 if (wpa_supplicant_ctrl_iface_ctrl_rsp_handle(wpa_s, ssid,
1607 field, value) < 0)
1608 reply = wpas_dbus_error_invalid_args(message, field);
1609 else {
1610 /* Tell EAP to retry immediately */
1611 eapol_sm_notify_ctrl_response(wpa_s->eapol);
1612 }
1613
1614 out:
1615 os_free(iface);
1616 os_free(net_id);
1617 return reply;
1618 #else /* IEEE8021X_EAPOL */
1619 wpa_printf(MSG_DEBUG, "CTRL_IFACE: 802.1X not included");
1620 return wpas_dbus_error_unknown_error(message, "802.1X not included");
1621 #endif /* IEEE8021X_EAPOL */
1622 }
1623
1624
1625 /**
1626 * wpas_dbus_handler_add_blob - Store named binary blob (ie, for certificates)
1627 * @message: Pointer to incoming dbus message
1628 * @wpa_s: %wpa_supplicant data structure
1629 * Returns: A dbus message containing an error on failure or NULL on success
1630 *
1631 * Asks wpa_supplicant to internally store a binary blobs.
1632 */
1633 DBusMessage * wpas_dbus_handler_add_blob(DBusMessage *message,
1634 struct wpa_supplicant *wpa_s)
1635 {
1636 DBusMessage *reply = NULL;
1637 DBusMessageIter iter, array_iter;
1638
1639 char *blob_name;
1640 u8 *blob_data;
1641 int blob_len;
1642 struct wpa_config_blob *blob = NULL;
1643
1644 dbus_message_iter_init(message, &iter);
1645 dbus_message_iter_get_basic(&iter, &blob_name);
1646
1647 if (wpa_config_get_blob(wpa_s->conf, blob_name)) {
1648 return dbus_message_new_error(message,
1649 WPAS_DBUS_ERROR_BLOB_EXISTS,
1650 NULL);
1651 }
1652
1653 dbus_message_iter_next(&iter);
1654 dbus_message_iter_recurse(&iter, &array_iter);
1655
1656 dbus_message_iter_get_fixed_array(&array_iter, &blob_data, &blob_len);
1657
1658 blob = os_zalloc(sizeof(*blob));
1659 if (!blob) {
1660 reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
1661 NULL);
1662 goto err;
1663 }
1664
1665 blob->data = os_malloc(blob_len);
1666 if (!blob->data) {
1667 reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
1668 NULL);
1669 goto err;
1670 }
1671 os_memcpy(blob->data, blob_data, blob_len);
1672
1673 blob->len = blob_len;
1674 blob->name = os_strdup(blob_name);
1675 if (!blob->name) {
1676 reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
1677 NULL);
1678 goto err;
1679 }
1680
1681 wpa_config_set_blob(wpa_s->conf, blob);
1682 wpas_notify_blob_added(wpa_s, blob->name);
1683
1684 return reply;
1685
1686 err:
1687 if (blob) {
1688 os_free(blob->name);
1689 os_free(blob->data);
1690 os_free(blob);
1691 }
1692 return reply;
1693 }
1694
1695
1696 /**
1697 * wpas_dbus_handler_get_blob - Get named binary blob (ie, for certificates)
1698 * @message: Pointer to incoming dbus message
1699 * @wpa_s: %wpa_supplicant data structure
1700 * Returns: A dbus message containing array of bytes (blob)
1701 *
1702 * Gets one wpa_supplicant's binary blobs.
1703 */
1704 DBusMessage * wpas_dbus_handler_get_blob(DBusMessage *message,
1705 struct wpa_supplicant *wpa_s)
1706 {
1707 DBusMessage *reply = NULL;
1708 DBusMessageIter iter, array_iter;
1709
1710 char *blob_name;
1711 const struct wpa_config_blob *blob;
1712
1713 dbus_message_get_args(message, NULL, DBUS_TYPE_STRING, &blob_name,
1714 DBUS_TYPE_INVALID);
1715
1716 blob = wpa_config_get_blob(wpa_s->conf, blob_name);
1717 if (!blob) {
1718 return dbus_message_new_error(message,
1719 WPAS_DBUS_ERROR_BLOB_UNKNOWN,
1720 "Blob id not set");
1721 }
1722
1723 reply = dbus_message_new_method_return(message);
1724 if (!reply) {
1725 reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
1726 NULL);
1727 goto out;
1728 }
1729
1730 dbus_message_iter_init_append(reply, &iter);
1731
1732 if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
1733 DBUS_TYPE_BYTE_AS_STRING,
1734 &array_iter)) {
1735 dbus_message_unref(reply);
1736 reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
1737 NULL);
1738 goto out;
1739 }
1740
1741 if (!dbus_message_iter_append_fixed_array(&array_iter, DBUS_TYPE_BYTE,
1742 &(blob->data), blob->len)) {
1743 dbus_message_unref(reply);
1744 reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
1745 NULL);
1746 goto out;
1747 }
1748
1749 if (!dbus_message_iter_close_container(&iter, &array_iter)) {
1750 dbus_message_unref(reply);
1751 reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
1752 NULL);
1753 goto out;
1754 }
1755
1756 out:
1757 return reply;
1758 }
1759
1760
1761 /**
1762 * wpas_remove_handler_remove_blob - Remove named binary blob
1763 * @message: Pointer to incoming dbus message
1764 * @wpa_s: %wpa_supplicant data structure
1765 * Returns: NULL on success or dbus error
1766 *
1767 * Asks wpa_supplicant to internally remove a binary blobs.
1768 */
1769 DBusMessage * wpas_dbus_handler_remove_blob(DBusMessage *message,
1770 struct wpa_supplicant *wpa_s)
1771 {
1772 DBusMessage *reply = NULL;
1773 char *blob_name;
1774
1775 dbus_message_get_args(message, NULL, DBUS_TYPE_STRING, &blob_name,
1776 DBUS_TYPE_INVALID);
1777
1778 if (wpa_config_remove_blob(wpa_s->conf, blob_name)) {
1779 return dbus_message_new_error(message,
1780 WPAS_DBUS_ERROR_BLOB_UNKNOWN,
1781 "Blob id not set");
1782 }
1783 wpas_notify_blob_removed(wpa_s, blob_name);
1784
1785 return reply;
1786
1787 }
1788
1789 /*
1790 * wpas_dbus_handler_flush_bss - Flush the BSS cache
1791 * @message: Pointer to incoming dbus message
1792 * @wpa_s: wpa_supplicant structure for a network interface
1793 * Returns: NULL
1794 *
1795 * Handler function for "FlushBSS" method call of network interface.
1796 */
1797 DBusMessage * wpas_dbus_handler_flush_bss(DBusMessage *message,
1798 struct wpa_supplicant *wpa_s)
1799 {
1800 dbus_uint32_t age;
1801
1802 dbus_message_get_args(message, NULL, DBUS_TYPE_UINT32, &age,
1803 DBUS_TYPE_INVALID);
1804
1805 if (age == 0)
1806 wpa_bss_flush(wpa_s);
1807 else
1808 wpa_bss_flush_by_age(wpa_s, age);
1809
1810 return NULL;
1811 }
1812
1813
1814 #ifdef CONFIG_AUTOSCAN
1815 /**
1816 * wpas_dbus_handler_autoscan - Set autoscan parameters for the interface
1817 * @message: Pointer to incoming dbus message
1818 * @wpa_s: wpa_supplicant structure for a network interface
1819 * Returns: NULL
1820 *
1821 * Handler function for "AutoScan" method call of network interface.
1822 */
1823 DBusMessage * wpas_dbus_handler_autoscan(DBusMessage *message,
1824 struct wpa_supplicant *wpa_s)
1825 {
1826 DBusMessage *reply = NULL;
1827 enum wpa_states state = wpa_s->wpa_state;
1828 char *arg;
1829
1830 dbus_message_get_args(message, NULL, DBUS_TYPE_STRING, &arg,
1831 DBUS_TYPE_INVALID);
1832
1833 if (arg != NULL && os_strlen(arg) > 0) {
1834 char *tmp;
1835 tmp = os_strdup(arg);
1836 if (tmp == NULL) {
1837 reply = dbus_message_new_error(message,
1838 DBUS_ERROR_NO_MEMORY,
1839 NULL);
1840 } else {
1841 os_free(wpa_s->conf->autoscan);
1842 wpa_s->conf->autoscan = tmp;
1843 if (state == WPA_DISCONNECTED || state == WPA_INACTIVE)
1844 autoscan_init(wpa_s, 1);
1845 else if (state == WPA_SCANNING)
1846 wpa_supplicant_reinit_autoscan(wpa_s);
1847 }
1848 } else if (arg != NULL && os_strlen(arg) == 0) {
1849 os_free(wpa_s->conf->autoscan);
1850 wpa_s->conf->autoscan = NULL;
1851 autoscan_deinit(wpa_s);
1852 } else
1853 reply = dbus_message_new_error(message,
1854 DBUS_ERROR_INVALID_ARGS,
1855 NULL);
1856
1857 return reply;
1858 }
1859 #endif /* CONFIG_AUTOSCAN */
1860
1861
1862 /**
1863 * wpas_dbus_getter_capabilities - Return interface capabilities
1864 * @iter: Pointer to incoming dbus message iter
1865 * @error: Location to store error on failure
1866 * @user_data: Function specific data
1867 * Returns: TRUE on success, FALSE on failure
1868 *
1869 * Getter for "Capabilities" property of an interface.
1870 */
1871 dbus_bool_t wpas_dbus_getter_capabilities(DBusMessageIter *iter,
1872 DBusError *error, void *user_data)
1873 {
1874 struct wpa_supplicant *wpa_s = user_data;
1875 struct wpa_driver_capa capa;
1876 int res;
1877 DBusMessageIter iter_dict, iter_dict_entry, iter_dict_val, iter_array,
1878 variant_iter;
1879 const char *scans[] = { "active", "passive", "ssid" };
1880
1881 if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
1882 "a{sv}", &variant_iter))
1883 goto nomem;
1884
1885 if (!wpa_dbus_dict_open_write(&variant_iter, &iter_dict))
1886 goto nomem;
1887
1888 res = wpa_drv_get_capa(wpa_s, &capa);
1889
1890 /***** pairwise cipher */
1891 if (res < 0) {
1892 const char *args[] = {"ccmp", "tkip", "none"};
1893 if (!wpa_dbus_dict_append_string_array(
1894 &iter_dict, "Pairwise", args,
1895 sizeof(args) / sizeof(char*)))
1896 goto nomem;
1897 } else {
1898 if (!wpa_dbus_dict_begin_string_array(&iter_dict, "Pairwise",
1899 &iter_dict_entry,
1900 &iter_dict_val,
1901 &iter_array))
1902 goto nomem;
1903
1904 if (capa.enc & WPA_DRIVER_CAPA_ENC_CCMP) {
1905 if (!wpa_dbus_dict_string_array_add_element(
1906 &iter_array, "ccmp"))
1907 goto nomem;
1908 }
1909
1910 if (capa.enc & WPA_DRIVER_CAPA_ENC_TKIP) {
1911 if (!wpa_dbus_dict_string_array_add_element(
1912 &iter_array, "tkip"))
1913 goto nomem;
1914 }
1915
1916 if (capa.key_mgmt & WPA_DRIVER_CAPA_KEY_MGMT_WPA_NONE) {
1917 if (!wpa_dbus_dict_string_array_add_element(
1918 &iter_array, "none"))
1919 goto nomem;
1920 }
1921
1922 if (!wpa_dbus_dict_end_string_array(&iter_dict,
1923 &iter_dict_entry,
1924 &iter_dict_val,
1925 &iter_array))
1926 goto nomem;
1927 }
1928
1929 /***** group cipher */
1930 if (res < 0) {
1931 const char *args[] = {
1932 "ccmp", "tkip", "wep104", "wep40"
1933 };
1934 if (!wpa_dbus_dict_append_string_array(
1935 &iter_dict, "Group", args,
1936 sizeof(args) / sizeof(char*)))
1937 goto nomem;
1938 } else {
1939 if (!wpa_dbus_dict_begin_string_array(&iter_dict, "Group",
1940 &iter_dict_entry,
1941 &iter_dict_val,
1942 &iter_array))
1943 goto nomem;
1944
1945 if (capa.enc & WPA_DRIVER_CAPA_ENC_CCMP) {
1946 if (!wpa_dbus_dict_string_array_add_element(
1947 &iter_array, "ccmp"))
1948 goto nomem;
1949 }
1950
1951 if (capa.enc & WPA_DRIVER_CAPA_ENC_TKIP) {
1952 if (!wpa_dbus_dict_string_array_add_element(
1953 &iter_array, "tkip"))
1954 goto nomem;
1955 }
1956
1957 if (capa.enc & WPA_DRIVER_CAPA_ENC_WEP104) {
1958 if (!wpa_dbus_dict_string_array_add_element(
1959 &iter_array, "wep104"))
1960 goto nomem;
1961 }
1962
1963 if (capa.enc & WPA_DRIVER_CAPA_ENC_WEP40) {
1964 if (!wpa_dbus_dict_string_array_add_element(
1965 &iter_array, "wep40"))
1966 goto nomem;
1967 }
1968
1969 if (!wpa_dbus_dict_end_string_array(&iter_dict,
1970 &iter_dict_entry,
1971 &iter_dict_val,
1972 &iter_array))
1973 goto nomem;
1974 }
1975
1976 /***** key management */
1977 if (res < 0) {
1978 const char *args[] = {
1979 "wpa-psk", "wpa-eap", "ieee8021x", "wpa-none",
1980 #ifdef CONFIG_WPS
1981 "wps",
1982 #endif /* CONFIG_WPS */
1983 "none"
1984 };
1985 if (!wpa_dbus_dict_append_string_array(
1986 &iter_dict, "KeyMgmt", args,
1987 sizeof(args) / sizeof(char*)))
1988 goto nomem;
1989 } else {
1990 if (!wpa_dbus_dict_begin_string_array(&iter_dict, "KeyMgmt",
1991 &iter_dict_entry,
1992 &iter_dict_val,
1993 &iter_array))
1994 goto nomem;
1995
1996 if (!wpa_dbus_dict_string_array_add_element(&iter_array,
1997 "none"))
1998 goto nomem;
1999
2000 if (!wpa_dbus_dict_string_array_add_element(&iter_array,
2001 "ieee8021x"))
2002 goto nomem;
2003
2004 if (capa.key_mgmt & (WPA_DRIVER_CAPA_KEY_MGMT_WPA |
2005 WPA_DRIVER_CAPA_KEY_MGMT_WPA2)) {
2006 if (!wpa_dbus_dict_string_array_add_element(
2007 &iter_array, "wpa-eap"))
2008 goto nomem;
2009
2010 if (capa.key_mgmt & WPA_DRIVER_CAPA_KEY_MGMT_FT)
2011 if (!wpa_dbus_dict_string_array_add_element(
2012 &iter_array, "wpa-ft-eap"))
2013 goto nomem;
2014
2015 /* TODO: Ensure that driver actually supports sha256 encryption. */
2016 #ifdef CONFIG_IEEE80211W
2017 if (!wpa_dbus_dict_string_array_add_element(
2018 &iter_array, "wpa-eap-sha256"))
2019 goto nomem;
2020 #endif /* CONFIG_IEEE80211W */
2021 }
2022
2023 if (capa.key_mgmt & (WPA_DRIVER_CAPA_KEY_MGMT_WPA_PSK |
2024 WPA_DRIVER_CAPA_KEY_MGMT_WPA2_PSK)) {
2025 if (!wpa_dbus_dict_string_array_add_element(
2026 &iter_array, "wpa-psk"))
2027 goto nomem;
2028
2029 if (capa.key_mgmt & WPA_DRIVER_CAPA_KEY_MGMT_FT_PSK)
2030 if (!wpa_dbus_dict_string_array_add_element(
2031 &iter_array, "wpa-ft-psk"))
2032 goto nomem;
2033
2034 /* TODO: Ensure that driver actually supports sha256 encryption. */
2035 #ifdef CONFIG_IEEE80211W
2036 if (!wpa_dbus_dict_string_array_add_element(
2037 &iter_array, "wpa-psk-sha256"))
2038 goto nomem;
2039 #endif /* CONFIG_IEEE80211W */
2040 }
2041
2042 if (capa.key_mgmt & WPA_DRIVER_CAPA_KEY_MGMT_WPA_NONE) {
2043 if (!wpa_dbus_dict_string_array_add_element(
2044 &iter_array, "wpa-none"))
2045 goto nomem;
2046 }
2047
2048
2049 #ifdef CONFIG_WPS
2050 if (!wpa_dbus_dict_string_array_add_element(&iter_array,
2051 "wps"))
2052 goto nomem;
2053 #endif /* CONFIG_WPS */
2054
2055 if (!wpa_dbus_dict_end_string_array(&iter_dict,
2056 &iter_dict_entry,
2057 &iter_dict_val,
2058 &iter_array))
2059 goto nomem;
2060 }
2061
2062 /***** WPA protocol */
2063 if (res < 0) {
2064 const char *args[] = { "rsn", "wpa" };
2065 if (!wpa_dbus_dict_append_string_array(
2066 &iter_dict, "Protocol", args,
2067 sizeof(args) / sizeof(char*)))
2068 goto nomem;
2069 } else {
2070 if (!wpa_dbus_dict_begin_string_array(&iter_dict, "Protocol",
2071 &iter_dict_entry,
2072 &iter_dict_val,
2073 &iter_array))
2074 goto nomem;
2075
2076 if (capa.key_mgmt & (WPA_DRIVER_CAPA_KEY_MGMT_WPA2 |
2077 WPA_DRIVER_CAPA_KEY_MGMT_WPA2_PSK)) {
2078 if (!wpa_dbus_dict_string_array_add_element(
2079 &iter_array, "rsn"))
2080 goto nomem;
2081 }
2082
2083 if (capa.key_mgmt & (WPA_DRIVER_CAPA_KEY_MGMT_WPA |
2084 WPA_DRIVER_CAPA_KEY_MGMT_WPA_PSK)) {
2085 if (!wpa_dbus_dict_string_array_add_element(
2086 &iter_array, "wpa"))
2087 goto nomem;
2088 }
2089
2090 if (!wpa_dbus_dict_end_string_array(&iter_dict,
2091 &iter_dict_entry,
2092 &iter_dict_val,
2093 &iter_array))
2094 goto nomem;
2095 }
2096
2097 /***** auth alg */
2098 if (res < 0) {
2099 const char *args[] = { "open", "shared", "leap" };
2100 if (!wpa_dbus_dict_append_string_array(
2101 &iter_dict, "AuthAlg", args,
2102 sizeof(args) / sizeof(char*)))
2103 goto nomem;
2104 } else {
2105 if (!wpa_dbus_dict_begin_string_array(&iter_dict, "AuthAlg",
2106 &iter_dict_entry,
2107 &iter_dict_val,
2108 &iter_array))
2109 goto nomem;
2110
2111 if (capa.auth & (WPA_DRIVER_AUTH_OPEN)) {
2112 if (!wpa_dbus_dict_string_array_add_element(
2113 &iter_array, "open"))
2114 goto nomem;
2115 }
2116
2117 if (capa.auth & (WPA_DRIVER_AUTH_SHARED)) {
2118 if (!wpa_dbus_dict_string_array_add_element(
2119 &iter_array, "shared"))
2120 goto nomem;
2121 }
2122
2123 if (capa.auth & (WPA_DRIVER_AUTH_LEAP)) {
2124 if (!wpa_dbus_dict_string_array_add_element(
2125 &iter_array, "leap"))
2126 goto nomem;
2127 }
2128
2129 if (!wpa_dbus_dict_end_string_array(&iter_dict,
2130 &iter_dict_entry,
2131 &iter_dict_val,
2132 &iter_array))
2133 goto nomem;
2134 }
2135
2136 /***** Scan */
2137 if (!wpa_dbus_dict_append_string_array(&iter_dict, "Scan", scans,
2138 sizeof(scans) / sizeof(char *)))
2139 goto nomem;
2140
2141 /***** Modes */
2142 if (!wpa_dbus_dict_begin_string_array(&iter_dict, "Modes",
2143 &iter_dict_entry,
2144 &iter_dict_val,
2145 &iter_array))
2146 goto nomem;
2147
2148 if (!wpa_dbus_dict_string_array_add_element(
2149 &iter_array, "infrastructure"))
2150 goto nomem;
2151
2152 if (!wpa_dbus_dict_string_array_add_element(
2153 &iter_array, "ad-hoc"))
2154 goto nomem;
2155
2156 if (res >= 0) {
2157 if (capa.flags & (WPA_DRIVER_FLAGS_AP)) {
2158 if (!wpa_dbus_dict_string_array_add_element(
2159 &iter_array, "ap"))
2160 goto nomem;
2161 }
2162
2163 if (capa.flags & (WPA_DRIVER_FLAGS_P2P_CAPABLE)) {
2164 if (!wpa_dbus_dict_string_array_add_element(
2165 &iter_array, "p2p"))
2166 goto nomem;
2167 }
2168 }
2169
2170 if (!wpa_dbus_dict_end_string_array(&iter_dict,
2171 &iter_dict_entry,
2172 &iter_dict_val,
2173 &iter_array))
2174 goto nomem;
2175 /***** Modes end */
2176
2177 if (res >= 0) {
2178 dbus_int32_t max_scan_ssid = capa.max_scan_ssids;
2179
2180 if (!wpa_dbus_dict_append_int32(&iter_dict, "MaxScanSSID",
2181 max_scan_ssid))
2182 goto nomem;
2183 }
2184
2185 if (!wpa_dbus_dict_close_write(&variant_iter, &iter_dict))
2186 goto nomem;
2187 if (!dbus_message_iter_close_container(iter, &variant_iter))
2188 goto nomem;
2189
2190 return TRUE;
2191
2192 nomem:
2193 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
2194 return FALSE;
2195 }
2196
2197
2198 /**
2199 * wpas_dbus_getter_state - Get interface state
2200 * @iter: Pointer to incoming dbus message iter
2201 * @error: Location to store error on failure
2202 * @user_data: Function specific data
2203 * Returns: TRUE on success, FALSE on failure
2204 *
2205 * Getter for "State" property.
2206 */
2207 dbus_bool_t wpas_dbus_getter_state(DBusMessageIter *iter, DBusError *error,
2208 void *user_data)
2209 {
2210 struct wpa_supplicant *wpa_s = user_data;
2211 const char *str_state;
2212 char *state_ls, *tmp;
2213 dbus_bool_t success = FALSE;
2214
2215 str_state = wpa_supplicant_state_txt(wpa_s->wpa_state);
2216
2217 /* make state string lowercase to fit new DBus API convention
2218 */
2219 state_ls = tmp = os_strdup(str_state);
2220 if (!tmp) {
2221 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
2222 return FALSE;
2223 }
2224 while (*tmp) {
2225 *tmp = tolower(*tmp);
2226 tmp++;
2227 }
2228
2229 success = wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING,
2230 &state_ls, error);
2231
2232 os_free(state_ls);
2233
2234 return success;
2235 }
2236
2237
2238 /**
2239 * wpas_dbus_new_iface_get_scanning - Get interface scanning state
2240 * @iter: Pointer to incoming dbus message iter
2241 * @error: Location to store error on failure
2242 * @user_data: Function specific data
2243 * Returns: TRUE on success, FALSE on failure
2244 *
2245 * Getter for "scanning" property.
2246 */
2247 dbus_bool_t wpas_dbus_getter_scanning(DBusMessageIter *iter, DBusError *error,
2248 void *user_data)
2249 {
2250 struct wpa_supplicant *wpa_s = user_data;
2251 dbus_bool_t scanning = wpa_s->scanning ? TRUE : FALSE;
2252
2253 return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_BOOLEAN,
2254 &scanning, error);
2255 }
2256
2257
2258 /**
2259 * wpas_dbus_getter_ap_scan - Control roaming mode
2260 * @iter: Pointer to incoming dbus message iter
2261 * @error: Location to store error on failure
2262 * @user_data: Function specific data
2263 * Returns: TRUE on success, FALSE on failure
2264 *
2265 * Getter function for "ApScan" property.
2266 */
2267 dbus_bool_t wpas_dbus_getter_ap_scan(DBusMessageIter *iter, DBusError *error,
2268 void *user_data)
2269 {
2270 struct wpa_supplicant *wpa_s = user_data;
2271 dbus_uint32_t ap_scan = wpa_s->conf->ap_scan;
2272
2273 return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_UINT32,
2274 &ap_scan, error);
2275 }
2276
2277
2278 /**
2279 * wpas_dbus_setter_ap_scan - Control roaming mode
2280 * @iter: Pointer to incoming dbus message iter
2281 * @error: Location to store error on failure
2282 * @user_data: Function specific data
2283 * Returns: TRUE on success, FALSE on failure
2284 *
2285 * Setter function for "ApScan" property.
2286 */
2287 dbus_bool_t wpas_dbus_setter_ap_scan(DBusMessageIter *iter, DBusError *error,
2288 void *user_data)
2289 {
2290 struct wpa_supplicant *wpa_s = user_data;
2291 dbus_uint32_t ap_scan;
2292
2293 if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_UINT32,
2294 &ap_scan))
2295 return FALSE;
2296
2297 if (wpa_supplicant_set_ap_scan(wpa_s, ap_scan)) {
2298 dbus_set_error_const(error, DBUS_ERROR_FAILED,
2299 "ap_scan must be 0, 1, or 2");
2300 return FALSE;
2301 }
2302 return TRUE;
2303 }
2304
2305
2306 /**
2307 * wpas_dbus_getter_fast_reauth - Control fast
2308 * reauthentication (TLS session resumption)
2309 * @iter: Pointer to incoming dbus message iter
2310 * @error: Location to store error on failure
2311 * @user_data: Function specific data
2312 * Returns: TRUE on success, FALSE on failure
2313 *
2314 * Getter function for "FastReauth" property.
2315 */
2316 dbus_bool_t wpas_dbus_getter_fast_reauth(DBusMessageIter *iter,
2317 DBusError *error,
2318 void *user_data)
2319 {
2320 struct wpa_supplicant *wpa_s = user_data;
2321 dbus_bool_t fast_reauth = wpa_s->conf->fast_reauth ? TRUE : FALSE;
2322
2323 return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_BOOLEAN,
2324 &fast_reauth, error);
2325 }
2326
2327
2328 /**
2329 * wpas_dbus_setter_fast_reauth - Control fast
2330 * reauthentication (TLS session resumption)
2331 * @iter: Pointer to incoming dbus message iter
2332 * @error: Location to store error on failure
2333 * @user_data: Function specific data
2334 * Returns: TRUE on success, FALSE on failure
2335 *
2336 * Setter function for "FastReauth" property.
2337 */
2338 dbus_bool_t wpas_dbus_setter_fast_reauth(DBusMessageIter *iter,
2339 DBusError *error,
2340 void *user_data)
2341 {
2342 struct wpa_supplicant *wpa_s = user_data;
2343 dbus_bool_t fast_reauth;
2344
2345 if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_BOOLEAN,
2346 &fast_reauth))
2347 return FALSE;
2348
2349 wpa_s->conf->fast_reauth = fast_reauth;
2350 return TRUE;
2351 }
2352
2353
2354 /**
2355 * wpas_dbus_getter_disconnect_reason - Get most recent reason for disconnect
2356 * @iter: Pointer to incoming dbus message iter
2357 * @error: Location to store error on failure
2358 * @user_data: Function specific data
2359 * Returns: TRUE on success, FALSE on failure
2360 *
2361 * Getter for "DisconnectReason" property. The reason is negative if it is
2362 * locally generated.
2363 */
2364 dbus_bool_t wpas_dbus_getter_disconnect_reason(DBusMessageIter *iter,
2365 DBusError *error,
2366 void *user_data)
2367 {
2368 struct wpa_supplicant *wpa_s = user_data;
2369 dbus_int32_t reason = wpa_s->disconnect_reason;
2370 return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_INT32,
2371 &reason, error);
2372 }
2373
2374
2375 /**
2376 * wpas_dbus_getter_bss_expire_age - Get BSS entry expiration age
2377 * @iter: Pointer to incoming dbus message iter
2378 * @error: Location to store error on failure
2379 * @user_data: Function specific data
2380 * Returns: TRUE on success, FALSE on failure
2381 *
2382 * Getter function for "BSSExpireAge" property.
2383 */
2384 dbus_bool_t wpas_dbus_getter_bss_expire_age(DBusMessageIter *iter,
2385 DBusError *error,
2386 void *user_data)
2387 {
2388 struct wpa_supplicant *wpa_s = user_data;
2389 dbus_uint32_t expire_age = wpa_s->conf->bss_expiration_age;
2390
2391 return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_UINT32,
2392 &expire_age, error);
2393 }
2394
2395
2396 /**
2397 * wpas_dbus_setter_bss_expire_age - Control BSS entry expiration age
2398 * @iter: Pointer to incoming dbus message iter
2399 * @error: Location to store error on failure
2400 * @user_data: Function specific data
2401 * Returns: TRUE on success, FALSE on failure
2402 *
2403 * Setter function for "BSSExpireAge" property.
2404 */
2405 dbus_bool_t wpas_dbus_setter_bss_expire_age(DBusMessageIter *iter,
2406 DBusError *error,
2407 void *user_data)
2408 {
2409 struct wpa_supplicant *wpa_s = user_data;
2410 dbus_uint32_t expire_age;
2411
2412 if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_UINT32,
2413 &expire_age))
2414 return FALSE;
2415
2416 if (wpa_supplicant_set_bss_expiration_age(wpa_s, expire_age)) {
2417 dbus_set_error_const(error, DBUS_ERROR_FAILED,
2418 "BSSExpireAge must be >= 10");
2419 return FALSE;
2420 }
2421 return TRUE;
2422 }
2423
2424
2425 /**
2426 * wpas_dbus_getter_bss_expire_count - Get BSS entry expiration scan count
2427 * @iter: Pointer to incoming dbus message iter
2428 * @error: Location to store error on failure
2429 * @user_data: Function specific data
2430 * Returns: TRUE on success, FALSE on failure
2431 *
2432 * Getter function for "BSSExpireCount" property.
2433 */
2434 dbus_bool_t wpas_dbus_getter_bss_expire_count(DBusMessageIter *iter,
2435 DBusError *error,
2436 void *user_data)
2437 {
2438 struct wpa_supplicant *wpa_s = user_data;
2439 dbus_uint32_t expire_count = wpa_s->conf->bss_expiration_age;
2440
2441 return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_UINT32,
2442 &expire_count, error);
2443 }
2444
2445
2446 /**
2447 * wpas_dbus_setter_bss_expire_count - Control BSS entry expiration scan count
2448 * @iter: Pointer to incoming dbus message iter
2449 * @error: Location to store error on failure
2450 * @user_data: Function specific data
2451 * Returns: TRUE on success, FALSE on failure
2452 *
2453 * Setter function for "BSSExpireCount" property.
2454 */
2455 dbus_bool_t wpas_dbus_setter_bss_expire_count(DBusMessageIter *iter,
2456 DBusError *error,
2457 void *user_data)
2458 {
2459 struct wpa_supplicant *wpa_s = user_data;
2460 dbus_uint32_t expire_count;
2461
2462 if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_UINT32,
2463 &expire_count))
2464 return FALSE;
2465
2466 if (wpa_supplicant_set_bss_expiration_count(wpa_s, expire_count)) {
2467 dbus_set_error_const(error, DBUS_ERROR_FAILED,
2468 "BSSExpireCount must be > 0");
2469 return FALSE;
2470 }
2471 return TRUE;
2472 }
2473
2474
2475 /**
2476 * wpas_dbus_getter_country - Control country code
2477 * @iter: Pointer to incoming dbus message iter
2478 * @error: Location to store error on failure
2479 * @user_data: Function specific data
2480 * Returns: TRUE on success, FALSE on failure
2481 *
2482 * Getter function for "Country" property.
2483 */
2484 dbus_bool_t wpas_dbus_getter_country(DBusMessageIter *iter, DBusError *error,
2485 void *user_data)
2486 {
2487 struct wpa_supplicant *wpa_s = user_data;
2488 char country[3];
2489 char *str = country;
2490
2491 country[0] = wpa_s->conf->country[0];
2492 country[1] = wpa_s->conf->country[1];
2493 country[2] = '\0';
2494
2495 return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING,
2496 &str, error);
2497 }
2498
2499
2500 /**
2501 * wpas_dbus_setter_country - Control country code
2502 * @iter: Pointer to incoming dbus message iter
2503 * @error: Location to store error on failure
2504 * @user_data: Function specific data
2505 * Returns: TRUE on success, FALSE on failure
2506 *
2507 * Setter function for "Country" property.
2508 */
2509 dbus_bool_t wpas_dbus_setter_country(DBusMessageIter *iter, DBusError *error,
2510 void *user_data)
2511 {
2512 struct wpa_supplicant *wpa_s = user_data;
2513 const char *country;
2514
2515 if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_STRING,
2516 &country))
2517 return FALSE;
2518
2519 if (!country[0] || !country[1]) {
2520 dbus_set_error_const(error, DBUS_ERROR_FAILED,
2521 "invalid country code");
2522 return FALSE;
2523 }
2524
2525 if (wpa_s->drv_priv != NULL && wpa_drv_set_country(wpa_s, country)) {
2526 wpa_printf(MSG_DEBUG, "Failed to set country");
2527 dbus_set_error_const(error, DBUS_ERROR_FAILED,
2528 "failed to set country code");
2529 return FALSE;
2530 }
2531
2532 wpa_s->conf->country[0] = country[0];
2533 wpa_s->conf->country[1] = country[1];
2534 return TRUE;
2535 }
2536
2537
2538 /**
2539 * wpas_dbus_getter_scan_interval - Get scan interval
2540 * @iter: Pointer to incoming dbus message iter
2541 * @error: Location to store error on failure
2542 * @user_data: Function specific data
2543 * Returns: TRUE on success, FALSE on failure
2544 *
2545 * Getter function for "ScanInterval" property.
2546 */
2547 dbus_bool_t wpas_dbus_getter_scan_interval(DBusMessageIter *iter,
2548 DBusError *error,
2549 void *user_data)
2550 {
2551 struct wpa_supplicant *wpa_s = user_data;
2552 dbus_int32_t scan_interval = wpa_s->scan_interval;
2553
2554 return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_INT32,
2555 &scan_interval, error);
2556 }
2557
2558
2559 /**
2560 * wpas_dbus_setter_scan_interval - Control scan interval
2561 * @iter: Pointer to incoming dbus message iter
2562 * @error: Location to store error on failure
2563 * @user_data: Function specific data
2564 * Returns: TRUE on success, FALSE on failure
2565 *
2566 * Setter function for "ScanInterval" property.
2567 */
2568 dbus_bool_t wpas_dbus_setter_scan_interval(DBusMessageIter *iter,
2569 DBusError *error,
2570 void *user_data)
2571 {
2572 struct wpa_supplicant *wpa_s = user_data;
2573 dbus_int32_t scan_interval;
2574
2575 if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_INT32,
2576 &scan_interval))
2577 return FALSE;
2578
2579 if (wpa_supplicant_set_scan_interval(wpa_s, scan_interval)) {
2580 dbus_set_error_const(error, DBUS_ERROR_FAILED,
2581 "scan_interval must be >= 0");
2582 return FALSE;
2583 }
2584 return TRUE;
2585 }
2586
2587
2588 /**
2589 * wpas_dbus_getter_ifname - Get interface name
2590 * @iter: Pointer to incoming dbus message iter
2591 * @error: Location to store error on failure
2592 * @user_data: Function specific data
2593 * Returns: TRUE on success, FALSE on failure
2594 *
2595 * Getter for "Ifname" property.
2596 */
2597 dbus_bool_t wpas_dbus_getter_ifname(DBusMessageIter *iter, DBusError *error,
2598 void *user_data)
2599 {
2600 struct wpa_supplicant *wpa_s = user_data;
2601 const char *ifname = wpa_s->ifname;
2602
2603 return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING,
2604 &ifname, error);
2605 }
2606
2607
2608 /**
2609 * wpas_dbus_getter_driver - Get interface name
2610 * @iter: Pointer to incoming dbus message iter
2611 * @error: Location to store error on failure
2612 * @user_data: Function specific data
2613 * Returns: TRUE on success, FALSE on failure
2614 *
2615 * Getter for "Driver" property.
2616 */
2617 dbus_bool_t wpas_dbus_getter_driver(DBusMessageIter *iter, DBusError *error,
2618 void *user_data)
2619 {
2620 struct wpa_supplicant *wpa_s = user_data;
2621 const char *driver;
2622
2623 if (wpa_s->driver == NULL || wpa_s->driver->name == NULL) {
2624 wpa_printf(MSG_DEBUG, "wpas_dbus_getter_driver[dbus]: "
2625 "wpa_s has no driver set");
2626 dbus_set_error(error, DBUS_ERROR_FAILED, "%s: no driver set",
2627 __func__);
2628 return FALSE;
2629 }
2630
2631 driver = wpa_s->driver->name;
2632 return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING,
2633 &driver, error);
2634 }
2635
2636
2637 /**
2638 * wpas_dbus_getter_current_bss - Get current bss object path
2639 * @iter: Pointer to incoming dbus message iter
2640 * @error: Location to store error on failure
2641 * @user_data: Function specific data
2642 * Returns: TRUE on success, FALSE on failure
2643 *
2644 * Getter for "CurrentBSS" property.
2645 */
2646 dbus_bool_t wpas_dbus_getter_current_bss(DBusMessageIter *iter,
2647 DBusError *error,
2648 void *user_data)
2649 {
2650 struct wpa_supplicant *wpa_s = user_data;
2651 char path_buf[WPAS_DBUS_OBJECT_PATH_MAX], *bss_obj_path = path_buf;
2652
2653 if (wpa_s->current_bss)
2654 os_snprintf(bss_obj_path, WPAS_DBUS_OBJECT_PATH_MAX,
2655 "%s/" WPAS_DBUS_NEW_BSSIDS_PART "/%u",
2656 wpa_s->dbus_new_path, wpa_s->current_bss->id);
2657 else
2658 os_snprintf(bss_obj_path, WPAS_DBUS_OBJECT_PATH_MAX, "/");
2659
2660 return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_OBJECT_PATH,
2661 &bss_obj_path, error);
2662 }
2663
2664
2665 /**
2666 * wpas_dbus_getter_current_network - Get current network object path
2667 * @iter: Pointer to incoming dbus message iter
2668 * @error: Location to store error on failure
2669 * @user_data: Function specific data
2670 * Returns: TRUE on success, FALSE on failure
2671 *
2672 * Getter for "CurrentNetwork" property.
2673 */
2674 dbus_bool_t wpas_dbus_getter_current_network(DBusMessageIter *iter,
2675 DBusError *error,
2676 void *user_data)
2677 {
2678 struct wpa_supplicant *wpa_s = user_data;
2679 char path_buf[WPAS_DBUS_OBJECT_PATH_MAX], *net_obj_path = path_buf;
2680
2681 if (wpa_s->current_ssid)
2682 os_snprintf(net_obj_path, WPAS_DBUS_OBJECT_PATH_MAX,
2683 "%s/" WPAS_DBUS_NEW_NETWORKS_PART "/%u",
2684 wpa_s->dbus_new_path, wpa_s->current_ssid->id);
2685 else
2686 os_snprintf(net_obj_path, WPAS_DBUS_OBJECT_PATH_MAX, "/");
2687
2688 return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_OBJECT_PATH,
2689 &net_obj_path, error);
2690 }
2691
2692
2693 /**
2694 * wpas_dbus_getter_current_auth_mode - Get current authentication type
2695 * @iter: Pointer to incoming dbus message iter
2696 * @error: Location to store error on failure
2697 * @user_data: Function specific data
2698 * Returns: TRUE on success, FALSE on failure
2699 *
2700 * Getter for "CurrentAuthMode" property.
2701 */
2702 dbus_bool_t wpas_dbus_getter_current_auth_mode(DBusMessageIter *iter,
2703 DBusError *error,
2704 void *user_data)
2705 {
2706 struct wpa_supplicant *wpa_s = user_data;
2707 const char *eap_mode;
2708 const char *auth_mode;
2709 char eap_mode_buf[WPAS_DBUS_AUTH_MODE_MAX];
2710
2711 if (wpa_s->wpa_state != WPA_COMPLETED) {
2712 auth_mode = "INACTIVE";
2713 } else if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X ||
2714 wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
2715 eap_mode = wpa_supplicant_get_eap_mode(wpa_s);
2716 os_snprintf(eap_mode_buf, WPAS_DBUS_AUTH_MODE_MAX,
2717 "EAP-%s", eap_mode);
2718 auth_mode = eap_mode_buf;
2719
2720 } else {
2721 auth_mode = wpa_key_mgmt_txt(wpa_s->key_mgmt,
2722 wpa_s->current_ssid->proto);
2723 }
2724
2725 return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING,
2726 &auth_mode, error);
2727 }
2728
2729
2730 /**
2731 * wpas_dbus_getter_bridge_ifname - Get interface name
2732 * @iter: Pointer to incoming dbus message iter
2733 * @error: Location to store error on failure
2734 * @user_data: Function specific data
2735 * Returns: TRUE on success, FALSE on failure
2736 *
2737 * Getter for "BridgeIfname" property.
2738 */
2739 dbus_bool_t wpas_dbus_getter_bridge_ifname(DBusMessageIter *iter,
2740 DBusError *error,
2741 void *user_data)
2742 {
2743 struct wpa_supplicant *wpa_s = user_data;
2744 const char *bridge_ifname = wpa_s->bridge_ifname;
2745 return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING,
2746 &bridge_ifname, error);
2747 }
2748
2749
2750 /**
2751 * wpas_dbus_getter_bsss - Get array of BSSs objects
2752 * @iter: Pointer to incoming dbus message iter
2753 * @error: Location to store error on failure
2754 * @user_data: Function specific data
2755 * Returns: TRUE on success, FALSE on failure
2756 *
2757 * Getter for "BSSs" property.
2758 */
2759 dbus_bool_t wpas_dbus_getter_bsss(DBusMessageIter *iter, DBusError *error,
2760 void *user_data)
2761 {
2762 struct wpa_supplicant *wpa_s = user_data;
2763 struct wpa_bss *bss;
2764 char **paths;
2765 unsigned int i = 0;
2766 dbus_bool_t success = FALSE;
2767
2768 paths = os_zalloc(wpa_s->num_bss * sizeof(char *));
2769 if (!paths) {
2770 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
2771 return FALSE;
2772 }
2773
2774 /* Loop through scan results and append each result's object path */
2775 dl_list_for_each(bss, &wpa_s->bss_id, struct wpa_bss, list_id) {
2776 paths[i] = os_zalloc(WPAS_DBUS_OBJECT_PATH_MAX);
2777 if (paths[i] == NULL) {
2778 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY,
2779 "no memory");
2780 goto out;
2781 }
2782 /* Construct the object path for this BSS. */
2783 os_snprintf(paths[i++], WPAS_DBUS_OBJECT_PATH_MAX,
2784 "%s/" WPAS_DBUS_NEW_BSSIDS_PART "/%u",
2785 wpa_s->dbus_new_path, bss->id);
2786 }
2787
2788 success = wpas_dbus_simple_array_property_getter(iter,
2789 DBUS_TYPE_OBJECT_PATH,
2790 paths, wpa_s->num_bss,
2791 error);
2792
2793 out:
2794 while (i)
2795 os_free(paths[--i]);
2796 os_free(paths);
2797 return success;
2798 }
2799
2800
2801 /**
2802 * wpas_dbus_getter_networks - Get array of networks objects
2803 * @iter: Pointer to incoming dbus message iter
2804 * @error: Location to store error on failure
2805 * @user_data: Function specific data
2806 * Returns: TRUE on success, FALSE on failure
2807 *
2808 * Getter for "Networks" property.
2809 */
2810 dbus_bool_t wpas_dbus_getter_networks(DBusMessageIter *iter, DBusError *error,
2811 void *user_data)
2812 {
2813 struct wpa_supplicant *wpa_s = user_data;
2814 struct wpa_ssid *ssid;
2815 char **paths;
2816 unsigned int i = 0, num = 0;
2817 dbus_bool_t success = FALSE;
2818
2819 if (wpa_s->conf == NULL) {
2820 wpa_printf(MSG_ERROR, "%s[dbus]: An error occurred getting "
2821 "networks list.", __func__);
2822 dbus_set_error(error, DBUS_ERROR_FAILED, "%s: an error "
2823 "occurred getting the networks list", __func__);
2824 return FALSE;
2825 }
2826
2827 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
2828 if (!network_is_persistent_group(ssid))
2829 num++;
2830
2831 paths = os_zalloc(num * sizeof(char *));
2832 if (!paths) {
2833 dbus_set_error(error, DBUS_ERROR_NO_MEMORY, "no memory");
2834 return FALSE;
2835 }
2836
2837 /* Loop through configured networks and append object path of each */
2838 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) {
2839 if (network_is_persistent_group(ssid))
2840 continue;
2841 paths[i] = os_zalloc(WPAS_DBUS_OBJECT_PATH_MAX);
2842 if (paths[i] == NULL) {
2843 dbus_set_error(error, DBUS_ERROR_NO_MEMORY, "no memory");
2844 goto out;
2845 }
2846
2847 /* Construct the object path for this network. */
2848 os_snprintf(paths[i++], WPAS_DBUS_OBJECT_PATH_MAX,
2849 "%s/" WPAS_DBUS_NEW_NETWORKS_PART "/%d",
2850 wpa_s->dbus_new_path, ssid->id);
2851 }
2852
2853 success = wpas_dbus_simple_array_property_getter(iter,
2854 DBUS_TYPE_OBJECT_PATH,
2855 paths, num, error);
2856
2857 out:
2858 while (i)
2859 os_free(paths[--i]);
2860 os_free(paths);
2861 return success;
2862 }
2863
2864
2865 /**
2866 * wpas_dbus_getter_blobs - Get all blobs defined for this interface
2867 * @iter: Pointer to incoming dbus message iter
2868 * @error: Location to store error on failure
2869 * @user_data: Function specific data
2870 * Returns: TRUE on success, FALSE on failure
2871 *
2872 * Getter for "Blobs" property.
2873 */
2874 dbus_bool_t wpas_dbus_getter_blobs(DBusMessageIter *iter, DBusError *error,
2875 void *user_data)
2876 {
2877 struct wpa_supplicant *wpa_s = user_data;
2878 DBusMessageIter variant_iter, dict_iter, entry_iter, array_iter;
2879 struct wpa_config_blob *blob;
2880
2881 if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
2882 "a{say}", &variant_iter) ||
2883 !dbus_message_iter_open_container(&variant_iter, DBUS_TYPE_ARRAY,
2884 "{say}", &dict_iter)) {
2885 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
2886 return FALSE;
2887 }
2888
2889 blob = wpa_s->conf->blobs;
2890 while (blob) {
2891 if (!dbus_message_iter_open_container(&dict_iter,
2892 DBUS_TYPE_DICT_ENTRY,
2893 NULL, &entry_iter) ||
2894 !dbus_message_iter_append_basic(&entry_iter,
2895 DBUS_TYPE_STRING,
2896 &(blob->name)) ||
2897 !dbus_message_iter_open_container(&entry_iter,
2898 DBUS_TYPE_ARRAY,
2899 DBUS_TYPE_BYTE_AS_STRING,
2900 &array_iter) ||
2901 !dbus_message_iter_append_fixed_array(&array_iter,
2902 DBUS_TYPE_BYTE,
2903 &(blob->data),
2904 blob->len) ||
2905 !dbus_message_iter_close_container(&entry_iter,
2906 &array_iter) ||
2907 !dbus_message_iter_close_container(&dict_iter,
2908 &entry_iter)) {
2909 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY,
2910 "no memory");
2911 return FALSE;
2912 }
2913
2914 blob = blob->next;
2915 }
2916
2917 if (!dbus_message_iter_close_container(&variant_iter, &dict_iter) ||
2918 !dbus_message_iter_close_container(iter, &variant_iter)) {
2919 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
2920 return FALSE;
2921 }
2922
2923 return TRUE;
2924 }
2925
2926
2927 static struct wpa_bss * get_bss_helper(struct bss_handler_args *args,
2928 DBusError *error, const char *func_name)
2929 {
2930 struct wpa_bss *res = wpa_bss_get_id(args->wpa_s, args->id);
2931
2932 if (!res) {
2933 wpa_printf(MSG_ERROR, "%s[dbus]: no bss with id %d found",
2934 func_name, args->id);
2935 dbus_set_error(error, DBUS_ERROR_FAILED,
2936 "%s: BSS %d not found",
2937 func_name, args->id);
2938 }
2939
2940 return res;
2941 }
2942
2943
2944 /**
2945 * wpas_dbus_getter_bss_bssid - Return the BSSID of a BSS
2946 * @iter: Pointer to incoming dbus message iter
2947 * @error: Location to store error on failure
2948 * @user_data: Function specific data
2949 * Returns: TRUE on success, FALSE on failure
2950 *
2951 * Getter for "BSSID" property.
2952 */
2953 dbus_bool_t wpas_dbus_getter_bss_bssid(DBusMessageIter *iter, DBusError *error,
2954 void *user_data)
2955 {
2956 struct bss_handler_args *args = user_data;
2957 struct wpa_bss *res;
2958
2959 res = get_bss_helper(args, error, __func__);
2960 if (!res)
2961 return FALSE;
2962
2963 return wpas_dbus_simple_array_property_getter(iter, DBUS_TYPE_BYTE,
2964 res->bssid, ETH_ALEN,
2965 error);
2966 }
2967
2968
2969 /**
2970 * wpas_dbus_getter_bss_ssid - Return the SSID of a BSS
2971 * @iter: Pointer to incoming dbus message iter
2972 * @error: Location to store error on failure
2973 * @user_data: Function specific data
2974 * Returns: TRUE on success, FALSE on failure
2975 *
2976 * Getter for "SSID" property.
2977 */
2978 dbus_bool_t wpas_dbus_getter_bss_ssid(DBusMessageIter *iter, DBusError *error,
2979 void *user_data)
2980 {
2981 struct bss_handler_args *args = user_data;
2982 struct wpa_bss *res;
2983
2984 res = get_bss_helper(args, error, __func__);
2985 if (!res)
2986 return FALSE;
2987
2988 return wpas_dbus_simple_array_property_getter(iter, DBUS_TYPE_BYTE,
2989 res->ssid, res->ssid_len,
2990 error);
2991 }
2992
2993
2994 /**
2995 * wpas_dbus_getter_bss_privacy - Return the privacy flag of a BSS
2996 * @iter: Pointer to incoming dbus message iter
2997 * @error: Location to store error on failure
2998 * @user_data: Function specific data
2999 * Returns: TRUE on success, FALSE on failure
3000 *
3001 * Getter for "Privacy" property.
3002 */
3003 dbus_bool_t wpas_dbus_getter_bss_privacy(DBusMessageIter *iter,
3004 DBusError *error, void *user_data)
3005 {
3006 struct bss_handler_args *args = user_data;
3007 struct wpa_bss *res;
3008 dbus_bool_t privacy;
3009
3010 res = get_bss_helper(args, error, __func__);
3011 if (!res)
3012 return FALSE;
3013
3014 privacy = (res->caps & IEEE80211_CAP_PRIVACY) ? TRUE : FALSE;
3015 return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_BOOLEAN,
3016 &privacy, error);
3017 }
3018
3019
3020 /**
3021 * wpas_dbus_getter_bss_mode - Return the mode of a BSS
3022 * @iter: Pointer to incoming dbus message iter
3023 * @error: Location to store error on failure
3024 * @user_data: Function specific data
3025 * Returns: TRUE on success, FALSE on failure
3026 *
3027 * Getter for "Mode" property.
3028 */
3029 dbus_bool_t wpas_dbus_getter_bss_mode(DBusMessageIter *iter, DBusError *error,
3030 void *user_data)
3031 {
3032 struct bss_handler_args *args = user_data;
3033 struct wpa_bss *res;
3034 const char *mode;
3035
3036 res = get_bss_helper(args, error, __func__);
3037 if (!res)
3038 return FALSE;
3039
3040 if (res->caps & IEEE80211_CAP_IBSS)
3041 mode = "ad-hoc";
3042 else
3043 mode = "infrastructure";
3044
3045 return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING,
3046 &mode, error);
3047 }
3048
3049
3050 /**
3051 * wpas_dbus_getter_bss_level - Return the signal strength of a BSS
3052 * @iter: Pointer to incoming dbus message iter
3053 * @error: Location to store error on failure
3054 * @user_data: Function specific data
3055 * Returns: TRUE on success, FALSE on failure
3056 *
3057 * Getter for "Level" property.
3058 */
3059 dbus_bool_t wpas_dbus_getter_bss_signal(DBusMessageIter *iter,
3060 DBusError *error, void *user_data)
3061 {
3062 struct bss_handler_args *args = user_data;
3063 struct wpa_bss *res;
3064 s16 level;
3065
3066 res = get_bss_helper(args, error, __func__);
3067 if (!res)
3068 return FALSE;
3069
3070 level = (s16) res->level;
3071 return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_INT16,
3072 &level, error);
3073 }
3074
3075
3076 /**
3077 * wpas_dbus_getter_bss_frequency - Return the frequency of a BSS
3078 * @iter: Pointer to incoming dbus message iter
3079 * @error: Location to store error on failure
3080 * @user_data: Function specific data
3081 * Returns: TRUE on success, FALSE on failure
3082 *
3083 * Getter for "Frequency" property.
3084 */
3085 dbus_bool_t wpas_dbus_getter_bss_frequency(DBusMessageIter *iter,
3086 DBusError *error, void *user_data)
3087 {
3088 struct bss_handler_args *args = user_data;
3089 struct wpa_bss *res;
3090 u16 freq;
3091
3092 res = get_bss_helper(args, error, __func__);
3093 if (!res)
3094 return FALSE;
3095
3096 freq = (u16) res->freq;
3097 return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_UINT16,
3098 &freq, error);
3099 }
3100
3101
3102 static int cmp_u8s_desc(const void *a, const void *b)
3103 {
3104 return (*(u8 *) b - *(u8 *) a);
3105 }
3106
3107
3108 /**
3109 * wpas_dbus_getter_bss_rates - Return available bit rates of a BSS
3110 * @iter: Pointer to incoming dbus message iter
3111 * @error: Location to store error on failure
3112 * @user_data: Function specific data
3113 * Returns: TRUE on success, FALSE on failure
3114 *
3115 * Getter for "Rates" property.
3116 */
3117 dbus_bool_t wpas_dbus_getter_bss_rates(DBusMessageIter *iter,
3118 DBusError *error, void *user_data)
3119 {
3120 struct bss_handler_args *args = user_data;
3121 struct wpa_bss *res;
3122 u8 *ie_rates = NULL;
3123 u32 *real_rates;
3124 int rates_num, i;
3125 dbus_bool_t success = FALSE;
3126
3127 res = get_bss_helper(args, error, __func__);
3128 if (!res)
3129 return FALSE;
3130
3131 rates_num = wpa_bss_get_bit_rates(res, &ie_rates);
3132 if (rates_num < 0)
3133 return FALSE;
3134
3135 qsort(ie_rates, rates_num, 1, cmp_u8s_desc);
3136
3137 real_rates = os_malloc(sizeof(u32) * rates_num);
3138 if (!real_rates) {
3139 os_free(ie_rates);
3140 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
3141 return FALSE;
3142 }
3143
3144 for (i = 0; i < rates_num; i++)
3145 real_rates[i] = ie_rates[i] * 500000;
3146
3147 success = wpas_dbus_simple_array_property_getter(iter, DBUS_TYPE_UINT32,
3148 real_rates, rates_num,
3149 error);
3150
3151 os_free(ie_rates);
3152 os_free(real_rates);
3153 return success;
3154 }
3155
3156
3157 static dbus_bool_t wpas_dbus_get_bss_security_prop(DBusMessageIter *iter,
3158 struct wpa_ie_data *ie_data,
3159 DBusError *error)
3160 {
3161 DBusMessageIter iter_dict, variant_iter;
3162 const char *group;
3163 const char *pairwise[2]; /* max 2 pairwise ciphers is supported */
3164 const char *key_mgmt[7]; /* max 7 key managements may be supported */
3165 int n;
3166
3167 if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
3168 "a{sv}", &variant_iter))
3169 goto nomem;
3170
3171 if (!wpa_dbus_dict_open_write(&variant_iter, &iter_dict))
3172 goto nomem;
3173
3174 /* KeyMgmt */
3175 n = 0;
3176 if (ie_data->key_mgmt & WPA_KEY_MGMT_PSK)
3177 key_mgmt[n++] = "wpa-psk";
3178 if (ie_data->key_mgmt & WPA_KEY_MGMT_FT_PSK)
3179 key_mgmt[n++] = "wpa-ft-psk";
3180 if (ie_data->key_mgmt & WPA_KEY_MGMT_PSK_SHA256)
3181 key_mgmt[n++] = "wpa-psk-sha256";
3182 if (ie_data->key_mgmt & WPA_KEY_MGMT_IEEE8021X)
3183 key_mgmt[n++] = "wpa-eap";
3184 if (ie_data->key_mgmt & WPA_KEY_MGMT_FT_IEEE8021X)
3185 key_mgmt[n++] = "wpa-ft-eap";
3186 if (ie_data->key_mgmt & WPA_KEY_MGMT_IEEE8021X_SHA256)
3187 key_mgmt[n++] = "wpa-eap-sha256";
3188 if (ie_data->key_mgmt & WPA_KEY_MGMT_NONE)
3189 key_mgmt[n++] = "wpa-none";
3190
3191 if (!wpa_dbus_dict_append_string_array(&iter_dict, "KeyMgmt",
3192 key_mgmt, n))
3193 goto nomem;
3194
3195 /* Group */
3196 switch (ie_data->group_cipher) {
3197 case WPA_CIPHER_WEP40:
3198 group = "wep40";
3199 break;
3200 case WPA_CIPHER_TKIP:
3201 group = "tkip";
3202 break;
3203 case WPA_CIPHER_CCMP:
3204 group = "ccmp";
3205 break;
3206 case WPA_CIPHER_WEP104:
3207 group = "wep104";
3208 break;
3209 default:
3210 group = "";
3211 break;
3212 }
3213
3214 if (!wpa_dbus_dict_append_string(&iter_dict, "Group", group))
3215 goto nomem;
3216
3217 /* Pairwise */
3218 n = 0;
3219 if (ie_data->pairwise_cipher & WPA_CIPHER_TKIP)
3220 pairwise[n++] = "tkip";
3221 if (ie_data->pairwise_cipher & WPA_CIPHER_CCMP)
3222 pairwise[n++] = "ccmp";
3223
3224 if (!wpa_dbus_dict_append_string_array(&iter_dict, "Pairwise",
3225 pairwise, n))
3226 goto nomem;
3227
3228 /* Management group (RSN only) */
3229 if (ie_data->proto == WPA_PROTO_RSN) {
3230 switch (ie_data->mgmt_group_cipher) {
3231 #ifdef CONFIG_IEEE80211W
3232 case WPA_CIPHER_AES_128_CMAC:
3233 group = "aes128cmac";
3234 break;
3235 #endif /* CONFIG_IEEE80211W */
3236 default:
3237 group = "";
3238 break;
3239 }
3240
3241 if (!wpa_dbus_dict_append_string(&iter_dict, "MgmtGroup",
3242 group))
3243 goto nomem;
3244 }
3245
3246 if (!wpa_dbus_dict_close_write(&variant_iter, &iter_dict))
3247 goto nomem;
3248 if (!dbus_message_iter_close_container(iter, &variant_iter))
3249 goto nomem;
3250
3251 return TRUE;
3252
3253 nomem:
3254 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
3255 return FALSE;
3256 }
3257
3258
3259 /**
3260 * wpas_dbus_getter_bss_wpa - Return the WPA options of a BSS
3261 * @iter: Pointer to incoming dbus message iter
3262 * @error: Location to store error on failure
3263 * @user_data: Function specific data
3264 * Returns: TRUE on success, FALSE on failure
3265 *
3266 * Getter for "WPA" property.
3267 */
3268 dbus_bool_t wpas_dbus_getter_bss_wpa(DBusMessageIter *iter, DBusError *error,
3269 void *user_data)
3270 {
3271 struct bss_handler_args *args = user_data;
3272 struct wpa_bss *res;
3273 struct wpa_ie_data wpa_data;
3274 const u8 *ie;
3275
3276 res = get_bss_helper(args, error, __func__);
3277 if (!res)
3278 return FALSE;
3279
3280 os_memset(&wpa_data, 0, sizeof(wpa_data));
3281 ie = wpa_bss_get_vendor_ie(res, WPA_IE_VENDOR_TYPE);
3282 if (ie) {
3283 if (wpa_parse_wpa_ie(ie, 2 + ie[1], &wpa_data) < 0) {
3284 dbus_set_error_const(error, DBUS_ERROR_FAILED,
3285 "failed to parse WPA IE");
3286 return FALSE;
3287 }
3288 }
3289
3290 return wpas_dbus_get_bss_security_prop(iter, &wpa_data, error);
3291 }
3292
3293
3294 /**
3295 * wpas_dbus_getter_bss_rsn - Return the RSN options of a BSS
3296 * @iter: Pointer to incoming dbus message iter
3297 * @error: Location to store error on failure
3298 * @user_data: Function specific data
3299 * Returns: TRUE on success, FALSE on failure
3300 *
3301 * Getter for "RSN" property.
3302 */
3303 dbus_bool_t wpas_dbus_getter_bss_rsn(DBusMessageIter *iter, DBusError *error,
3304 void *user_data)
3305 {
3306 struct bss_handler_args *args = user_data;
3307 struct wpa_bss *res;
3308 struct wpa_ie_data wpa_data;
3309 const u8 *ie;
3310
3311 res = get_bss_helper(args, error, __func__);
3312 if (!res)
3313 return FALSE;
3314
3315 os_memset(&wpa_data, 0, sizeof(wpa_data));
3316 ie = wpa_bss_get_ie(res, WLAN_EID_RSN);
3317 if (ie) {
3318 if (wpa_parse_wpa_ie(ie, 2 + ie[1], &wpa_data) < 0) {
3319 dbus_set_error_const(error, DBUS_ERROR_FAILED,
3320 "failed to parse RSN IE");
3321 return FALSE;
3322 }
3323 }
3324
3325 return wpas_dbus_get_bss_security_prop(iter, &wpa_data, error);
3326 }
3327
3328
3329 /**
3330 * wpas_dbus_getter_bss_ies - Return all IEs of a BSS
3331 * @iter: Pointer to incoming dbus message iter
3332 * @error: Location to store error on failure
3333 * @user_data: Function specific data
3334 * Returns: TRUE on success, FALSE on failure
3335 *
3336 * Getter for "IEs" property.
3337 */
3338 dbus_bool_t wpas_dbus_getter_bss_ies(DBusMessageIter *iter, DBusError *error,
3339 void *user_data)
3340 {
3341 struct bss_handler_args *args = user_data;
3342 struct wpa_bss *res;
3343
3344 res = get_bss_helper(args, error, __func__);
3345 if (!res)
3346 return FALSE;
3347
3348 return wpas_dbus_simple_array_property_getter(iter, DBUS_TYPE_BYTE,
3349 res + 1, res->ie_len,
3350 error);
3351 }
3352
3353
3354 /**
3355 * wpas_dbus_getter_enabled - Check whether network is enabled or disabled
3356 * @iter: Pointer to incoming dbus message iter
3357 * @error: Location to store error on failure
3358 * @user_data: Function specific data
3359 * Returns: TRUE on success, FALSE on failure
3360 *
3361 * Getter for "enabled" property of a configured network.
3362 */
3363 dbus_bool_t wpas_dbus_getter_enabled(DBusMessageIter *iter, DBusError *error,
3364 void *user_data)
3365 {
3366 struct network_handler_args *net = user_data;
3367 dbus_bool_t enabled = net->ssid->disabled ? FALSE : TRUE;
3368
3369 return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_BOOLEAN,
3370 &enabled, error);
3371 }
3372
3373
3374 /**
3375 * wpas_dbus_setter_enabled - Mark a configured network as enabled or disabled
3376 * @iter: Pointer to incoming dbus message iter
3377 * @error: Location to store error on failure
3378 * @user_data: Function specific data
3379 * Returns: TRUE on success, FALSE on failure
3380 *
3381 * Setter for "Enabled" property of a configured network.
3382 */
3383 dbus_bool_t wpas_dbus_setter_enabled(DBusMessageIter *iter, DBusError *error,
3384 void *user_data)
3385 {
3386 struct network_handler_args *net = user_data;
3387 struct wpa_supplicant *wpa_s;
3388 struct wpa_ssid *ssid;
3389 dbus_bool_t enable;
3390
3391 if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_BOOLEAN,
3392 &enable))
3393 return FALSE;
3394
3395 wpa_s = net->wpa_s;
3396 ssid = net->ssid;
3397
3398 if (enable)
3399 wpa_supplicant_enable_network(wpa_s, ssid);
3400 else
3401 wpa_supplicant_disable_network(wpa_s, ssid);
3402
3403 return TRUE;
3404 }
3405
3406
3407 /**
3408 * wpas_dbus_getter_network_properties - Get options for a configured network
3409 * @iter: Pointer to incoming dbus message iter
3410 * @error: Location to store error on failure
3411 * @user_data: Function specific data
3412 * Returns: TRUE on success, FALSE on failure
3413 *
3414 * Getter for "Properties" property of a configured network.
3415 */
3416 dbus_bool_t wpas_dbus_getter_network_properties(DBusMessageIter *iter,
3417 DBusError *error,
3418 void *user_data)
3419 {
3420 struct network_handler_args *net = user_data;
3421 DBusMessageIter variant_iter, dict_iter;
3422 char **iterator;
3423 char **props = wpa_config_get_all(net->ssid, 1);
3424 dbus_bool_t success = FALSE;
3425
3426 if (!props) {
3427 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
3428 return FALSE;
3429 }
3430
3431 if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT, "a{sv}",
3432 &variant_iter) ||
3433 !wpa_dbus_dict_open_write(&variant_iter, &dict_iter)) {
3434 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
3435 goto out;
3436 }
3437
3438 iterator = props;
3439 while (*iterator) {
3440 if (!wpa_dbus_dict_append_string(&dict_iter, *iterator,
3441 *(iterator + 1))) {
3442 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY,
3443 "no memory");
3444 goto out;
3445 }
3446 iterator += 2;
3447 }
3448
3449
3450 if (!wpa_dbus_dict_close_write(&variant_iter, &dict_iter) ||
3451 !dbus_message_iter_close_container(iter, &variant_iter)) {
3452 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
3453 goto out;
3454 }
3455
3456 success = TRUE;
3457
3458 out:
3459 iterator = props;
3460 while (*iterator) {
3461 os_free(*iterator);
3462 iterator++;
3463 }
3464 os_free(props);
3465 return success;
3466 }
3467
3468
3469 /**
3470 * wpas_dbus_setter_network_properties - Set options for a configured network
3471 * @iter: Pointer to incoming dbus message iter
3472 * @error: Location to store error on failure
3473 * @user_data: Function specific data
3474 * Returns: TRUE on success, FALSE on failure
3475 *
3476 * Setter for "Properties" property of a configured network.
3477 */
3478 dbus_bool_t wpas_dbus_setter_network_properties(DBusMessageIter *iter,
3479 DBusError *error,
3480 void *user_data)
3481 {
3482 struct network_handler_args *net = user_data;
3483 struct wpa_ssid *ssid = net->ssid;
3484 DBusMessageIter variant_iter;
3485
3486 dbus_message_iter_recurse(iter, &variant_iter);
3487 return set_network_properties(net->wpa_s, ssid, &variant_iter, error);
3488 }
3489
3490
3491 #ifdef CONFIG_AP
3492
3493 DBusMessage * wpas_dbus_handler_subscribe_preq(
3494 DBusMessage *message, struct wpa_supplicant *wpa_s)
3495 {
3496 struct wpas_dbus_priv *priv = wpa_s->global->dbus;
3497 char *name;
3498
3499 if (wpa_s->preq_notify_peer != NULL) {
3500 if (os_strcmp(dbus_message_get_sender(message),
3501 wpa_s->preq_notify_peer) == 0)
3502 return NULL;
3503
3504 return dbus_message_new_error(message,
3505 WPAS_DBUS_ERROR_SUBSCRIPTION_IN_USE,
3506 "Another application is already subscribed");
3507 }
3508
3509 name = os_strdup(dbus_message_get_sender(message));
3510 if (!name)
3511 return dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
3512 "out of memory");
3513
3514 wpa_s->preq_notify_peer = name;
3515
3516 /* Subscribe to clean up if application closes socket */
3517 wpas_dbus_subscribe_noc(priv);
3518
3519 /*
3520 * Double-check it's still alive to make sure that we didn't
3521 * miss the NameOwnerChanged signal, e.g. while strdup'ing.
3522 */
3523 if (!dbus_bus_name_has_owner(priv->con, name, NULL)) {
3524 /*
3525 * Application no longer exists, clean up.
3526 * The return value is irrelevant now.
3527 *
3528 * Need to check if the NameOwnerChanged handling
3529 * already cleaned up because we have processed
3530 * DBus messages while checking if the name still
3531 * has an owner.
3532 */
3533 if (!wpa_s->preq_notify_peer)
3534 return NULL;
3535 os_free(wpa_s->preq_notify_peer);
3536 wpa_s->preq_notify_peer = NULL;
3537 wpas_dbus_unsubscribe_noc(priv);
3538 }
3539
3540 return NULL;
3541 }
3542
3543
3544 DBusMessage * wpas_dbus_handler_unsubscribe_preq(
3545 DBusMessage *message, struct wpa_supplicant *wpa_s)
3546 {
3547 struct wpas_dbus_priv *priv = wpa_s->global->dbus;
3548
3549 if (!wpa_s->preq_notify_peer)
3550 return dbus_message_new_error(message,
3551 WPAS_DBUS_ERROR_NO_SUBSCRIPTION,
3552 "Not subscribed");
3553
3554 if (os_strcmp(wpa_s->preq_notify_peer,
3555 dbus_message_get_sender(message)))
3556 return dbus_message_new_error(message,
3557 WPAS_DBUS_ERROR_SUBSCRIPTION_EPERM,
3558 "Can't unsubscribe others");
3559
3560 os_free(wpa_s->preq_notify_peer);
3561 wpa_s->preq_notify_peer = NULL;
3562 wpas_dbus_unsubscribe_noc(priv);
3563 return NULL;
3564 }
3565
3566
3567 void wpas_dbus_signal_preq(struct wpa_supplicant *wpa_s,
3568 const u8 *addr, const u8 *dst, const u8 *bssid,
3569 const u8 *ie, size_t ie_len, u32 ssi_signal)
3570 {
3571 DBusMessage *msg;
3572 DBusMessageIter iter, dict_iter;
3573 struct wpas_dbus_priv *priv = wpa_s->global->dbus;
3574
3575 /* Do nothing if the control interface is not turned on */
3576 if (priv == NULL)
3577 return;
3578
3579 if (wpa_s->preq_notify_peer == NULL)
3580 return;
3581
3582 msg = dbus_message_new_signal(wpa_s->dbus_new_path,
3583 WPAS_DBUS_NEW_IFACE_INTERFACE,
3584 "ProbeRequest");
3585 if (msg == NULL)
3586 return;
3587
3588 dbus_message_set_destination(msg, wpa_s->preq_notify_peer);
3589
3590 dbus_message_iter_init_append(msg, &iter);
3591
3592 if (!wpa_dbus_dict_open_write(&iter, &dict_iter))
3593 goto fail;
3594 if (addr && !wpa_dbus_dict_append_byte_array(&dict_iter, "addr",
3595 (const char *) addr,
3596 ETH_ALEN))
3597 goto fail;
3598 if (dst && !wpa_dbus_dict_append_byte_array(&dict_iter, "dst",
3599 (const char *) dst,
3600 ETH_ALEN))
3601 goto fail;
3602 if (bssid && !wpa_dbus_dict_append_byte_array(&dict_iter, "bssid",
3603 (const char *) bssid,
3604 ETH_ALEN))
3605 goto fail;
3606 if (ie && ie_len && !wpa_dbus_dict_append_byte_array(&dict_iter, "ies",
3607 (const char *) ie,
3608 ie_len))
3609 goto fail;
3610 if (ssi_signal && !wpa_dbus_dict_append_int32(&dict_iter, "signal",
3611 ssi_signal))
3612 goto fail;
3613 if (!wpa_dbus_dict_close_write(&iter, &dict_iter))
3614 goto fail;
3615
3616 dbus_connection_send(priv->con, msg, NULL);
3617 goto out;
3618 fail:
3619 wpa_printf(MSG_ERROR, "dbus: Failed to construct signal");
3620 out:
3621 dbus_message_unref(msg);
3622 }
3623
3624 #endif /* CONFIG_AP */
Unnamed repository; edit this file 'description' to name the repository.