?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dbus: Use strdup instead of malloc+strncpy
[hostap-gosc2009.git] / wpa_supplicant / dbus / dbus_new_handlers.c
blob91f08e09a5a3be76fa28eb6304c681771929b4ac
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, 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 "../config.h"
24 #include "../wpa_supplicant_i.h"
25 #include "../driver_i.h"
26 #include "../notify.h"
27 #include "../wpas_glue.h"
28 #include "../bss.h"
29 #include "dbus_new_helpers.h"
30 #include "dbus_new.h"
31 #include "dbus_new_handlers.h"
32 #include "dbus_dict_helpers.h"
33
34 extern int wpa_debug_level;
35 extern int wpa_debug_show_keys;
36 extern int wpa_debug_timestamp;
37
38
39 /**
40 * wpas_dbus_new_decompose_object_path - Decompose an interface object path into parts
41 * @path: The dbus object path
42 * @network: (out) the configured network this object path refers to, if any
43 * @bssid: (out) the scanned bssid this object path refers to, if any
44 * Returns: The object path of the network interface this path refers to
45 *
46 * For a given object path, decomposes the object path into object id, network,
47 * and BSSID parts, if those parts exist.
48 */
49 static char * wpas_dbus_new_decompose_object_path(const char *path,
50 char **network,
51 char **bssid)
52 {
53 const unsigned int dev_path_prefix_len =
54 strlen(WPAS_DBUS_NEW_PATH_INTERFACES "/");
55 char *obj_path_only;
56 char *next_sep;
57
58 /* Be a bit paranoid about path */
59 if (!path || os_strncmp(path, WPAS_DBUS_NEW_PATH_INTERFACES "/",
60 dev_path_prefix_len))
61 return NULL;
62
63 /* Ensure there's something at the end of the path */
64 if ((path + dev_path_prefix_len)[0] == '\0')
65 return NULL;
66
67 obj_path_only = os_strdup(path);
68 if (obj_path_only == NULL)
69 return NULL;
70
71 next_sep = os_strchr(obj_path_only + dev_path_prefix_len, '/');
72 if (next_sep != NULL) {
73 const char *net_part = os_strstr(
74 next_sep, WPAS_DBUS_NEW_NETWORKS_PART "/");
75 const char *bssid_part = os_strstr(
76 next_sep, WPAS_DBUS_NEW_BSSIDS_PART "/");
77
78 if (network && net_part) {
79 /* Deal with a request for a configured network */
80 const char *net_name = net_part +
81 os_strlen(WPAS_DBUS_NEW_NETWORKS_PART "/");
82 *network = NULL;
83 if (os_strlen(net_name))
84 *network = os_strdup(net_name);
85 } else if (bssid && bssid_part) {
86 /* Deal with a request for a scanned BSSID */
87 const char *bssid_name = bssid_part +
88 os_strlen(WPAS_DBUS_NEW_BSSIDS_PART "/");
89 if (strlen(bssid_name))
90 *bssid = os_strdup(bssid_name);
91 else
92 *bssid = NULL;
93 }
94
95 /* Cut off interface object path before "/" */
96 *next_sep = '\0';
97 }
98
99 return obj_path_only;
100 }
101
102
103 /**
104 * wpas_dbus_error_unknown_error - Return a new InvalidArgs error message
105 * @message: Pointer to incoming dbus message this error refers to
106 * @arg: Optional string appended to error message
107 * Returns: a dbus error message
108 *
109 * Convenience function to create and return an UnknownError
110 */
111 DBusMessage * wpas_dbus_error_unknown_error(DBusMessage *message,
112 const char *arg)
113 {
114 return dbus_message_new_error(message, WPAS_DBUS_ERROR_UNKNOWN_ERROR,
115 arg);
116 }
117
118
119 /**
120 * wpas_dbus_error_iface_unknown - Return a new invalid interface error message
121 * @message: Pointer to incoming dbus message this error refers to
122 * Returns: A dbus error message
123 *
124 * Convenience function to create and return an invalid interface error
125 */
126 static DBusMessage * wpas_dbus_error_iface_unknown(DBusMessage *message)
127 {
128 return dbus_message_new_error(message, WPAS_DBUS_ERROR_IFACE_UNKNOWN,
129 "wpa_supplicant knows nothing about "
130 "this interface.");
131 }
132
133
134 /**
135 * wpas_dbus_error_network_unknown - Return a new NetworkUnknown error message
136 * @message: Pointer to incoming dbus message this error refers to
137 * Returns: a dbus error message
138 *
139 * Convenience function to create and return an invalid network error
140 */
141 static DBusMessage * wpas_dbus_error_network_unknown(DBusMessage *message)
142 {
143 return dbus_message_new_error(message, WPAS_DBUS_ERROR_NETWORK_UNKNOWN,
144 "There is no such a network in this "
145 "interface.");
146 }
147
148
149 /**
150 * wpas_dbus_error_invald_args - Return a new InvalidArgs error message
151 * @message: Pointer to incoming dbus message this error refers to
152 * Returns: a dbus error message
153 *
154 * Convenience function to create and return an invalid options error
155 */
156 DBusMessage * wpas_dbus_error_invald_args(DBusMessage *message,
157 const char *arg)
158 {
159 DBusMessage *reply;
160
161 reply = dbus_message_new_error(message, WPAS_DBUS_ERROR_INVALID_ARGS,
162 "Did not receive correct message "
163 "arguments.");
164 if (arg != NULL)
165 dbus_message_append_args(reply, DBUS_TYPE_STRING, &arg,
166 DBUS_TYPE_INVALID);
167
168 return reply;
169 }
170
171
172 static const char *dont_quote[] = {
173 "key_mgmt", "proto", "pairwise", "auth_alg", "group", "eap",
174 "opensc_engine_path", "pkcs11_engine_path", "pkcs11_module_path",
175 "bssid", NULL
176 };
177
178 static dbus_bool_t should_quote_opt(const char *key)
179 {
180 int i = 0;
181 while (dont_quote[i] != NULL) {
182 if (os_strcmp(key, dont_quote[i]) == 0)
183 return FALSE;
184 i++;
185 }
186 return TRUE;
187 }
188
189 /**
190 * get_iface_by_dbus_path - Get a new network interface
191 * @global: Pointer to global data from wpa_supplicant_init()
192 * @path: Pointer to a dbus object path representing an interface
193 * Returns: Pointer to the interface or %NULL if not found
194 */
195 static struct wpa_supplicant * get_iface_by_dbus_path(
196 struct wpa_global *global, const char *path)
197 {
198 struct wpa_supplicant *wpa_s;
199
200 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
201 if (os_strcmp(wpa_s->dbus_new_path, path) == 0)
202 return wpa_s;
203 }
204 return NULL;
205 }
206
207
208 /**
209 * set_network_properties - Set properties of a configured network
210 * @message: Pointer to incoming dbus message
211 * @ssid: wpa_ssid structure for a configured network
212 * @iter: DBus message iterator containing dictionary of network
213 * properties to set.
214 * Returns: NULL when succeed or DBus error on failure
215 *
216 * Sets network configuration with parameters given id DBus dictionary
217 */
218 static DBusMessage * set_network_properties(DBusMessage *message,
219 struct wpa_ssid *ssid,
220 DBusMessageIter *iter)
221 {
222
223 struct wpa_dbus_dict_entry entry = { .type = DBUS_TYPE_STRING };
224 DBusMessage *reply = NULL;
225 DBusMessageIter iter_dict;
226
227 if (!wpa_dbus_dict_open_read(iter, &iter_dict))
228 return wpas_dbus_error_invald_args(message, NULL);
229
230 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
231 char *value = NULL;
232 size_t size = 50;
233 int ret;
234 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry)) {
235 reply = wpas_dbus_error_invald_args(message, NULL);
236 break;
237 }
238 if (entry.type == DBUS_TYPE_ARRAY &&
239 entry.array_type == DBUS_TYPE_BYTE) {
240 if (entry.array_len <= 0)
241 goto error;
242
243 size = entry.array_len * 2 + 1;
244 value = os_zalloc(size);
245 if (value == NULL)
246 goto error;
247
248 ret = wpa_snprintf_hex(value, size,
249 (u8 *) entry.bytearray_value,
250 entry.array_len);
251 if (ret <= 0)
252 goto error;
253 } else if (entry.type == DBUS_TYPE_STRING) {
254 if (should_quote_opt(entry.key)) {
255 size = os_strlen(entry.str_value);
256 if (size <= 0)
257 goto error;
258
259 size += 3;
260 value = os_zalloc(size);
261 if (value == NULL)
262 goto error;
263
264 ret = os_snprintf(value, size, "\"%s\"",
265 entry.str_value);
266 if (ret < 0 || (size_t) ret != (size - 1))
267 goto error;
268 } else {
269 value = os_strdup(entry.str_value);
270 if (value == NULL)
271 goto error;
272 }
273 } else if (entry.type == DBUS_TYPE_UINT32) {
274 value = os_zalloc(size);
275 if (value == NULL)
276 goto error;
277
278 ret = os_snprintf(value, size, "%u",
279 entry.uint32_value);
280 if (ret <= 0)
281 goto error;
282 } else if (entry.type == DBUS_TYPE_INT32) {
283 value = os_zalloc(size);
284 if (value == NULL)
285 goto error;
286
287 ret = os_snprintf(value, size, "%d",
288 entry.int32_value);
289 if (ret <= 0)
290 goto error;
291 } else
292 goto error;
293
294 if (wpa_config_set(ssid, entry.key, value, 0) < 0)
295 goto error;
296
297 if ((os_strcmp(entry.key, "psk") == 0 &&
298 value[0] == '"' && ssid->ssid_len) ||
299 (strcmp(entry.key, "ssid") == 0 && ssid->passphrase))
300 wpa_config_update_psk(ssid);
301
302 os_free(value);
303 wpa_dbus_dict_entry_clear(&entry);
304 continue;
305
306 error:
307 os_free(value);
308 reply = wpas_dbus_error_invald_args(message, entry.key);
309 wpa_dbus_dict_entry_clear(&entry);
310 break;
311 }
312
313 return reply;
314 }
315
316
317 static const char * _get_dbus_type_as_string(const int type)
318 {
319 switch(type) {
320 case DBUS_TYPE_BYTE:
321 return DBUS_TYPE_BYTE_AS_STRING;
322 case DBUS_TYPE_BOOLEAN:
323 return DBUS_TYPE_BOOLEAN_AS_STRING;
324 case DBUS_TYPE_INT16:
325 return DBUS_TYPE_INT16_AS_STRING;
326 case DBUS_TYPE_UINT16:
327 return DBUS_TYPE_UINT16_AS_STRING;
328 case DBUS_TYPE_INT32:
329 return DBUS_TYPE_INT32_AS_STRING;
330 case DBUS_TYPE_UINT32:
331 return DBUS_TYPE_UINT32_AS_STRING;
332 case DBUS_TYPE_INT64:
333 return DBUS_TYPE_INT64_AS_STRING;
334 case DBUS_TYPE_UINT64:
335 return DBUS_TYPE_UINT64_AS_STRING;
336 case DBUS_TYPE_DOUBLE:
337 return DBUS_TYPE_DOUBLE_AS_STRING;
338 case DBUS_TYPE_STRING:
339 return DBUS_TYPE_STRING_AS_STRING;
340 case DBUS_TYPE_OBJECT_PATH:
341 return DBUS_TYPE_OBJECT_PATH_AS_STRING;
342 default:
343 return NULL;
344 }
345 }
346
347
348 /**
349 * wpas_dbus_simple_property_getter - Get basic type property
350 * @message: Pointer to incoming dbus message
351 * @type: DBus type of property (must be basic type)
352 * @val: pointer to place holding property value
353 * Returns: The DBus message containing response for Properties.Get call
354 * or DBus error message if error occurred.
355 *
356 * Generic getter for basic type properties. Type is required to be basic.
357 */
358 DBusMessage * wpas_dbus_simple_property_getter(DBusMessage *message,
359 const int type, const void *val)
360 {
361 DBusMessage *reply = NULL;
362 DBusMessageIter iter, variant_iter;
363
364 if (!dbus_type_is_basic(type)) {
365 wpa_printf(MSG_ERROR, "dbus: wpas_dbus_simple_property_getter:"
366 " given type is not basic");
367 return wpas_dbus_error_unknown_error(message, NULL);
368 }
369
370 if (message == NULL)
371 reply = dbus_message_new(DBUS_MESSAGE_TYPE_SIGNAL);
372 else
373 reply = dbus_message_new_method_return(message);
374
375 if (reply != NULL) {
376 dbus_message_iter_init_append(reply, &iter);
377 if (!dbus_message_iter_open_container(
378 &iter, DBUS_TYPE_VARIANT,
379 _get_dbus_type_as_string(type), &variant_iter) ||
380 !dbus_message_iter_append_basic(&variant_iter, type,
381 val) ||
382 !dbus_message_iter_close_container(&iter, &variant_iter)) {
383 wpa_printf(MSG_ERROR, "dbus: "
384 "wpas_dbus_simple_property_getter: out of "
385 "memory to put property value into "
386 "message");
387 dbus_message_unref(reply);
388 reply = dbus_message_new_error(message,
389 DBUS_ERROR_NO_MEMORY,
390 NULL);
391 }
392 } else {
393 wpa_printf(MSG_ERROR, "dbus: wpas_dbus_simple_property_getter:"
394 " out of memory to return property value");
395 reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
396 NULL);
397 }
398
399 return reply;
400 }
401
402
403 /**
404 * wpas_dbus_simple_property_setter - Set basic type property
405 * @message: Pointer to incoming dbus message
406 * @type: DBus type of property (must be basic type)
407 * @val: pointer to place where value being set will be stored
408 * Returns: NULL or DBus error message if error occurred.
409 *
410 * Generic setter for basic type properties. Type is required to be basic.
411 */
412 DBusMessage * wpas_dbus_simple_property_setter(DBusMessage *message,
413 const int type, void *val)
414 {
415 DBusMessageIter iter, variant_iter;
416
417 if (!dbus_type_is_basic(type)) {
418 wpa_printf(MSG_ERROR, "dbus: wpas_dbus_simple_property_setter:"
419 " given type is not basic");
420 return wpas_dbus_error_unknown_error(message, NULL);
421 }
422
423 if (!dbus_message_iter_init(message, &iter)) {
424 wpa_printf(MSG_ERROR, "dbus: wpas_dbus_simple_property_setter:"
425 " out of memory to return scanning state");
426 return dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
427 NULL);
428 }
429
430 /* omit first and second argument and get value from third */
431 dbus_message_iter_next(&iter);
432 dbus_message_iter_next(&iter);
433 dbus_message_iter_recurse(&iter, &variant_iter);
434
435 if (dbus_message_iter_get_arg_type(&variant_iter) != type) {
436 return wpas_dbus_error_invald_args(message,
437 "wrong property type");
438 }
439 dbus_message_iter_get_basic(&variant_iter, val);
440
441 return NULL;
442 }
443
444
445 /**
446 * wpas_dbus_simple_array_property_getter - Get array type property
447 * @message: Pointer to incoming dbus message
448 * @type: DBus type of property array elements (must be basic type)
449 * @array: pointer to array of elements to put into response message
450 * @array_len: length of above array
451 * Returns: The DBus message containing response for Properties.Get call
452 * or DBus error message if error occurred.
453 *
454 * Generic getter for array type properties. Array elements type is
455 * required to be basic.
456 */
457 DBusMessage * wpas_dbus_simple_array_property_getter(DBusMessage *message,
458 const int type,
459 const void *array,
460 size_t array_len)
461 {
462 DBusMessage *reply = NULL;
463 DBusMessageIter iter, variant_iter, array_iter;
464 char type_str[] = "a?"; /* ? will be replaced with subtype letter; */
465 const char *sub_type_str;
466 size_t element_size, i;
467
468 if (!dbus_type_is_basic(type)) {
469 wpa_printf(MSG_ERROR, "dbus: "
470 "wpas_dbus_simple_array_property_getter: given "
471 "type is not basic");
472 return wpas_dbus_error_unknown_error(message, NULL);
473 }
474
475 sub_type_str = _get_dbus_type_as_string(type);
476 type_str[1] = sub_type_str[0];
477
478 if (message == NULL)
479 reply = dbus_message_new(DBUS_MESSAGE_TYPE_SIGNAL);
480 else
481 reply = dbus_message_new_method_return(message);
482 if (reply == NULL) {
483 wpa_printf(MSG_ERROR, "dbus: "
484 "wpas_dbus_simple_array_property_getter: out of "
485 "memory to create return message");
486 return dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
487 NULL);
488 }
489
490 dbus_message_iter_init_append(reply, &iter);
491
492 if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT,
493 type_str, &variant_iter) ||
494 !dbus_message_iter_open_container(&variant_iter, DBUS_TYPE_ARRAY,
495 sub_type_str, &array_iter)) {
496 wpa_printf(MSG_ERROR, "dbus: "
497 "wpas_dbus_simple_array_property_getter: out of "
498 "memory to open container");
499 dbus_message_unref(reply);
500 return dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
501 NULL);
502 }
503
504 switch(type) {
505 case DBUS_TYPE_BYTE:
506 case DBUS_TYPE_BOOLEAN:
507 element_size = 1;
508 break;
509 case DBUS_TYPE_INT16:
510 case DBUS_TYPE_UINT16:
511 element_size = sizeof(uint16_t);
512 break;
513 case DBUS_TYPE_INT32:
514 case DBUS_TYPE_UINT32:
515 element_size = sizeof(uint32_t);
516 break;
517 case DBUS_TYPE_INT64:
518 case DBUS_TYPE_UINT64:
519 element_size = sizeof(uint64_t);
520 break;
521 case DBUS_TYPE_DOUBLE:
522 element_size = sizeof(double);
523 break;
524 case DBUS_TYPE_STRING:
525 case DBUS_TYPE_OBJECT_PATH:
526 element_size = sizeof(char *);
527 break;
528 default:
529 wpa_printf(MSG_ERROR, "dbus: "
530 "wpas_dbus_simple_array_property_getter: "
531 "fatal: unknown element type");
532 element_size = 1;
533 break;
534 }
535
536 for (i = 0; i < array_len; i++) {
537 dbus_message_iter_append_basic(&array_iter, type,
538 array + i * element_size);
539 }
540
541 if (!dbus_message_iter_close_container(&variant_iter, &array_iter) ||
542 !dbus_message_iter_close_container(&iter, &variant_iter)) {
543 wpa_printf(MSG_ERROR, "dbus: "
544 "wpas_dbus_simple_array_property_getter: out of "
545 "memory to close container");
546 dbus_message_unref(reply);
547 return dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
548 NULL);
549 }
550
551 return reply;
552 }
553
554
555 /**
556 * wpas_dbus_handler_create_interface - Request registration of a network iface
557 * @message: Pointer to incoming dbus message
558 * @global: %wpa_supplicant global data structure
559 * Returns: The object path of the new interface object,
560 * or a dbus error message with more information
561 *
562 * Handler function for "CreateInterface" method call. Handles requests
563 * by dbus clients to register a network interface that wpa_supplicant
564 * will manage.
565 */
566 DBusMessage * wpas_dbus_handler_create_interface(DBusMessage *message,
567 struct wpa_global *global)
568 {
569 DBusMessageIter iter_dict;
570 DBusMessage *reply = NULL;
571 DBusMessageIter iter;
572 struct wpa_dbus_dict_entry entry;
573 char *driver = NULL;
574 char *ifname = NULL;
575 char *bridge_ifname = NULL;
576
577 dbus_message_iter_init(message, &iter);
578
579 if (!wpa_dbus_dict_open_read(&iter, &iter_dict))
580 goto error;
581 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
582 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
583 goto error;
584 if (!strcmp(entry.key, "Driver") &&
585 (entry.type == DBUS_TYPE_STRING)) {
586 driver = os_strdup(entry.str_value);
587 wpa_dbus_dict_entry_clear(&entry);
588 if (driver == NULL)
589 goto error;
590 } else if (!strcmp(entry.key, "Ifname") &&
591 (entry.type == DBUS_TYPE_STRING)) {
592 ifname = os_strdup(entry.str_value);
593 wpa_dbus_dict_entry_clear(&entry);
594 if (ifname == NULL)
595 goto error;
596 } else if (!strcmp(entry.key, "BridgeIfname") &&
597 (entry.type == DBUS_TYPE_STRING)) {
598 bridge_ifname = os_strdup(entry.str_value);
599 wpa_dbus_dict_entry_clear(&entry);
600 if (bridge_ifname == NULL)
601 goto error;
602 } else {
603 wpa_dbus_dict_entry_clear(&entry);
604 goto error;
605 }
606 }
607
608 if (ifname == NULL)
609 goto error; /* Required Ifname argument missing */
610
611 /*
612 * Try to get the wpa_supplicant record for this iface, return
613 * an error if we already control it.
614 */
615 if (wpa_supplicant_get_iface(global, ifname) != NULL) {
616 reply = dbus_message_new_error(message,
617 WPAS_DBUS_ERROR_IFACE_EXISTS,
618 "wpa_supplicant already "
619 "controls this interface.");
620 } else {
621 struct wpa_supplicant *wpa_s;
622 struct wpa_interface iface;
623 os_memset(&iface, 0, sizeof(iface));
624 iface.driver = driver;
625 iface.ifname = ifname;
626 iface.bridge_ifname = bridge_ifname;
627 /* Otherwise, have wpa_supplicant attach to it. */
628 if ((wpa_s = wpa_supplicant_add_iface(global, &iface))) {
629 const char *path = wpas_dbus_get_path(wpa_s);
630 reply = dbus_message_new_method_return(message);
631 dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH,
632 &path, DBUS_TYPE_INVALID);
633 } else {
634 reply = wpas_dbus_error_unknown_error(
635 message, "wpa_supplicant couldn't grab this "
636 "interface.");
637 }
638 }
639
640 out:
641 os_free(driver);
642 os_free(ifname);
643 os_free(bridge_ifname);
644 return reply;
645
646 error:
647 reply = wpas_dbus_error_invald_args(message, NULL);
648 goto out;
649 }
650
651
652 /**
653 * wpas_dbus_handler_remove_interface - Request deregistration of an interface
654 * @message: Pointer to incoming dbus message
655 * @global: wpa_supplicant global data structure
656 * Returns: a dbus message containing a UINT32 indicating success (1) or
657 * failure (0), or returns a dbus error message with more information
658 *
659 * Handler function for "removeInterface" method call. Handles requests
660 * by dbus clients to deregister a network interface that wpa_supplicant
661 * currently manages.
662 */
663 DBusMessage * wpas_dbus_handler_remove_interface(DBusMessage *message,
664 struct wpa_global *global)
665 {
666 struct wpa_supplicant *wpa_s;
667 char *path;
668 DBusMessage *reply = NULL;
669
670 dbus_message_get_args(message, NULL, DBUS_TYPE_OBJECT_PATH, &path,
671 DBUS_TYPE_INVALID);
672
673 wpa_s = get_iface_by_dbus_path(global, path);
674 if (wpa_s == NULL)
675 reply = wpas_dbus_error_iface_unknown(message);
676 else if (wpa_supplicant_remove_iface(global, wpa_s)) {
677 reply = wpas_dbus_error_unknown_error(
678 message, "wpa_supplicant couldn't remove this "
679 "interface.");
680 }
681
682 return reply;
683 }
684
685
686 /**
687 * wpas_dbus_handler_get_interface - Get the object path for an interface name
688 * @message: Pointer to incoming dbus message
689 * @global: %wpa_supplicant global data structure
690 * Returns: The object path of the interface object,
691 * or a dbus error message with more information
692 *
693 * Handler function for "getInterface" method call.
694 */
695 DBusMessage * wpas_dbus_handler_get_interface(DBusMessage *message,
696 struct wpa_global *global)
697 {
698 DBusMessage *reply = NULL;
699 const char *ifname;
700 const char *path;
701 struct wpa_supplicant *wpa_s;
702
703 dbus_message_get_args(message, NULL, DBUS_TYPE_STRING, &ifname,
704 DBUS_TYPE_INVALID);
705
706 wpa_s = wpa_supplicant_get_iface(global, ifname);
707 if (wpa_s == NULL)
708 return wpas_dbus_error_iface_unknown(message);
709
710 path = wpas_dbus_get_path(wpa_s);
711 if (path == NULL) {
712 wpa_printf(MSG_ERROR, "wpas_dbus_handler_get_interface[dbus]: "
713 "interface has no dbus object path set");
714 return wpas_dbus_error_unknown_error(message, "path not set");
715 }
716
717 reply = dbus_message_new_method_return(message);
718 if (reply == NULL) {
719 perror("wpas_dbus_handler_get_interface[dbus]: out of memory "
720 "when creating reply");
721 return dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
722 NULL);
723 }
724 if (!dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH, &path,
725 DBUS_TYPE_INVALID)) {
726 perror("wpas_dbus_handler_get_interface[dbus]: out of memory "
727 "when appending argument to reply");
728 dbus_message_unref(reply);
729 return dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
730 NULL);
731 }
732
733 return reply;
734 }
735
736
737 /**
738 * wpas_dbus_getter_debug_level - Get debug level
739 * @message: Pointer to incoming dbus message
740 * @global: %wpa_supplicant global data structure
741 * Returns: DBus message with value of debug level
742 *
743 * Getter for "DebugLevel" property.
744 */
745 DBusMessage * wpas_dbus_getter_debug_level(DBusMessage *message,
746 struct wpa_global *global)
747 {
748 return wpas_dbus_simple_property_getter(message, DBUS_TYPE_BYTE,
749 &wpa_debug_level);
750
751 }
752
753
754 /**
755 * wpas_dbus_getter_debug_timestamp - Get debug timestamp
756 * @message: Pointer to incoming dbus message
757 * @global: %wpa_supplicant global data structure
758 * Returns: DBus message with value of debug timestamp
759 *
760 * Getter for "DebugTimestamp" property.
761 */
762 DBusMessage * wpas_dbus_getter_debug_timestamp(DBusMessage *message,
763 struct wpa_global *global)
764 {
765 return wpas_dbus_simple_property_getter(message, DBUS_TYPE_BOOLEAN,
766 &wpa_debug_timestamp);
767
768 }
769
770
771 /**
772 * wpas_dbus_getter_debug_show_keys - Get debug show keys
773 * @message: Pointer to incoming dbus message
774 * @global: %wpa_supplicant global data structure
775 * Returns: DBus message with value of debug show_keys
776 *
777 * Getter for "DebugShowKeys" property.
778 */
779 DBusMessage * wpas_dbus_getter_debug_show_keys(DBusMessage *message,
780 struct wpa_global *global)
781 {
782 return wpas_dbus_simple_property_getter(message, DBUS_TYPE_BOOLEAN,
783 &wpa_debug_show_keys);
784
785 }
786
787 /**
788 * wpas_dbus_setter_debug_level - Set debug level
789 * @message: Pointer to incoming dbus message
790 * @global: %wpa_supplicant global data structure
791 * Returns: %NULL or DBus error message
792 *
793 * Setter for "DebugLevel" property.
794 */
795 DBusMessage * wpas_dbus_setter_debug_level(DBusMessage *message,
796 struct wpa_global *global)
797 {
798 DBusMessage *reply = NULL;
799 dbus_uint16_t val;
800
801 reply = wpas_dbus_simple_property_setter(message, DBUS_TYPE_INT16,
802 &val);
803 if (reply)
804 return reply;
805
806 if (wpa_supplicant_set_debug_params(global, val, wpa_debug_timestamp,
807 wpa_debug_show_keys)) {
808 dbus_message_unref(reply);
809 return wpas_dbus_error_invald_args(
810 message, "Wrong debug level value");
811 }
812
813 return NULL;
814 }
815
816
817 /**
818 * wpas_dbus_setter_debug_timestamp - Set debug timestamp
819 * @message: Pointer to incoming dbus message
820 * @global: %wpa_supplicant global data structure
821 * Returns: %NULL or DBus error message
822 *
823 * Setter for "DebugTimestamp" property.
824 */
825 DBusMessage * wpas_dbus_setter_debug_timestamp(DBusMessage *message,
826 struct wpa_global *global)
827 {
828 DBusMessage *reply = NULL;
829 dbus_bool_t val;
830
831 reply = wpas_dbus_simple_property_setter(message, DBUS_TYPE_BOOLEAN,
832 &val);
833 if (reply)
834 return reply;
835
836 wpa_supplicant_set_debug_params(global, wpa_debug_level, val ? 1 : 0,
837 wpa_debug_show_keys);
838
839 return NULL;
840 }
841
842
843 /**
844 * wpas_dbus_setter_debug_show_keys - Set debug show keys
845 * @message: Pointer to incoming dbus message
846 * @global: %wpa_supplicant global data structure
847 * Returns: %NULL or DBus error message
848 *
849 * Setter for "DebugShowKeys" property.
850 */
851 DBusMessage * wpas_dbus_setter_debug_show_keys(DBusMessage *message,
852 struct wpa_global *global)
853 {
854 DBusMessage *reply = NULL;
855 dbus_bool_t val;
856
857 reply = wpas_dbus_simple_property_setter(message, DBUS_TYPE_BOOLEAN,
858 &val);
859 if (reply)
860 return reply;
861
862 wpa_supplicant_set_debug_params(global, wpa_debug_level,
863 wpa_debug_timestamp,
864 val ? 1 : 0);
865
866 return NULL;
867 }
868
869
870 /**
871 * wpas_dbus_getter_interfaces - Request registered interfaces list
872 * @message: Pointer to incoming dbus message
873 * @global: %wpa_supplicant global data structure
874 * Returns: The object paths array containing registered interfaces
875 * objects paths or DBus error on failure
876 *
877 * Getter for "Interfaces" property. Handles requests
878 * by dbus clients to return list of registered interfaces objects
879 * paths
880 */
881 DBusMessage * wpas_dbus_getter_interfaces(DBusMessage *message,
882 struct wpa_global *global)
883 {
884 DBusMessage *reply = NULL;
885 struct wpa_supplicant *wpa_s;
886 const char **paths;
887 unsigned int i = 0, num = 0;
888
889 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next)
890 num++;
891
892 paths = os_zalloc(num * sizeof(char*));
893 if (!paths) {
894 return dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
895 NULL);
896 }
897
898 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next)
899 paths[i] = wpas_dbus_get_path(wpa_s);
900
901 reply = wpas_dbus_simple_array_property_getter(message,
902 DBUS_TYPE_OBJECT_PATH,
903 paths, num);
904
905 os_free(paths);
906 return reply;
907 }
908
909
910 /**
911 * wpas_dbus_getter_eap_methods - Request supported EAP methods list
912 * @message: Pointer to incoming dbus message
913 * @nothing: not used argument. may be NULL or anything else
914 * Returns: The object paths array containing supported EAP methods
915 * represented by strings or DBus error on failure
916 *
917 * Getter for "EapMethods" property. Handles requests
918 * by dbus clients to return list of strings with supported EAP methods
919 */
920 DBusMessage * wpas_dbus_getter_eap_methods(DBusMessage *message, void *nothing)
921 {
922 DBusMessage *reply = NULL;
923 char **eap_methods;
924 size_t num_items = 0;
925
926 eap_methods = eap_get_names_as_string_array(&num_items);
927 if (!eap_methods) {
928 return dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
929 NULL);
930 }
931
932 reply = wpas_dbus_simple_array_property_getter(message,
933 DBUS_TYPE_STRING,
934 eap_methods, num_items);
935
936 while (num_items)
937 os_free(eap_methods[--num_items]);
938 os_free(eap_methods);
939 return reply;
940 }
941
942
943 static int wpas_dbus_get_scan_type(DBusMessage *message, DBusMessageIter *var,
944 char **type, DBusMessage **reply)
945 {
946 if (dbus_message_iter_get_arg_type(var) != DBUS_TYPE_STRING) {
947 wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: "
948 "Type must be a string");
949 *reply = wpas_dbus_error_invald_args(
950 message, "Wrong Type value type. String required");
951 return -1;
952 }
953 dbus_message_iter_get_basic(var, type);
954 return 0;
955 }
956
957
958 static int wpas_dbus_get_scan_ssids(DBusMessage *message, DBusMessageIter *var,
959 struct wpa_driver_scan_params *params,
960 DBusMessage **reply)
961 {
962 struct wpa_driver_scan_ssid *ssids = params->ssids;
963 size_t ssids_num = 0;
964 u8 *ssid;
965 DBusMessageIter array_iter, sub_array_iter;
966 char *val;
967 int len;
968
969 if (dbus_message_iter_get_arg_type(var) != DBUS_TYPE_ARRAY) {
970 wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: ssids "
971 "must be an array of arrays of bytes");
972 *reply = wpas_dbus_error_invald_args(
973 message, "Wrong SSIDs value type. Array of arrays of "
974 "bytes required");
975 return -1;
976 }
977
978 dbus_message_iter_recurse(var, &array_iter);
979
980 if (dbus_message_iter_get_arg_type(&array_iter) != DBUS_TYPE_ARRAY ||
981 dbus_message_iter_get_element_type(&array_iter) != DBUS_TYPE_BYTE)
982 {
983 wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: ssids "
984 "must be an array of arrays of bytes");
985 *reply = wpas_dbus_error_invald_args(
986 message, "Wrong SSIDs value type. Array of arrays of "
987 "bytes required");
988 return -1;
989 }
990
991 while (dbus_message_iter_get_arg_type(&array_iter) == DBUS_TYPE_ARRAY)
992 {
993 if (ssids_num >= WPAS_MAX_SCAN_SSIDS) {
994 wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: "
995 "Too many ssids specified on scan dbus "
996 "call");
997 *reply = wpas_dbus_error_invald_args(
998 message, "Too many ssids specified. Specify "
999 "at most four");
1000 return -1;
1001 }
1002
1003 dbus_message_iter_recurse(&array_iter, &sub_array_iter);
1004
1005 dbus_message_iter_get_fixed_array(&sub_array_iter, &val, &len);
1006 if (len == 0) {
1007 dbus_message_iter_next(&array_iter);
1008 continue;
1009 }
1010
1011 ssid = os_malloc(len);
1012 if (ssid == NULL) {
1013 wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: "
1014 "out of memory. Cannot allocate memory for "
1015 "SSID");
1016 *reply = dbus_message_new_error(
1017 message, DBUS_ERROR_NO_MEMORY, NULL);
1018 return -1;
1019 }
1020 os_memcpy(ssid, val, len);
1021 ssids[ssids_num].ssid = ssid;
1022 ssids[ssids_num].ssid_len = len;
1023
1024 dbus_message_iter_next(&array_iter);
1025 ssids_num++;
1026 }
1027
1028 params->num_ssids = ssids_num;
1029 return 0;
1030 }
1031
1032
1033 static int wpas_dbus_get_scan_ies(DBusMessage *message, DBusMessageIter *var,
1034 struct wpa_driver_scan_params *params,
1035 DBusMessage **reply)
1036 {
1037 u8 *ies = NULL, *nies;
1038 int ies_len = 0;
1039 DBusMessageIter array_iter, sub_array_iter;
1040 char *val;
1041 int len;
1042
1043 if (dbus_message_iter_get_arg_type(var) != DBUS_TYPE_ARRAY) {
1044 wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: ies must "
1045 "be an array of arrays of bytes");
1046 *reply = wpas_dbus_error_invald_args(
1047 message, "Wrong IEs value type. Array of arrays of "
1048 "bytes required");
1049 return -1;
1050 }
1051
1052 dbus_message_iter_recurse(var, &array_iter);
1053
1054 if (dbus_message_iter_get_arg_type(&array_iter) != DBUS_TYPE_ARRAY ||
1055 dbus_message_iter_get_element_type(&array_iter) != DBUS_TYPE_BYTE)
1056 {
1057 wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: ies must "
1058 "be an array of arrays of bytes");
1059 *reply = wpas_dbus_error_invald_args(
1060 message, "Wrong IEs value type. Array required");
1061 return -1;
1062 }
1063
1064 while (dbus_message_iter_get_arg_type(&array_iter) == DBUS_TYPE_ARRAY)
1065 {
1066 dbus_message_iter_recurse(&array_iter, &sub_array_iter);
1067
1068 dbus_message_iter_get_fixed_array(&sub_array_iter, &val, &len);
1069 if (len == 0) {
1070 dbus_message_iter_next(&array_iter);
1071 continue;
1072 }
1073
1074 nies = os_realloc(ies, ies_len + len);
1075 if (nies == NULL) {
1076 wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: "
1077 "out of memory. Cannot allocate memory for "
1078 "IE");
1079 os_free(ies);
1080 *reply = dbus_message_new_error(
1081 message, DBUS_ERROR_NO_MEMORY, NULL);
1082 return -1;
1083 }
1084 ies = nies;
1085 os_memcpy(ies + ies_len, val, len);
1086 ies_len += len;
1087
1088 dbus_message_iter_next(&array_iter);
1089 }
1090
1091 params->extra_ies = ies;
1092 params->extra_ies_len = ies_len;
1093 return 0;
1094 }
1095
1096
1097 static int wpas_dbus_get_scan_channels(DBusMessage *message,
1098 DBusMessageIter *var,
1099 struct wpa_driver_scan_params *params,
1100 DBusMessage **reply)
1101 {
1102 DBusMessageIter array_iter, sub_array_iter;
1103 int *freqs = NULL, *nfreqs;
1104 int freqs_num = 0;
1105
1106 if (dbus_message_iter_get_arg_type(var) != DBUS_TYPE_ARRAY) {
1107 wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: "
1108 "Channels must be an array of structs");
1109 *reply = wpas_dbus_error_invald_args(
1110 message, "Wrong Channels value type. Array of structs "
1111 "required");
1112 return -1;
1113 }
1114
1115 dbus_message_iter_recurse(var, &array_iter);
1116
1117 if (dbus_message_iter_get_arg_type(&array_iter) != DBUS_TYPE_STRUCT) {
1118 wpa_printf(MSG_DEBUG,
1119 "wpas_dbus_handler_scan[dbus]: Channels must be an "
1120 "array of structs");
1121 *reply = wpas_dbus_error_invald_args(
1122 message, "Wrong Channels value type. Array of structs "
1123 "required");
1124 return -1;
1125 }
1126
1127 while (dbus_message_iter_get_arg_type(&array_iter) == DBUS_TYPE_STRUCT)
1128 {
1129 int freq, width;
1130
1131 dbus_message_iter_recurse(&array_iter, &sub_array_iter);
1132
1133 if (dbus_message_iter_get_arg_type(&sub_array_iter) !=
1134 DBUS_TYPE_UINT32) {
1135 wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: "
1136 "Channel must by specified by struct of "
1137 "two UINT32s %c",
1138 dbus_message_iter_get_arg_type(
1139 &sub_array_iter));
1140 *reply = wpas_dbus_error_invald_args(
1141 message, "Wrong Channel struct. Two UINT32s "
1142 "required");
1143 os_free(freqs);
1144 return -1;
1145 }
1146 dbus_message_iter_get_basic(&sub_array_iter, &freq);
1147
1148 if (!dbus_message_iter_next(&sub_array_iter) ||
1149 dbus_message_iter_get_arg_type(&sub_array_iter) !=
1150 DBUS_TYPE_UINT32) {
1151 wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: "
1152 "Channel must by specified by struct of "
1153 "two UINT32s");
1154 *reply = wpas_dbus_error_invald_args(
1155 message,
1156 "Wrong Channel struct. Two UINT32s required");
1157 os_free(freqs);
1158 return -1;
1159 }
1160
1161 dbus_message_iter_get_basic(&sub_array_iter, &width);
1162
1163 #define FREQS_ALLOC_CHUNK 32
1164 if (freqs_num % FREQS_ALLOC_CHUNK == 0) {
1165 nfreqs = os_realloc(freqs, sizeof(int) *
1166 (freqs_num + FREQS_ALLOC_CHUNK));
1167 if (nfreqs == NULL)
1168 os_free(freqs);
1169 freqs = nfreqs;
1170 }
1171 if (freqs == NULL) {
1172 wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: "
1173 "out of memory. can't allocate memory for "
1174 "freqs");
1175 *reply = dbus_message_new_error(
1176 message, DBUS_ERROR_NO_MEMORY, NULL);
1177 return -1;
1178 }
1179
1180 freqs[freqs_num] = freq;
1181
1182 freqs_num++;
1183 dbus_message_iter_next(&array_iter);
1184 }
1185
1186 nfreqs = os_realloc(freqs,
1187 sizeof(int) * (freqs_num + 1));
1188 if (nfreqs == NULL)
1189 os_free(freqs);
1190 freqs = nfreqs;
1191 if (freqs == NULL) {
1192 wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: "
1193 "out of memory. Can't allocate memory for freqs");
1194 *reply = dbus_message_new_error(
1195 message, DBUS_ERROR_NO_MEMORY, NULL);
1196 return -1;
1197 }
1198 freqs[freqs_num] = 0;
1199
1200 params->freqs = freqs;
1201 return 0;
1202 }
1203
1204
1205 /**
1206 * wpas_dbus_handler_scan - Request a wireless scan on an interface
1207 * @message: Pointer to incoming dbus message
1208 * @wpa_s: wpa_supplicant structure for a network interface
1209 * Returns: NULL indicating success or DBus error message on failure
1210 *
1211 * Handler function for "Scan" method call of a network device. Requests
1212 * that wpa_supplicant perform a wireless scan as soon as possible
1213 * on a particular wireless interface.
1214 */
1215 DBusMessage * wpas_dbus_handler_scan(DBusMessage *message,
1216 struct wpa_supplicant *wpa_s)
1217 {
1218 DBusMessage *reply = NULL;
1219 DBusMessageIter iter, dict_iter, entry_iter, variant_iter;
1220 char *key = NULL, *type = NULL;
1221 struct wpa_driver_scan_params params;
1222 size_t i;
1223
1224 os_memset(&params, 0, sizeof(params));
1225
1226 dbus_message_iter_init(message, &iter);
1227
1228 dbus_message_iter_recurse(&iter, &dict_iter);
1229
1230 while (dbus_message_iter_get_arg_type(&dict_iter) ==
1231 DBUS_TYPE_DICT_ENTRY) {
1232 dbus_message_iter_recurse(&dict_iter, &entry_iter);
1233 dbus_message_iter_get_basic(&entry_iter, &key);
1234 dbus_message_iter_next(&entry_iter);
1235 dbus_message_iter_recurse(&entry_iter, &variant_iter);
1236
1237 if (os_strcmp(key, "Type") == 0) {
1238 if (wpas_dbus_get_scan_type(message, &variant_iter,
1239 &type, &reply) < 0)
1240 goto out;
1241 } else if (os_strcmp(key, "SSIDs") == 0) {
1242 if (wpas_dbus_get_scan_ssids(message, &variant_iter,
1243 &params, &reply) < 0)
1244 goto out;
1245 } else if (os_strcmp(key, "IEs") == 0) {
1246 if (wpas_dbus_get_scan_ies(message, &variant_iter,
1247 &params, &reply) < 0)
1248 goto out;
1249 } else if (os_strcmp(key, "Channels") == 0) {
1250 if (wpas_dbus_get_scan_channels(message, &variant_iter,
1251 &params, &reply) < 0)
1252 goto out;
1253 } else {
1254 wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: "
1255 "Unknown argument %s", key);
1256 reply = wpas_dbus_error_invald_args(message, key);
1257 goto out;
1258 }
1259
1260 dbus_message_iter_next(&dict_iter);
1261 }
1262
1263 if (!type) {
1264 wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: "
1265 "Scan type not specified");
1266 reply = wpas_dbus_error_invald_args(message, key);
1267 goto out;
1268 }
1269
1270 if (!os_strcmp(type, "passive")) {
1271 if (params.num_ssids || params.extra_ies_len) {
1272 wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: "
1273 "SSIDs or IEs specified for passive scan.");
1274 reply = wpas_dbus_error_invald_args(
1275 message, "You can specify only Channels in "
1276 "passive scan");
1277 goto out;
1278 } else if (params.freqs && params.freqs[0]) {
1279 /* wildcard ssid */
1280 params.num_ssids++;
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 wpa_supplicant_trigger_scan(wpa_s, &params);
1288 } else {
1289 wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: "
1290 "Unknown scan type: %s", type);
1291 reply = wpas_dbus_error_invald_args(message,
1292 "Wrong scan type");
1293 goto out;
1294 }
1295
1296 out:
1297 for (i = 0; i < WPAS_MAX_SCAN_SSIDS; i++)
1298 os_free((u8 *) params.ssids[i].ssid);
1299 os_free((u8 *) params.extra_ies);
1300 os_free(params.freqs);
1301 return reply;
1302 }
1303
1304
1305 /*
1306 * wpas_dbus_handler_disconnect - Terminate the current connection
1307 * @message: Pointer to incoming dbus message
1308 * @wpa_s: wpa_supplicant structure for a network interface
1309 * Returns: NotConnected DBus error message if already not connected
1310 * or NULL otherwise.
1311 *
1312 * Handler function for "Disconnect" method call of network interface.
1313 */
1314 DBusMessage * wpas_dbus_handler_disconnect(DBusMessage *message,
1315 struct wpa_supplicant *wpa_s)
1316 {
1317 if (wpa_s->current_ssid != NULL) {
1318 wpa_s->disconnected = 1;
1319 wpa_supplicant_disassociate(wpa_s, WLAN_REASON_DEAUTH_LEAVING);
1320
1321 return NULL;
1322 }
1323
1324 return dbus_message_new_error(message, WPAS_DBUS_ERROR_NOT_CONNECTED,
1325 "This interface is not connected");
1326 }
1327
1328
1329 /**
1330 * wpas_dbus_new_iface_add_network - Add a new configured network
1331 * @message: Pointer to incoming dbus message
1332 * @wpa_s: wpa_supplicant structure for a network interface
1333 * Returns: A dbus message containing the object path of the new network
1334 *
1335 * Handler function for "AddNetwork" method call of a network interface.
1336 */
1337 DBusMessage * wpas_dbus_handler_add_network(DBusMessage *message,
1338 struct wpa_supplicant *wpa_s)
1339 {
1340 DBusMessage *reply = NULL;
1341 DBusMessageIter iter;
1342 struct wpa_ssid *ssid = NULL;
1343 char *path = NULL;
1344
1345 path = os_zalloc(WPAS_DBUS_OBJECT_PATH_MAX);
1346 if (path == NULL) {
1347 perror("wpas_dbus_handler_add_network[dbus]: out of "
1348 "memory.");
1349 reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
1350 NULL);
1351 goto err;
1352 }
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 reply = set_network_properties(message, ssid, &iter);
1371 if (reply) {
1372 wpa_printf(MSG_DEBUG, "wpas_dbus_handler_add_network[dbus]:"
1373 "control interface couldn't set network "
1374 "properties");
1375 goto err;
1376 }
1377
1378 /* Construct the object path for this network. */
1379 os_snprintf(path, WPAS_DBUS_OBJECT_PATH_MAX,
1380 "%s/" WPAS_DBUS_NEW_NETWORKS_PART "/%d",
1381 wpas_dbus_get_path(wpa_s),
1382 ssid->id);
1383
1384 reply = dbus_message_new_method_return(message);
1385 if (reply == NULL) {
1386 perror("wpas_dbus_handler_add_network[dbus]: out of memory "
1387 "when creating reply");
1388 reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
1389 NULL);
1390 goto err;
1391 }
1392 if (!dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH, &path,
1393 DBUS_TYPE_INVALID)) {
1394 perror("wpas_dbus_handler_add_network[dbus]: out of memory "
1395 "when appending argument to reply");
1396 dbus_message_unref(reply);
1397 reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
1398 NULL);
1399 goto err;
1400 }
1401
1402 os_free(path);
1403 return reply;
1404
1405 err:
1406 if (ssid) {
1407 wpas_notify_network_removed(wpa_s, ssid);
1408 wpa_config_remove_network(wpa_s->conf, ssid->id);
1409 }
1410 os_free(path);
1411 return reply;
1412 }
1413
1414
1415 /**
1416 * wpas_dbus_handler_remove_network - Remove a configured network
1417 * @message: Pointer to incoming dbus message
1418 * @wpa_s: wpa_supplicant structure for a network interface
1419 * Returns: NULL on success or dbus error on failure
1420 *
1421 * Handler function for "RemoveNetwork" method call of a network interface.
1422 */
1423 DBusMessage * wpas_dbus_handler_remove_network(DBusMessage *message,
1424 struct wpa_supplicant *wpa_s)
1425 {
1426 DBusMessage *reply = NULL;
1427 const char *op;
1428 char *iface = NULL, *net_id = NULL;
1429 int id;
1430 struct wpa_ssid *ssid;
1431
1432 dbus_message_get_args(message, NULL, DBUS_TYPE_OBJECT_PATH, &op,
1433 DBUS_TYPE_INVALID);
1434
1435 /* Extract the network ID and ensure the network */
1436 /* is actually a child of this interface */
1437 iface = wpas_dbus_new_decompose_object_path(op, &net_id, NULL);
1438 if (iface == NULL || strcmp(iface, wpas_dbus_get_path(wpa_s)) != 0) {
1439 reply = wpas_dbus_error_invald_args(message, op);
1440 goto out;
1441 }
1442
1443 id = strtoul(net_id, NULL, 10);
1444 if (errno == EINVAL) {
1445 reply = wpas_dbus_error_invald_args(message, op);
1446 goto out;
1447 }
1448
1449 ssid = wpa_config_get_network(wpa_s->conf, id);
1450 if (ssid == NULL) {
1451 reply = wpas_dbus_error_network_unknown(message);
1452 goto out;
1453 }
1454
1455 wpas_notify_network_removed(wpa_s, ssid);
1456
1457 if (wpa_config_remove_network(wpa_s->conf, id) < 0) {
1458 wpa_printf(MSG_ERROR,
1459 "wpas_dbus_handler_remove_network[dbus]: "
1460 "error occurred when removing network %d", id);
1461 reply = wpas_dbus_error_unknown_error(
1462 message, "error removing the specified network on "
1463 "this interface.");
1464 goto out;
1465 }
1466
1467 if (ssid == wpa_s->current_ssid)
1468 wpa_supplicant_disassociate(wpa_s, WLAN_REASON_DEAUTH_LEAVING);
1469
1470 out:
1471 os_free(iface);
1472 os_free(net_id);
1473 return reply;
1474 }
1475
1476
1477 /**
1478 * wpas_dbus_handler_select_network - Attempt association with a network
1479 * @message: Pointer to incoming dbus message
1480 * @wpa_s: wpa_supplicant structure for a network interface
1481 * Returns: NULL on success or dbus error on failure
1482 *
1483 * Handler function for "SelectNetwork" method call of network interface.
1484 */
1485 DBusMessage * wpas_dbus_handler_select_network(DBusMessage *message,
1486 struct wpa_supplicant *wpa_s)
1487 {
1488 DBusMessage *reply = NULL;
1489 const char *op;
1490 char *iface = NULL, *net_id = NULL;
1491 int id;
1492 struct wpa_ssid *ssid;
1493
1494 dbus_message_get_args(message, NULL, DBUS_TYPE_OBJECT_PATH, &op,
1495 DBUS_TYPE_INVALID);
1496
1497 /* Extract the network ID and ensure the network */
1498 /* is actually a child of this interface */
1499 iface = wpas_dbus_new_decompose_object_path(op, &net_id, NULL);
1500 if (iface == NULL || strcmp(iface, wpas_dbus_get_path(wpa_s)) != 0) {
1501 reply = wpas_dbus_error_invald_args(message, op);
1502 goto out;
1503 }
1504
1505 id = strtoul(net_id, NULL, 10);
1506 if (errno == EINVAL) {
1507 reply = wpas_dbus_error_invald_args(message, op);
1508 goto out;
1509 }
1510
1511 ssid = wpa_config_get_network(wpa_s->conf, id);
1512 if (ssid == NULL) {
1513 reply = wpas_dbus_error_network_unknown(message);
1514 goto out;
1515 }
1516
1517 /* Finally, associate with the network */
1518 wpa_supplicant_select_network(wpa_s, ssid);
1519
1520 out:
1521 os_free(iface);
1522 os_free(net_id);
1523 return reply;
1524 }
1525
1526
1527 /**
1528 * wpas_dbus_handler_add_blob - Store named binary blob (ie, for certificates)
1529 * @message: Pointer to incoming dbus message
1530 * @wpa_s: %wpa_supplicant data structure
1531 * Returns: A dbus message containing an error on failure or NULL on success
1532 *
1533 * Asks wpa_supplicant to internally store a binary blobs.
1534 */
1535 DBusMessage * wpas_dbus_handler_add_blob(DBusMessage *message,
1536 struct wpa_supplicant *wpa_s)
1537 {
1538 DBusMessage *reply = NULL;
1539 DBusMessageIter iter, array_iter;
1540
1541 char *blob_name;
1542 u8 *blob_data;
1543 int blob_len;
1544 struct wpa_config_blob *blob = NULL;
1545
1546 dbus_message_iter_init(message, &iter);
1547 dbus_message_iter_get_basic(&iter, &blob_name);
1548
1549 if (wpa_config_get_blob(wpa_s->conf, blob_name)) {
1550 return dbus_message_new_error(message,
1551 WPAS_DBUS_ERROR_BLOB_EXISTS,
1552 NULL);
1553 }
1554
1555 dbus_message_iter_next(&iter);
1556 dbus_message_iter_recurse(&iter, &array_iter);
1557
1558 dbus_message_iter_get_fixed_array(&array_iter, &blob_data, &blob_len);
1559
1560 blob = os_zalloc(sizeof(*blob));
1561 if (!blob) {
1562 perror("wpas_dbus_handler_add_blob[dbus] out of memory when "
1563 "trying to allocate blob struct");
1564 reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
1565 NULL);
1566 goto err;
1567 }
1568
1569 blob->data = os_malloc(blob_len);
1570 if (!blob->data) {
1571 perror("wpas_dbus_handler_add_blob[dbus] out of memory when "
1572 "trying to allocate blob data");
1573 reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
1574 NULL);
1575 goto err;
1576 }
1577 os_memcpy(blob->data, blob_data, blob_len);
1578
1579 blob->len = blob_len;
1580 blob->name = os_strdup(blob_name);
1581 if (!blob->name) {
1582 perror("wpas_dbus_handler_add_blob[dbus] out of memory when "
1583 "trying to copy blob name");
1584 reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
1585 NULL);
1586 goto err;
1587 }
1588
1589 wpa_config_set_blob(wpa_s->conf, blob);
1590 wpas_notify_blob_added(wpa_s, blob->name);
1591
1592 return reply;
1593
1594 err:
1595 if (blob) {
1596 os_free(blob->name);
1597 os_free(blob->data);
1598 os_free(blob);
1599 }
1600 return reply;
1601 }
1602
1603
1604 /**
1605 * wpas_dbus_handler_get_blob - Get named binary blob (ie, for certificates)
1606 * @message: Pointer to incoming dbus message
1607 * @wpa_s: %wpa_supplicant data structure
1608 * Returns: A dbus message containing array of bytes (blob)
1609 *
1610 * Gets one wpa_supplicant's binary blobs.
1611 */
1612 DBusMessage * wpas_dbus_handler_get_blob(DBusMessage *message,
1613 struct wpa_supplicant *wpa_s)
1614 {
1615 DBusMessage *reply = NULL;
1616 DBusMessageIter iter, array_iter;
1617
1618 char *blob_name;
1619 const struct wpa_config_blob *blob;
1620
1621 dbus_message_get_args(message, NULL, DBUS_TYPE_STRING, &blob_name,
1622 DBUS_TYPE_INVALID);
1623
1624 blob = wpa_config_get_blob(wpa_s->conf, blob_name);
1625 if (!blob) {
1626 return dbus_message_new_error(message,
1627 WPAS_DBUS_ERROR_BLOB_UNKNOWN,
1628 "Blob id not set");
1629 }
1630
1631 reply = dbus_message_new_method_return(message);
1632 if (!reply) {
1633 perror("wpas_dbus_handler_get_blob[dbus] out of memory when "
1634 "trying to allocate return message");
1635 reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
1636 NULL);
1637 goto out;
1638 }
1639
1640 dbus_message_iter_init_append(reply, &iter);
1641
1642 if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
1643 DBUS_TYPE_BYTE_AS_STRING,
1644 &array_iter)) {
1645 dbus_message_unref(reply);
1646 perror("wpas_dbus_handler_get_blob[dbus] out of memory when "
1647 "trying to open array");
1648 reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
1649 NULL);
1650 goto out;
1651 }
1652
1653 if (!dbus_message_iter_append_fixed_array(&array_iter, DBUS_TYPE_BYTE,
1654 &(blob->data), blob->len)) {
1655 dbus_message_unref(reply);
1656 perror("wpas_dbus_handler_get_blob[dbus] out of memory when "
1657 "trying to append data to array");
1658 reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
1659 NULL);
1660 goto out;
1661 }
1662
1663 if (!dbus_message_iter_close_container(&iter, &array_iter)) {
1664 dbus_message_unref(reply);
1665 perror("wpas_dbus_handler_get_blob[dbus] out of memory when "
1666 "trying to close array");
1667 reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
1668 NULL);
1669 goto out;
1670 }
1671
1672 out:
1673 return reply;
1674 }
1675
1676
1677 /**
1678 * wpas_remove_handler_remove_blob - Remove named binary blob
1679 * @message: Pointer to incoming dbus message
1680 * @wpa_s: %wpa_supplicant data structure
1681 * Returns: NULL on success or dbus error
1682 *
1683 * Asks wpa_supplicant to internally remove a binary blobs.
1684 */
1685 DBusMessage * wpas_dbus_handler_remove_blob(DBusMessage *message,
1686 struct wpa_supplicant *wpa_s)
1687 {
1688 DBusMessage *reply = NULL;
1689 char *blob_name;
1690
1691 dbus_message_get_args(message, NULL, DBUS_TYPE_STRING, &blob_name,
1692 DBUS_TYPE_INVALID);
1693
1694 if (wpa_config_remove_blob(wpa_s->conf, blob_name)) {
1695 return dbus_message_new_error(message,
1696 WPAS_DBUS_ERROR_BLOB_UNKNOWN,
1697 "Blob id not set");
1698 }
1699 wpas_notify_blob_removed(wpa_s, blob_name);
1700
1701 return reply;
1702
1703 }
1704
1705
1706 /**
1707 * wpas_dbus_getter_capabilities - Return interface capabilities
1708 * @message: Pointer to incoming dbus message
1709 * @wpa_s: wpa_supplicant structure for a network interface
1710 * Returns: A dbus message containing a dict of strings
1711 *
1712 * Getter for "Capabilities" property of an interface.
1713 */
1714 DBusMessage * wpas_dbus_getter_capabilities(DBusMessage *message,
1715 struct wpa_supplicant *wpa_s)
1716 {
1717 DBusMessage *reply = NULL;
1718 struct wpa_driver_capa capa;
1719 int res;
1720 DBusMessageIter iter, iter_dict;
1721 DBusMessageIter iter_dict_entry, iter_dict_val, iter_array,
1722 variant_iter;
1723 const char *scans[] = { "active", "passive", "ssid" };
1724 const char *modes[] = { "infrastructure", "ad-hoc", "ap" };
1725 int n = sizeof(modes) / sizeof(char *);
1726
1727 if (message == NULL)
1728 reply = dbus_message_new(DBUS_MESSAGE_TYPE_SIGNAL);
1729 else
1730 reply = dbus_message_new_method_return(message);
1731 if (!reply)
1732 goto nomem;
1733
1734 dbus_message_iter_init_append(reply, &iter);
1735 if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT,
1736 "a{sv}", &variant_iter))
1737 goto nomem;
1738
1739 if (!wpa_dbus_dict_open_write(&variant_iter, &iter_dict))
1740 goto nomem;
1741
1742 res = wpa_drv_get_capa(wpa_s, &capa);
1743
1744 /***** pairwise cipher */
1745 if (res < 0) {
1746 const char *args[] = {"ccmp", "tkip", "none"};
1747 if (!wpa_dbus_dict_append_string_array(
1748 &iter_dict, "Pairwise", args,
1749 sizeof(args) / sizeof(char*)))
1750 goto nomem;
1751 } else {
1752 if (!wpa_dbus_dict_begin_string_array(&iter_dict, "Pairwise",
1753 &iter_dict_entry,
1754 &iter_dict_val,
1755 &iter_array))
1756 goto nomem;
1757
1758 if (capa.enc & WPA_DRIVER_CAPA_ENC_CCMP) {
1759 if (!wpa_dbus_dict_string_array_add_element(
1760 &iter_array, "ccmp"))
1761 goto nomem;
1762 }
1763
1764 if (capa.enc & WPA_DRIVER_CAPA_ENC_TKIP) {
1765 if (!wpa_dbus_dict_string_array_add_element(
1766 &iter_array, "tkip"))
1767 goto nomem;
1768 }
1769
1770 if (capa.key_mgmt & WPA_DRIVER_CAPA_KEY_MGMT_WPA_NONE) {
1771 if (!wpa_dbus_dict_string_array_add_element(
1772 &iter_array, "none"))
1773 goto nomem;
1774 }
1775
1776 if (!wpa_dbus_dict_end_string_array(&iter_dict,
1777 &iter_dict_entry,
1778 &iter_dict_val,
1779 &iter_array))
1780 goto nomem;
1781 }
1782
1783 /***** group cipher */
1784 if (res < 0) {
1785 const char *args[] = {
1786 "ccmp", "tkip", "wep104", "wep40"
1787 };
1788 if (!wpa_dbus_dict_append_string_array(
1789 &iter_dict, "Group", args,
1790 sizeof(args) / sizeof(char*)))
1791 goto nomem;
1792 } else {
1793 if (!wpa_dbus_dict_begin_string_array(&iter_dict, "Group",
1794 &iter_dict_entry,
1795 &iter_dict_val,
1796 &iter_array))
1797 goto nomem;
1798
1799 if (capa.enc & WPA_DRIVER_CAPA_ENC_CCMP) {
1800 if (!wpa_dbus_dict_string_array_add_element(
1801 &iter_array, "ccmp"))
1802 goto nomem;
1803 }
1804
1805 if (capa.enc & WPA_DRIVER_CAPA_ENC_TKIP) {
1806 if (!wpa_dbus_dict_string_array_add_element(
1807 &iter_array, "tkip"))
1808 goto nomem;
1809 }
1810
1811 if (capa.enc & WPA_DRIVER_CAPA_ENC_WEP104) {
1812 if (!wpa_dbus_dict_string_array_add_element(
1813 &iter_array, "wep104"))
1814 goto nomem;
1815 }
1816
1817 if (capa.enc & WPA_DRIVER_CAPA_ENC_WEP40) {
1818 if (!wpa_dbus_dict_string_array_add_element(
1819 &iter_array, "wep40"))
1820 goto nomem;
1821 }
1822
1823 if (!wpa_dbus_dict_end_string_array(&iter_dict,
1824 &iter_dict_entry,
1825 &iter_dict_val,
1826 &iter_array))
1827 goto nomem;
1828 }
1829
1830 /***** key management */
1831 if (res < 0) {
1832 const char *args[] = {
1833 "wpa-psk", "wpa-eap", "ieee8021x", "wpa-none",
1834 #ifdef CONFIG_WPS
1835 "wps",
1836 #endif /* CONFIG_WPS */
1837 "none"
1838 };
1839 if (!wpa_dbus_dict_append_string_array(
1840 &iter_dict, "KeyMgmt", args,
1841 sizeof(args) / sizeof(char*)))
1842 goto nomem;
1843 } else {
1844 if (!wpa_dbus_dict_begin_string_array(&iter_dict, "KeyMgmt",
1845 &iter_dict_entry,
1846 &iter_dict_val,
1847 &iter_array))
1848 goto nomem;
1849
1850 if (!wpa_dbus_dict_string_array_add_element(&iter_array,
1851 "none"))
1852 goto nomem;
1853
1854 if (!wpa_dbus_dict_string_array_add_element(&iter_array,
1855 "ieee8021x"))
1856 goto nomem;
1857
1858 if (capa.key_mgmt & (WPA_DRIVER_CAPA_KEY_MGMT_WPA |
1859 WPA_DRIVER_CAPA_KEY_MGMT_WPA2)) {
1860 if (!wpa_dbus_dict_string_array_add_element(
1861 &iter_array, "wpa-eap"))
1862 goto nomem;
1863 }
1864
1865 if (capa.key_mgmt & (WPA_DRIVER_CAPA_KEY_MGMT_WPA_PSK |
1866 WPA_DRIVER_CAPA_KEY_MGMT_WPA2_PSK)) {
1867 if (!wpa_dbus_dict_string_array_add_element(
1868 &iter_array, "wpa-psk"))
1869 goto nomem;
1870 }
1871
1872 if (capa.key_mgmt & WPA_DRIVER_CAPA_KEY_MGMT_WPA_NONE) {
1873 if (!wpa_dbus_dict_string_array_add_element(
1874 &iter_array, "wpa-none"))
1875 goto nomem;
1876 }
1877
1878
1879 #ifdef CONFIG_WPS
1880 if (!wpa_dbus_dict_string_array_add_element(&iter_array,
1881 "wps"))
1882 goto nomem;
1883 #endif /* CONFIG_WPS */
1884
1885 if (!wpa_dbus_dict_end_string_array(&iter_dict,
1886 &iter_dict_entry,
1887 &iter_dict_val,
1888 &iter_array))
1889 goto nomem;
1890 }
1891
1892 /***** WPA protocol */
1893 if (res < 0) {
1894 const char *args[] = { "rsn", "wpa" };
1895 if (!wpa_dbus_dict_append_string_array(
1896 &iter_dict, "Protocol", args,
1897 sizeof(args) / sizeof(char*)))
1898 goto nomem;
1899 } else {
1900 if (!wpa_dbus_dict_begin_string_array(&iter_dict, "Protocol",
1901 &iter_dict_entry,
1902 &iter_dict_val,
1903 &iter_array))
1904 goto nomem;
1905
1906 if (capa.key_mgmt & (WPA_DRIVER_CAPA_KEY_MGMT_WPA2 |
1907 WPA_DRIVER_CAPA_KEY_MGMT_WPA2_PSK)) {
1908 if (!wpa_dbus_dict_string_array_add_element(
1909 &iter_array, "rsn"))
1910 goto nomem;
1911 }
1912
1913 if (capa.key_mgmt & (WPA_DRIVER_CAPA_KEY_MGMT_WPA |
1914 WPA_DRIVER_CAPA_KEY_MGMT_WPA_PSK)) {
1915 if (!wpa_dbus_dict_string_array_add_element(
1916 &iter_array, "wpa"))
1917 goto nomem;
1918 }
1919
1920 if (!wpa_dbus_dict_end_string_array(&iter_dict,
1921 &iter_dict_entry,
1922 &iter_dict_val,
1923 &iter_array))
1924 goto nomem;
1925 }
1926
1927 /***** auth alg */
1928 if (res < 0) {
1929 const char *args[] = { "open", "shared", "leap" };
1930 if (!wpa_dbus_dict_append_string_array(
1931 &iter_dict, "AuthAlg", args,
1932 sizeof(args) / sizeof(char*)))
1933 goto nomem;
1934 } else {
1935 if (!wpa_dbus_dict_begin_string_array(&iter_dict, "AuthAlg",
1936 &iter_dict_entry,
1937 &iter_dict_val,
1938 &iter_array))
1939 goto nomem;
1940
1941 if (capa.auth & (WPA_DRIVER_AUTH_OPEN)) {
1942 if (!wpa_dbus_dict_string_array_add_element(
1943 &iter_array, "open"))
1944 goto nomem;
1945 }
1946
1947 if (capa.auth & (WPA_DRIVER_AUTH_SHARED)) {
1948 if (!wpa_dbus_dict_string_array_add_element(
1949 &iter_array, "shared"))
1950 goto nomem;
1951 }
1952
1953 if (capa.auth & (WPA_DRIVER_AUTH_LEAP)) {
1954 if (!wpa_dbus_dict_string_array_add_element(
1955 &iter_array, "leap"))
1956 goto nomem;
1957 }
1958
1959 if (!wpa_dbus_dict_end_string_array(&iter_dict,
1960 &iter_dict_entry,
1961 &iter_dict_val,
1962 &iter_array))
1963 goto nomem;
1964 }
1965
1966 /***** Scan */
1967 if (!wpa_dbus_dict_append_string_array(&iter_dict, "Scan", scans,
1968 sizeof(scans) / sizeof(char *)))
1969 goto nomem;
1970
1971 /***** Modes */
1972 if (res < 0 || !(capa.flags & WPA_DRIVER_FLAGS_AP))
1973 n--; /* exclude ap mode if it is not supported by the driver */
1974 if (!wpa_dbus_dict_append_string_array(&iter_dict, "Modes", modes, n))
1975 goto nomem;
1976
1977 if (!wpa_dbus_dict_close_write(&variant_iter, &iter_dict))
1978 goto nomem;
1979 if (!dbus_message_iter_close_container(&iter, &variant_iter))
1980 goto nomem;
1981
1982 return reply;
1983
1984 nomem:
1985 if (reply)
1986 dbus_message_unref(reply);
1987
1988 return dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY, NULL);
1989 }
1990
1991
1992 /**
1993 * wpas_dbus_getter_state - Get interface state
1994 * @message: Pointer to incoming dbus message
1995 * @wpa_s: wpa_supplicant structure for a network interface
1996 * Returns: A dbus message containing a STRING representing the current
1997 * interface state
1998 *
1999 * Getter for "State" property.
2000 */
2001 DBusMessage * wpas_dbus_getter_state(DBusMessage *message,
2002 struct wpa_supplicant *wpa_s)
2003 {
2004 DBusMessage *reply = NULL;
2005 const char *str_state;
2006 char *state_ls, *tmp;
2007
2008 str_state = wpa_supplicant_state_txt(wpa_s->wpa_state);
2009
2010 /* make state string lowercase to fit new DBus API convention
2011 */
2012 state_ls = tmp = os_strdup(str_state);
2013 if (!tmp) {
2014 return dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
2015 NULL);
2016 }
2017 while (*tmp) {
2018 *tmp = tolower(*tmp);
2019 tmp++;
2020 }
2021
2022 reply = wpas_dbus_simple_property_getter(message, DBUS_TYPE_STRING,
2023 &state_ls);
2024
2025 os_free(state_ls);
2026
2027 return reply;
2028 }
2029
2030
2031 /**
2032 * wpas_dbus_new_iface_get_scanning - Get interface scanning state
2033 * @message: Pointer to incoming dbus message
2034 * @wpa_s: wpa_supplicant structure for a network interface
2035 * Returns: A dbus message containing whether the interface is scanning
2036 *
2037 * Getter for "scanning" property.
2038 */
2039 DBusMessage * wpas_dbus_getter_scanning(DBusMessage *message,
2040 struct wpa_supplicant *wpa_s)
2041 {
2042 dbus_bool_t scanning = wpa_s->scanning ? TRUE : FALSE;
2043 return wpas_dbus_simple_property_getter(message, DBUS_TYPE_BOOLEAN,
2044 &scanning);
2045 }
2046
2047
2048 /**
2049 * wpas_dbus_getter_ap_scan - Control roaming mode
2050 * @message: Pointer to incoming dbus message
2051 * @wpa_s: wpa_supplicant structure for a network interface
2052 * Returns: A message containong value of ap_scan variable
2053 *
2054 * Getter function for "ApScan" property.
2055 */
2056 DBusMessage * wpas_dbus_getter_ap_scan(DBusMessage *message,
2057 struct wpa_supplicant *wpa_s)
2058 {
2059 dbus_uint32_t ap_scan = wpa_s->conf->ap_scan;
2060 return wpas_dbus_simple_property_getter(message, DBUS_TYPE_UINT32,
2061 &ap_scan);
2062 }
2063
2064
2065 /**
2066 * wpas_dbus_setter_ap_scan - Control roaming mode
2067 * @message: Pointer to incoming dbus message
2068 * @wpa_s: wpa_supplicant structure for a network interface
2069 * Returns: NULL
2070 *
2071 * Setter function for "ApScan" property.
2072 */
2073 DBusMessage * wpas_dbus_setter_ap_scan(DBusMessage *message,
2074 struct wpa_supplicant *wpa_s)
2075 {
2076 DBusMessage *reply = NULL;
2077 dbus_uint32_t ap_scan;
2078
2079 reply = wpas_dbus_simple_property_setter(message, DBUS_TYPE_UINT32,
2080 &ap_scan);
2081 if (reply)
2082 return reply;
2083
2084 if (wpa_supplicant_set_ap_scan(wpa_s, ap_scan)) {
2085 return wpas_dbus_error_invald_args(
2086 message, "ap_scan must equal 0, 1 or 2");
2087 }
2088 return NULL;
2089 }
2090
2091
2092 /**
2093 * wpas_dbus_getter_ifname - Get interface name
2094 * @message: Pointer to incoming dbus message
2095 * @wpa_s: wpa_supplicant structure for a network interface
2096 * Returns: A dbus message containing a name of network interface
2097 * associated with with wpa_s
2098 *
2099 * Getter for "Ifname" property.
2100 */
2101 DBusMessage * wpas_dbus_getter_ifname(DBusMessage *message,
2102 struct wpa_supplicant *wpa_s)
2103 {
2104 const char *ifname = wpa_s->ifname;
2105 return wpas_dbus_simple_property_getter(message, DBUS_TYPE_STRING,
2106 &ifname);
2107 }
2108
2109
2110 /**
2111 * wpas_dbus_getter_driver - Get interface name
2112 * @message: Pointer to incoming dbus message
2113 * @wpa_s: wpa_supplicant structure for a network interface
2114 * Returns: A dbus message containing a name of network interface
2115 * driver associated with with wpa_s
2116 *
2117 * Getter for "Driver" property.
2118 */
2119 DBusMessage * wpas_dbus_getter_driver(DBusMessage *message,
2120 struct wpa_supplicant *wpa_s)
2121 {
2122 const char *driver;
2123
2124 if (wpa_s->driver == NULL || wpa_s->driver->name == NULL) {
2125 wpa_printf(MSG_DEBUG, "wpas_dbus_getter_driver[dbus]: "
2126 "wpa_s has no driver set");
2127 return wpas_dbus_error_unknown_error(message, NULL);
2128 }
2129
2130 driver = wpa_s->driver->name;
2131 return wpas_dbus_simple_property_getter(message, DBUS_TYPE_STRING,
2132 &driver);
2133 }
2134
2135
2136 /**
2137 * wpas_dbus_getter_current_bss - Get current bss object path
2138 * @message: Pointer to incoming dbus message
2139 * @wpa_s: wpa_supplicant structure for a network interface
2140 * Returns: A dbus message containing a DBus object path to
2141 * current BSS
2142 *
2143 * Getter for "CurrentBSS" property.
2144 */
2145 DBusMessage * wpas_dbus_getter_current_bss(DBusMessage *message,
2146 struct wpa_supplicant *wpa_s)
2147 {
2148 DBusMessage *reply = NULL;
2149 const char *path = wpas_dbus_get_path(wpa_s);
2150 char *bss_obj_path = os_zalloc(WPAS_DBUS_OBJECT_PATH_MAX);
2151 struct wpa_bss *bss = NULL;
2152
2153 if (bss_obj_path == NULL) {
2154 perror("wpas_dbus_getter_current_bss[dbus]: out of "
2155 "memory to allocate result argument.");
2156 return dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
2157 NULL);
2158 }
2159
2160 /* TODO: store current BSS or BSS id in wpa_s */
2161 if (!is_zero_ether_addr(wpa_s->bssid))
2162 bss = wpa_bss_get_bssid(wpa_s, wpa_s->bssid);
2163
2164 if (bss)
2165 os_snprintf(bss_obj_path, WPAS_DBUS_OBJECT_PATH_MAX,
2166 "%s/" WPAS_DBUS_NEW_BSSIDS_PART "/%u",
2167 path, bss->id);
2168 else
2169 os_snprintf(bss_obj_path, WPAS_DBUS_OBJECT_PATH_MAX, "/");
2170
2171 reply = wpas_dbus_simple_property_getter(message,
2172 DBUS_TYPE_OBJECT_PATH,
2173 &bss_obj_path);
2174
2175 os_free(bss_obj_path);
2176 return reply;
2177 }
2178
2179
2180 /**
2181 * wpas_dbus_getter_current_network - Get current network object path
2182 * @message: Pointer to incoming dbus message
2183 * @wpa_s: wpa_supplicant structure for a network interface
2184 * Returns: A dbus message containing a DBus object path to
2185 * current network
2186 *
2187 * Getter for "CurrentNetwork" property.
2188 */
2189 DBusMessage * wpas_dbus_getter_current_network(DBusMessage *message,
2190 struct wpa_supplicant *wpa_s)
2191 {
2192 DBusMessage *reply = NULL;
2193 const char *path = wpas_dbus_get_path(wpa_s);
2194 char *net_obj_path = os_zalloc(WPAS_DBUS_OBJECT_PATH_MAX);
2195
2196 if (net_obj_path == NULL) {
2197 perror("wpas_dbus_getter_current_network[dbus]: out of "
2198 "memory to allocate result argument.");
2199 return dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
2200 NULL);
2201 }
2202
2203 if (wpa_s->current_ssid)
2204 os_snprintf(net_obj_path, WPAS_DBUS_OBJECT_PATH_MAX,
2205 "%s/" WPAS_DBUS_NEW_NETWORKS_PART "/%u", path,
2206 wpa_s->current_ssid->id);
2207 else
2208 os_snprintf(net_obj_path, WPAS_DBUS_OBJECT_PATH_MAX, "/");
2209
2210 reply = wpas_dbus_simple_property_getter(message,
2211 DBUS_TYPE_OBJECT_PATH,
2212 &net_obj_path);
2213
2214 os_free(net_obj_path);
2215 return reply;
2216 }
2217
2218
2219 /**
2220 * wpas_dbus_getter_bridge_ifname - Get interface name
2221 * @message: Pointer to incoming dbus message
2222 * @wpa_s: wpa_supplicant structure for a network interface
2223 * Returns: A dbus message containing a name of bridge network
2224 * interface associated with with wpa_s
2225 *
2226 * Getter for "BridgeIfname" property.
2227 */
2228 DBusMessage * wpas_dbus_getter_bridge_ifname(DBusMessage *message,
2229 struct wpa_supplicant *wpa_s)
2230 {
2231 const char *bridge_ifname = NULL;
2232
2233 bridge_ifname = wpa_s->bridge_ifname;
2234 if (bridge_ifname == NULL) {
2235 wpa_printf(MSG_ERROR, "wpas_dbus_getter_bridge_ifname[dbus]: "
2236 "wpa_s has no bridge interface name set");
2237 return wpas_dbus_error_unknown_error(message, NULL);
2238 }
2239
2240 return wpas_dbus_simple_property_getter(message, DBUS_TYPE_STRING,
2241 &bridge_ifname);
2242 }
2243
2244
2245 /**
2246 * wpas_dbus_getter_bsss - Get array of BSSs objects
2247 * @message: Pointer to incoming dbus message
2248 * @wpa_s: wpa_supplicant structure for a network interface
2249 * Returns: a dbus message containing an array of all known BSS objects
2250 * dbus paths
2251 *
2252 * Getter for "BSSs" property.
2253 */
2254 DBusMessage * wpas_dbus_getter_bsss(DBusMessage *message,
2255 struct wpa_supplicant *wpa_s)
2256 {
2257 DBusMessage *reply = NULL;
2258 struct wpa_bss *bss;
2259 char **paths;
2260 unsigned int i = 0;
2261
2262 paths = os_zalloc(wpa_s->num_bss * sizeof(char *));
2263 if (!paths) {
2264 return dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
2265 NULL);
2266 }
2267
2268 /* Loop through scan results and append each result's object path */
2269 dl_list_for_each(bss, &wpa_s->bss_id, struct wpa_bss, list_id) {
2270 paths[i] = os_zalloc(WPAS_DBUS_OBJECT_PATH_MAX);
2271 if (paths[i] == NULL) {
2272 perror("wpas_dbus_getter_bsss[dbus]: out of "
2273 "memory.");
2274 reply = dbus_message_new_error(message,
2275 DBUS_ERROR_NO_MEMORY,
2276 NULL);
2277 goto out;
2278 }
2279 /* Construct the object path for this BSS. */
2280 os_snprintf(paths[i++], WPAS_DBUS_OBJECT_PATH_MAX,
2281 "%s/" WPAS_DBUS_NEW_BSSIDS_PART "/%u",
2282 wpas_dbus_get_path(wpa_s), bss->id);
2283 }
2284
2285 reply = wpas_dbus_simple_array_property_getter(message,
2286 DBUS_TYPE_OBJECT_PATH,
2287 paths, wpa_s->num_bss);
2288
2289 out:
2290 while(i)
2291 os_free(paths[--i]);
2292 os_free(paths);
2293 return reply;
2294 }
2295
2296
2297 /**
2298 * wpas_dbus_getter_networks - Get array of networks objects
2299 * @message: Pointer to incoming dbus message
2300 * @wpa_s: wpa_supplicant structure for a network interface
2301 * Returns: a dbus message containing an array of all configured
2302 * networks dbus object paths.
2303 *
2304 * Getter for "Networks" property.
2305 */
2306 DBusMessage * wpas_dbus_getter_networks(DBusMessage *message,
2307 struct wpa_supplicant *wpa_s)
2308 {
2309 DBusMessage *reply = NULL;
2310 struct wpa_ssid *ssid;
2311 char **paths;
2312 unsigned int i = 0, num = 0;
2313
2314 if (wpa_s->conf == NULL) {
2315 wpa_printf(MSG_ERROR, "wpas_dbus_getter_networks[dbus]: "
2316 "An error occurred getting networks list.");
2317 return wpas_dbus_error_unknown_error(message, NULL);
2318 }
2319
2320 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
2321 num++;
2322
2323 paths = os_zalloc(num * sizeof(char *));
2324 if (!paths) {
2325 return dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
2326 NULL);
2327 }
2328
2329 /* Loop through configured networks and append object path of each */
2330 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) {
2331
2332 paths[i] = os_zalloc(WPAS_DBUS_OBJECT_PATH_MAX);
2333 if (paths[i] == NULL) {
2334 perror("wpas_dbus_getter_networks[dbus]: out of "
2335 "memory.");
2336 reply = dbus_message_new_error(message,
2337 DBUS_ERROR_NO_MEMORY,
2338 NULL);
2339 goto out;
2340 }
2341
2342 /* Construct the object path for this network. */
2343 os_snprintf(paths[i++], WPAS_DBUS_OBJECT_PATH_MAX,
2344 "%s/" WPAS_DBUS_NEW_NETWORKS_PART "/%d",
2345 wpas_dbus_get_path(wpa_s), ssid->id);
2346 }
2347
2348 reply = wpas_dbus_simple_array_property_getter(message,
2349 DBUS_TYPE_OBJECT_PATH,
2350 paths, num);
2351
2352 out:
2353 while (i)
2354 os_free(paths[--i]);
2355 os_free(paths);
2356 return reply;
2357 }
2358
2359
2360 /**
2361 * wpas_dbus_getter_blobs - Get all blobs defined for this interface
2362 * @message: Pointer to incoming dbus message
2363 * @wpa_s: wpa_supplicant structure for a network interface
2364 * Returns: a dbus message containing a dictionary of pairs (blob_name, blob)
2365 *
2366 * Getter for "Blobs" property.
2367 */
2368 DBusMessage * wpas_dbus_getter_blobs(DBusMessage *message,
2369 struct wpa_supplicant *wpa_s)
2370 {
2371 DBusMessage *reply = NULL;
2372 DBusMessageIter iter, variant_iter, dict_iter, entry_iter, array_iter;
2373 struct wpa_config_blob *blob;
2374
2375 if (message == NULL)
2376 reply = dbus_message_new(DBUS_MESSAGE_TYPE_SIGNAL);
2377 else
2378 reply = dbus_message_new_method_return(message);
2379 if (!reply) {
2380 perror("wpas_dbus_getter_blobs[dbus] out of memory when "
2381 "trying to initialize return message");
2382 reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
2383 NULL);
2384 goto out;
2385 }
2386
2387 dbus_message_iter_init_append(reply, &iter);
2388
2389 if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT,
2390 "a{say}", &variant_iter)) {
2391 dbus_message_unref(reply);
2392 perror("wpas_dbus_getter_blobs[dbus] out of memory when "
2393 "trying to open variant");
2394 reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
2395 NULL);
2396 goto out;
2397 }
2398
2399 if (!dbus_message_iter_open_container(&variant_iter, DBUS_TYPE_ARRAY,
2400 "{say}", &dict_iter)) {
2401 dbus_message_unref(reply);
2402 perror("wpas_dbus_getter_blobs[dbus] out of memory when "
2403 "trying to open dictionary");
2404 reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
2405 NULL);
2406 goto out;
2407 }
2408
2409 blob = wpa_s->conf->blobs;
2410 while (blob) {
2411 if (!dbus_message_iter_open_container(&dict_iter,
2412 DBUS_TYPE_DICT_ENTRY,
2413 NULL, &entry_iter)) {
2414 dbus_message_unref(reply);
2415 perror("wpas_dbus_getter_blobs[dbus] out of memory "
2416 "when trying to open entry");
2417 reply = dbus_message_new_error(message,
2418 DBUS_ERROR_NO_MEMORY,
2419 NULL);
2420 goto out;
2421 }
2422
2423 if (!dbus_message_iter_append_basic(&entry_iter,
2424 DBUS_TYPE_STRING,
2425 &(blob->name))) {
2426 dbus_message_unref(reply);
2427 perror("wpas_dbus_getter_blobs[dbus] out of memory "
2428 "when trying to append blob name");
2429 reply = dbus_message_new_error(message,
2430 DBUS_ERROR_NO_MEMORY,
2431 NULL);
2432 goto out;
2433 }
2434
2435 if (!dbus_message_iter_open_container(&entry_iter,
2436 DBUS_TYPE_ARRAY,
2437 DBUS_TYPE_BYTE_AS_STRING,
2438 &array_iter)) {
2439 dbus_message_unref(reply);
2440 perror("wpas_dbus_getter_blobs[dbus] out of memory "
2441 "when trying to open array");
2442 reply = dbus_message_new_error(message,
2443 DBUS_ERROR_NO_MEMORY,
2444 NULL);
2445 goto out;
2446 }
2447
2448 if (!dbus_message_iter_append_fixed_array(&array_iter,
2449 DBUS_TYPE_BYTE,
2450 &(blob->data),
2451 blob->len)) {
2452 dbus_message_unref(reply);
2453 perror("wpas_dbus_getter_blobs[dbus] out of memory "
2454 "when trying to append blob data");
2455 reply = dbus_message_new_error(message,
2456 DBUS_ERROR_NO_MEMORY,
2457 NULL);
2458 goto out;
2459 }
2460
2461 if (!dbus_message_iter_close_container(&entry_iter,
2462 &array_iter)) {
2463 dbus_message_unref(reply);
2464 perror("wpas_dbus_getter_blobs[dbus] out of memory "
2465 "when trying to close array");
2466 reply = dbus_message_new_error(message,
2467 DBUS_ERROR_NO_MEMORY,
2468 NULL);
2469 goto out;
2470 }
2471
2472 if (!dbus_message_iter_close_container(&dict_iter,
2473 &entry_iter)) {
2474 dbus_message_unref(reply);
2475 perror("wpas_dbus_getter_blobs[dbus] out of memory "
2476 "when trying to close entry");
2477 reply = dbus_message_new_error(message,
2478 DBUS_ERROR_NO_MEMORY,
2479 NULL);
2480 goto out;
2481 }
2482
2483 blob = blob->next;
2484 }
2485
2486 if (!dbus_message_iter_close_container(&variant_iter, &dict_iter)) {
2487 dbus_message_unref(reply);
2488 perror("wpas_dbus_getter_blobs[dbus] out of memory when "
2489 "trying to close dictionary");
2490 reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
2491 NULL);
2492 goto out;
2493 }
2494
2495 if (!dbus_message_iter_close_container(&iter, &variant_iter)) {
2496 dbus_message_unref(reply);
2497 perror("wpas_dbus_getter_blobs[dbus] out of memory when "
2498 "trying to close variant");
2499 reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
2500 NULL);
2501 goto out;
2502 }
2503
2504 out:
2505 return reply;
2506 }
2507
2508
2509 /**
2510 * wpas_dbus_getter_bss_bssid - Return the BSSID of a BSS
2511 * @message: Pointer to incoming dbus message
2512 * @bss: a pair of interface describing structure and bss's id
2513 * Returns: a dbus message containing the bssid for the requested bss
2514 *
2515 * Getter for "BSSID" property.
2516 */
2517 DBusMessage * wpas_dbus_getter_bss_bssid(DBusMessage *message,
2518 struct bss_handler_args *bss)
2519 {
2520 struct wpa_bss *res = wpa_bss_get_id(bss->wpa_s, bss->id);
2521
2522 if (!res) {
2523 wpa_printf(MSG_ERROR, "wpas_dbus_getter_bss_bssid[dbus]: no "
2524 "bss with id %d found", bss->id);
2525 return NULL;
2526 }
2527
2528 return wpas_dbus_simple_array_property_getter(message, DBUS_TYPE_BYTE,
2529 res->bssid, ETH_ALEN);
2530 }
2531
2532
2533 /**
2534 * wpas_dbus_getter_bss_ssid - Return the SSID of a BSS
2535 * @message: Pointer to incoming dbus message
2536 * @bss: a pair of interface describing structure and bss's id
2537 * Returns: a dbus message containing the ssid for the requested bss
2538 *
2539 * Getter for "SSID" property.
2540 */
2541 DBusMessage * wpas_dbus_getter_bss_ssid(DBusMessage *message,
2542 struct bss_handler_args *bss)
2543 {
2544 struct wpa_bss *res = wpa_bss_get_id(bss->wpa_s, bss->id);
2545
2546 if (!res) {
2547 wpa_printf(MSG_ERROR, "wpas_dbus_getter_bss_ssid[dbus]: no "
2548 "bss with id %d found", bss->id);
2549 return NULL;
2550 }
2551
2552 return wpas_dbus_simple_array_property_getter(message, DBUS_TYPE_BYTE,
2553 res->ssid,
2554 res->ssid_len);
2555 }
2556
2557
2558 /**
2559 * wpas_dbus_getter_bss_privacy - Return the privacy flag of a BSS
2560 * @message: Pointer to incoming dbus message
2561 * @bss: a pair of interface describing structure and bss's id
2562 * Returns: a dbus message containing the privacy flag value of requested bss
2563 *
2564 * Getter for "Privacy" property.
2565 */
2566 DBusMessage * wpas_dbus_getter_bss_privacy(DBusMessage *message,
2567 struct bss_handler_args *bss)
2568 {
2569 struct wpa_bss *res = wpa_bss_get_id(bss->wpa_s, bss->id);
2570 dbus_bool_t privacy;
2571
2572 if (!res) {
2573 wpa_printf(MSG_ERROR, "wpas_dbus_getter_bss_privacy[dbus]: no "
2574 "bss with id %d found", bss->id);
2575 return NULL;
2576 }
2577
2578 privacy = res->caps && IEEE80211_CAP_PRIVACY ? TRUE : FALSE;
2579 return wpas_dbus_simple_property_getter(message, DBUS_TYPE_BOOLEAN,
2580 &privacy);
2581 }
2582
2583
2584 /**
2585 * wpas_dbus_getter_bss_mode - Return the mode of a BSS
2586 * @message: Pointer to incoming dbus message
2587 * @bss: a pair of interface describing structure and bss's id
2588 * Returns: a dbus message containing the mode of requested bss
2589 *
2590 * Getter for "Mode" property.
2591 */
2592 DBusMessage * wpas_dbus_getter_bss_mode(DBusMessage *message,
2593 struct bss_handler_args *bss)
2594 {
2595 struct wpa_bss *res = wpa_bss_get_id(bss->wpa_s, bss->id);
2596 const char *mode;
2597
2598 if (!res) {
2599 wpa_printf(MSG_ERROR, "wpas_dbus_getter_bss_mode[dbus]: no "
2600 "bss with id %d found", bss->id);
2601 return NULL;
2602 }
2603
2604 if (res->caps & IEEE80211_CAP_IBSS)
2605 mode = "ad-hoc";
2606 else
2607 mode = "infrastructure";
2608
2609 return wpas_dbus_simple_property_getter(message, DBUS_TYPE_STRING,
2610 &mode);
2611 }
2612
2613
2614 /**
2615 * wpas_dbus_getter_bss_level - Return the signal strength of a BSS
2616 * @message: Pointer to incoming dbus message
2617 * @bss: a pair of interface describing structure and bss's id
2618 * Returns: a dbus message containing the signal strength of requested bss
2619 *
2620 * Getter for "Level" property.
2621 */
2622 DBusMessage * wpas_dbus_getter_bss_signal(DBusMessage *message,
2623 struct bss_handler_args *bss)
2624 {
2625 struct wpa_bss *res = wpa_bss_get_id(bss->wpa_s, bss->id);
2626
2627 if (!res) {
2628 wpa_printf(MSG_ERROR, "wpas_dbus_getter_bss_signal[dbus]: no "
2629 "bss with id %d found", bss->id);
2630 return NULL;
2631 }
2632
2633 return wpas_dbus_simple_property_getter(message, DBUS_TYPE_INT16,
2634 &res->level);
2635 }
2636
2637
2638 /**
2639 * wpas_dbus_getter_bss_frequency - Return the frequency of a BSS
2640 * @message: Pointer to incoming dbus message
2641 * @bss: a pair of interface describing structure and bss's id
2642 * Returns: a dbus message containing the frequency of requested bss
2643 *
2644 * Getter for "Frequency" property.
2645 */
2646 DBusMessage * wpas_dbus_getter_bss_frequency(DBusMessage *message,
2647 struct bss_handler_args *bss)
2648 {
2649 struct wpa_bss *res = wpa_bss_get_id(bss->wpa_s, bss->id);
2650
2651 if (!res) {
2652 wpa_printf(MSG_ERROR, "wpas_dbus_getter_bss_frequency[dbus]: "
2653 "no bss with id %d found", bss->id);
2654 return NULL;
2655 }
2656
2657 return wpas_dbus_simple_property_getter(message, DBUS_TYPE_UINT16,
2658 &res->freq);
2659 }
2660
2661
2662 /**
2663 * wpas_dbus_getter_bss_max_rate - Return the maximal rate of a BSS
2664 * @message: Pointer to incoming dbus message
2665 * @bss: a pair of interface describing structure and bss's id
2666 * Returns: a dbus message containing the maximal data rate of requested bss
2667 *
2668 * Getter for "MaxRate" property.
2669 */
2670 DBusMessage * wpas_dbus_getter_bss_max_rate(DBusMessage *message,
2671 struct bss_handler_args *bss)
2672 {
2673 struct wpa_bss *res = wpa_bss_get_id(bss->wpa_s, bss->id);
2674 int max_rate;
2675
2676 if (!res) {
2677 wpa_printf(MSG_ERROR, "wpas_dbus_getter_bss_max_rate[dbus]: "
2678 "no bss with id %d found", bss->id);
2679 return NULL;
2680 }
2681
2682 max_rate = wpa_bss_get_max_rate(res);
2683 return wpas_dbus_simple_property_getter(message, DBUS_TYPE_UINT16,
2684 &max_rate);
2685 }
2686
2687
2688 /**
2689 * wpas_dbus_getter_bss_wpaie - Return the WPA IE of a BSS
2690 * @message: Pointer to incoming dbus message
2691 * @bss: a pair of interface describing structure and bss's id
2692 * Returns: a dbus message containing the WPA information elements
2693 * of requested bss
2694 *
2695 * Getter for "WPAIE" property.
2696 */
2697 DBusMessage * wpas_dbus_getter_bss_wpaie(DBusMessage *message,
2698 struct bss_handler_args *bss)
2699 {
2700 struct wpa_bss *res = wpa_bss_get_id(bss->wpa_s, bss->id);
2701 const u8 *ie;
2702
2703 if (!res) {
2704 wpa_printf(MSG_ERROR, "wpas_dbus_getter_bss_wpaie[dbus]: no "
2705 "bss with id %d found", bss->id);
2706 return NULL;
2707 }
2708
2709 ie = wpa_bss_get_vendor_ie(res, WPA_IE_VENDOR_TYPE);
2710 if (!ie)
2711 return NULL;
2712 return wpas_dbus_simple_array_property_getter(message, DBUS_TYPE_BYTE,
2713 ie, ie[1] + 2);
2714 }
2715
2716
2717 /**
2718 * wpas_dbus_getter_bss_rsnie - Return the RSN IE of a BSS
2719 * @message: Pointer to incoming dbus message
2720 * @bss: a pair of interface describing structure and bss's id
2721 * Returns: a dbus message containing the RSN information elements
2722 * of requested bss
2723 *
2724 * Getter for "RSNIE" property.
2725 */
2726 DBusMessage * wpas_dbus_getter_bss_rsnie(DBusMessage *message,
2727 struct bss_handler_args *bss)
2728 {
2729 struct wpa_bss *res = wpa_bss_get_id(bss->wpa_s, bss->id);
2730 const u8 *ie;
2731
2732 if (!res) {
2733 wpa_printf(MSG_ERROR, "wpas_dbus_getter_bss_rsnie[dbus]: no "
2734 "bss with id %d found", bss->id);
2735 return NULL;
2736 }
2737
2738 ie = wpa_bss_get_ie(res, WLAN_EID_RSN);
2739 if (!ie)
2740 return NULL;
2741 return wpas_dbus_simple_array_property_getter(message, DBUS_TYPE_BYTE,
2742 ie, ie[1] + 2);
2743 }
2744
2745
2746 /**
2747 * wpas_dbus_getter_bss_wpsie - Return the WPS IE of a BSS
2748 * @message: Pointer to incoming dbus message
2749 * @bss: a pair of interface describing structure and bss's id
2750 * Returns: a dbus message containing the WPS information elements
2751 * of requested bss
2752 *
2753 * Getter for "WPSIE" property.
2754 */
2755 DBusMessage * wpas_dbus_getter_bss_wpsie(DBusMessage *message,
2756 struct bss_handler_args *bss)
2757 {
2758 struct wpa_bss *res = wpa_bss_get_id(bss->wpa_s, bss->id);
2759 const u8 *ie;
2760
2761 if (!res) {
2762 wpa_printf(MSG_ERROR, "wpas_dbus_getter_bss_wpsie[dbus]: no "
2763 "bss with id %d found", bss->id);
2764 return NULL;
2765 }
2766
2767 ie = wpa_bss_get_vendor_ie(res, WPS_IE_VENDOR_TYPE);
2768 if (!ie)
2769 return NULL;
2770 return wpas_dbus_simple_array_property_getter(message, DBUS_TYPE_BYTE,
2771 ie, ie[1] + 2);
2772 }
2773
2774
2775 /**
2776 * wpas_dbus_getter_enabled - Check whether network is enabled or disabled
2777 * @message: Pointer to incoming dbus message
2778 * @wpas_dbus_setter_enabled: wpa_supplicant structure for a network interface
2779 * and wpa_ssid structure for a configured network
2780 * Returns: DBus message with boolean indicating state of configured network
2781 * or DBus error on failure
2782 *
2783 * Getter for "enabled" property of a configured network.
2784 */
2785 DBusMessage * wpas_dbus_getter_enabled(DBusMessage *message,
2786 struct network_handler_args *net)
2787 {
2788 dbus_bool_t enabled = net->ssid->disabled ? FALSE : TRUE;
2789 return wpas_dbus_simple_property_getter(message, DBUS_TYPE_BOOLEAN,
2790 &enabled);
2791 }
2792
2793
2794 /**
2795 * wpas_dbus_setter_enabled - Mark a configured network as enabled or disabled
2796 * @message: Pointer to incoming dbus message
2797 * @wpas_dbus_setter_enabled: wpa_supplicant structure for a network interface
2798 * and wpa_ssid structure for a configured network
2799 * Returns: NULL indicating success or DBus error on failure
2800 *
2801 * Setter for "Enabled" property of a configured network.
2802 */
2803 DBusMessage * wpas_dbus_setter_enabled(DBusMessage *message,
2804 struct network_handler_args *net)
2805 {
2806 DBusMessage *reply = NULL;
2807
2808 struct wpa_supplicant *wpa_s;
2809 struct wpa_ssid *ssid;
2810
2811 dbus_bool_t enable;
2812
2813 reply = wpas_dbus_simple_property_setter(message, DBUS_TYPE_BOOLEAN,
2814 &enable);
2815
2816 if (reply)
2817 return reply;
2818
2819 wpa_s = net->wpa_s;
2820 ssid = net->ssid;
2821
2822 if (enable)
2823 wpa_supplicant_enable_network(wpa_s, ssid);
2824 else
2825 wpa_supplicant_disable_network(wpa_s, ssid);
2826
2827 return NULL;
2828 }
2829
2830
2831 /**
2832 * wpas_dbus_getter_network_properties - Get options for a configured network
2833 * @message: Pointer to incoming dbus message
2834 * @net: wpa_supplicant structure for a network interface and
2835 * wpa_ssid structure for a configured network
2836 * Returns: DBus message with network properties or DBus error on failure
2837 *
2838 * Getter for "Properties" property of a configured network.
2839 */
2840 DBusMessage * wpas_dbus_getter_network_properties(
2841 DBusMessage *message, struct network_handler_args *net)
2842 {
2843 DBusMessage *reply = NULL;
2844 DBusMessageIter iter, variant_iter, dict_iter;
2845 char **iterator;
2846 char **props = wpa_config_get_all(net->ssid, 0);
2847 if (!props) {
2848 perror("wpas_dbus_getter_network_properties[dbus] couldn't "
2849 "read network properties. out of memory.");
2850 return dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
2851 NULL);
2852 }
2853
2854 if (message == NULL)
2855 reply = dbus_message_new(DBUS_MESSAGE_TYPE_SIGNAL);
2856 else
2857 reply = dbus_message_new_method_return(message);
2858 if (!reply) {
2859 perror("wpas_dbus_getter_network_properties[dbus] out of "
2860 "memory when trying to initialize return message");
2861 reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
2862 NULL);
2863 goto out;
2864 }
2865
2866 dbus_message_iter_init_append(reply, &iter);
2867
2868 if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT,
2869 "a{sv}", &variant_iter)) {
2870 perror("wpas_dbus_getter_network_properties[dbus] out of "
2871 "memory when trying to open variant container");
2872 dbus_message_unref(reply);
2873 reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
2874 NULL);
2875 goto out;
2876 }
2877
2878 if (!wpa_dbus_dict_open_write(&variant_iter, &dict_iter)) {
2879 perror("wpas_dbus_getter_network_properties[dbus] out of "
2880 "memory when trying to open dict");
2881 dbus_message_unref(reply);
2882 reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
2883 NULL);
2884 goto out;
2885 }
2886
2887 iterator = props;
2888 while (*iterator) {
2889 if (!wpa_dbus_dict_append_string(&dict_iter, *iterator,
2890 *(iterator + 1))) {
2891 perror("wpas_dbus_getter_network_properties[dbus] out "
2892 "of memory when trying to add entry");
2893 dbus_message_unref(reply);
2894 reply = dbus_message_new_error(message,
2895 DBUS_ERROR_NO_MEMORY,
2896 NULL);
2897 goto out;
2898 }
2899 iterator += 2;
2900 }
2901
2902
2903 if (!wpa_dbus_dict_close_write(&variant_iter, &dict_iter)) {
2904 perror("wpas_dbus_getter_network_properties[dbus] out of "
2905 "memory when trying to close dictionary");
2906 dbus_message_unref(reply);
2907 reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
2908 NULL);
2909 goto out;
2910 }
2911
2912 if (!dbus_message_iter_close_container(&iter, &variant_iter)) {
2913 perror("wpas_dbus_getter_network_properties[dbus] out of "
2914 "memory when trying to close variant container");
2915 dbus_message_unref(reply);
2916 reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
2917 NULL);
2918 goto out;
2919 }
2920
2921 out:
2922 iterator = props;
2923 while (*iterator) {
2924 os_free(*iterator);
2925 iterator++;
2926 }
2927 os_free(props);
2928 return reply;
2929 }
2930
2931
2932 /**
2933 * wpas_dbus_setter_network_properties - Set options for a configured network
2934 * @message: Pointer to incoming dbus message
2935 * @net: wpa_supplicant structure for a network interface and
2936 * wpa_ssid structure for a configured network
2937 * Returns: NULL indicating success or DBus error on failure
2938 *
2939 * Setter for "Properties" property of a configured network.
2940 */
2941 DBusMessage * wpas_dbus_setter_network_properties(
2942 DBusMessage *message, struct network_handler_args *net)
2943 {
2944 struct wpa_ssid *ssid = net->ssid;
2945
2946 DBusMessage *reply = NULL;
2947 DBusMessageIter iter, variant_iter;
2948
2949 dbus_message_iter_init(message, &iter);
2950
2951 dbus_message_iter_next(&iter);
2952 dbus_message_iter_next(&iter);
2953
2954 dbus_message_iter_recurse(&iter, &variant_iter);
2955
2956 reply = set_network_properties(message, ssid, &variant_iter);
2957 if (reply)
2958 wpa_printf(MSG_DEBUG, "dbus control interface couldn't set "
2959 "network properties");
2960
2961 return reply;
2962 }