| /* |
| * WPA Supplicant / dbus-based control interface |
| * Copyright (c) 2006, Dan Williams <dcbw@redhat.com> and Red Hat, Inc. |
| * Copyright (c) 2009-2010, Witold Sowa <witold.sowa@gmail.com> |
| * Copyright (c) 2009-2015, Jouni Malinen <j@w1.fi> |
| * |
| * This software may be distributed under the terms of the BSD license. |
| * See README for more details. |
| */ |
| |
| #include "includes.h" |
| |
| #include "common.h" |
| #include "common/ieee802_11_defs.h" |
| #include "eap_peer/eap_methods.h" |
| #include "eapol_supp/eapol_supp_sm.h" |
| #include "rsn_supp/wpa.h" |
| #include "ap/hostapd.h" |
| #include "ap/sta_info.h" |
| #include "ap/ap_drv_ops.h" |
| #include "../config.h" |
| #include "../wpa_supplicant_i.h" |
| #include "../driver_i.h" |
| #include "../notify.h" |
| #include "../bss.h" |
| #include "../scan.h" |
| #include "../autoscan.h" |
| #include "../ap.h" |
| #include "dbus_new_helpers.h" |
| #include "dbus_new.h" |
| #include "dbus_new_handlers.h" |
| #include "dbus_dict_helpers.h" |
| #include "dbus_common_i.h" |
| #include "drivers/driver.h" |
| #ifdef CONFIG_MESH |
| #include "ap/hostapd.h" |
| #include "ap/sta_info.h" |
| #endif /* CONFIG_MESH */ |
| |
| static const char * const debug_strings[] = { |
| "excessive", "msgdump", "debug", "info", "warning", "error", NULL |
| }; |
| |
| |
| /** |
| * wpas_dbus_error_unknown_error - Return a new UnknownError error message |
| * @message: Pointer to incoming dbus message this error refers to |
| * @arg: Optional string appended to error message |
| * Returns: a dbus error message |
| * |
| * Convenience function to create and return an UnknownError |
| */ |
| DBusMessage * wpas_dbus_error_unknown_error(DBusMessage *message, |
| const char *arg) |
| { |
| return dbus_message_new_error(message, WPAS_DBUS_ERROR_UNKNOWN_ERROR, |
| arg); |
| } |
| |
| |
| /** |
| * wpas_dbus_error_iface_unknown - Return a new invalid interface error message |
| * @message: Pointer to incoming dbus message this error refers to |
| * Returns: A dbus error message |
| * |
| * Convenience function to create and return an invalid interface error |
| */ |
| static DBusMessage * wpas_dbus_error_iface_unknown(DBusMessage *message) |
| { |
| return dbus_message_new_error( |
| message, WPAS_DBUS_ERROR_IFACE_UNKNOWN, |
| "wpa_supplicant knows nothing about this interface."); |
| } |
| |
| |
| /** |
| * wpas_dbus_error_network_unknown - Return a new NetworkUnknown error message |
| * @message: Pointer to incoming dbus message this error refers to |
| * Returns: a dbus error message |
| * |
| * Convenience function to create and return an invalid network error |
| */ |
| static DBusMessage * wpas_dbus_error_network_unknown(DBusMessage *message) |
| { |
| return dbus_message_new_error( |
| message, WPAS_DBUS_ERROR_NETWORK_UNKNOWN, |
| "There is no such a network in this interface."); |
| } |
| |
| |
| /** |
| * wpas_dbus_error_invalid_args - Return a new InvalidArgs error message |
| * @message: Pointer to incoming dbus message this error refers to |
| * Returns: a dbus error message |
| * |
| * Convenience function to create and return an invalid options error |
| */ |
| DBusMessage * wpas_dbus_error_invalid_args(DBusMessage *message, |
| const char *arg) |
| { |
| DBusMessage *reply; |
| |
| reply = dbus_message_new_error( |
| message, WPAS_DBUS_ERROR_INVALID_ARGS, |
| "Did not receive correct message arguments."); |
| if (arg != NULL) |
| dbus_message_append_args(reply, DBUS_TYPE_STRING, &arg, |
| DBUS_TYPE_INVALID); |
| |
| return reply; |
| } |
| |
| |
| /** |
| * wpas_dbus_error_scan_error - Return a new ScanError error message |
| * @message: Pointer to incoming dbus message this error refers to |
| * @error: Optional string to be used as the error message |
| * Returns: a dbus error message |
| * |
| * Convenience function to create and return a scan error |
| */ |
| static DBusMessage * wpas_dbus_error_scan_error(DBusMessage *message, |
| const char *error) |
| { |
| return dbus_message_new_error(message, |
| WPAS_DBUS_ERROR_IFACE_SCAN_ERROR, |
| error); |
| } |
| |
| |
| DBusMessage * wpas_dbus_error_no_memory(DBusMessage *message) |
| { |
| wpa_printf(MSG_DEBUG, "dbus: Failed to allocate memory"); |
| return dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY, NULL); |
| } |
| |
| |
| static const char * const dont_quote[] = { |
| "key_mgmt", "proto", "pairwise", "auth_alg", "group", "eap", |
| "bssid", "scan_freq", "freq_list", "scan_ssid", "bssid_hint", |
| "bssid_ignore", "bssid_accept", /* deprecated aliases */ |
| "bssid_blacklist", "bssid_whitelist", |
| "group_mgmt", |
| "ignore_broadcast_ssid", |
| #ifdef CONFIG_MESH |
| "mesh_basic_rates", |
| #endif /* CONFIG_MESH */ |
| #ifdef CONFIG_P2P |
| "go_p2p_dev_addr", "p2p_client_list", "psk_list", |
| #endif /* CONFIG_P2P */ |
| NULL |
| }; |
| |
| static dbus_bool_t should_quote_opt(const char *key) |
| { |
| int i = 0; |
| |
| while (dont_quote[i] != NULL) { |
| if (os_strcmp(key, dont_quote[i]) == 0) |
| return FALSE; |
| i++; |
| } |
| return TRUE; |
| } |
| |
| /** |
| * get_iface_by_dbus_path - Get a new network interface |
| * @global: Pointer to global data from wpa_supplicant_init() |
| * @path: Pointer to a dbus object path representing an interface |
| * Returns: Pointer to the interface or %NULL if not found |
| */ |
| static struct wpa_supplicant * get_iface_by_dbus_path( |
| struct wpa_global *global, const char *path) |
| { |
| struct wpa_supplicant *wpa_s; |
| |
| for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) { |
| if (wpa_s->dbus_new_path && |
| os_strcmp(wpa_s->dbus_new_path, path) == 0) |
| return wpa_s; |
| } |
| return NULL; |
| } |
| |
| |
| /** |
| * set_network_properties - Set properties of a configured network |
| * @wpa_s: wpa_supplicant structure for a network interface |
| * @ssid: wpa_ssid structure for a configured network |
| * @iter: DBus message iterator containing dictionary of network |
| * properties to set. |
| * @error: On failure, an error describing the failure |
| * Returns: TRUE if the request succeeds, FALSE if it failed |
| * |
| * Sets network configuration with parameters given id DBus dictionary |
| */ |
| dbus_bool_t set_network_properties(struct wpa_supplicant *wpa_s, |
| struct wpa_ssid *ssid, |
| DBusMessageIter *iter, |
| DBusError *error) |
| { |
| struct wpa_dbus_dict_entry entry = { .type = DBUS_TYPE_STRING }; |
| DBusMessageIter iter_dict; |
| char *value = NULL; |
| |
| if (!wpa_dbus_dict_open_read(iter, &iter_dict, error)) |
| return FALSE; |
| |
| while (wpa_dbus_dict_has_dict_entry(&iter_dict)) { |
| size_t size = 50; |
| int ret; |
| |
| if (!wpa_dbus_dict_get_entry(&iter_dict, &entry)) |
| goto error; |
| |
| value = NULL; |
| if (entry.type == DBUS_TYPE_ARRAY && |
| entry.array_type == DBUS_TYPE_BYTE) { |
| if (entry.array_len <= 0) |
| goto error; |
| |
| size = entry.array_len * 2 + 1; |
| value = os_zalloc(size); |
| if (value == NULL) |
| goto error; |
| |
| ret = wpa_snprintf_hex(value, size, |
| (u8 *) entry.bytearray_value, |
| entry.array_len); |
| if (ret <= 0) |
| goto error; |
| } else if (entry.type == DBUS_TYPE_STRING) { |
| if (should_quote_opt(entry.key)) { |
| size = os_strlen(entry.str_value); |
| |
| size += 3; |
| value = os_zalloc(size); |
| if (value == NULL) |
| goto error; |
| |
| ret = os_snprintf(value, size, "\"%s\"", |
| entry.str_value); |
| if (os_snprintf_error(size, ret)) |
| goto error; |
| } else { |
| value = os_strdup(entry.str_value); |
| if (value == NULL) |
| goto error; |
| } |
| } else if (entry.type == DBUS_TYPE_UINT32) { |
| value = os_zalloc(size); |
| if (value == NULL) |
| goto error; |
| |
| ret = os_snprintf(value, size, "%u", |
| entry.uint32_value); |
| if (os_snprintf_error(size, ret)) |
| goto error; |
| } else if (entry.type == DBUS_TYPE_INT32) { |
| value = os_zalloc(size); |
| if (value == NULL) |
| goto error; |
| |
| ret = os_snprintf(value, size, "%d", |
| entry.int32_value); |
| if (os_snprintf_error(size, ret)) |
| goto error; |
| } else |
| goto error; |
| |
| ret = wpa_config_set(ssid, entry.key, value, 0); |
| if (ret < 0) |
| goto error; |
| if (ret == 1) |
| goto skip_update; |
| |
| #ifdef CONFIG_BGSCAN |
| if (os_strcmp(entry.key, "bgscan") == 0) { |
| /* |
| * Reset the bgscan parameters for the current network |
| * and continue. There's no need to flush caches for |
| * bgscan parameter changes. |
| */ |
| if (wpa_s->current_ssid == ssid && |
| wpa_s->wpa_state == WPA_COMPLETED) |
| wpa_supplicant_reset_bgscan(wpa_s); |
| os_free(value); |
| value = NULL; |
| wpa_dbus_dict_entry_clear(&entry); |
| continue; |
| } |
| #endif /* CONFIG_BGSCAN */ |
| |
| if (os_strcmp(entry.key, "bssid") != 0 && |
| os_strcmp(entry.key, "priority") != 0) |
| wpa_sm_pmksa_cache_flush(wpa_s->wpa, ssid); |
| |
| if (wpa_s->current_ssid == ssid || |
| wpa_s->current_ssid == NULL) { |
| /* |
| * Invalidate the EAP session cache if anything in the |
| * current or previously used configuration changes. |
| */ |
| eapol_sm_invalidate_cached_session(wpa_s->eapol); |
| } |
| |
| if ((os_strcmp(entry.key, "psk") == 0 && |
| value[0] == '"' && ssid->ssid_len) || |
| (os_strcmp(entry.key, "ssid") == 0 && ssid->passphrase)) |
| wpa_config_update_psk(ssid); |
| else if (os_strcmp(entry.key, "priority") == 0) |
| wpa_config_update_prio_list(wpa_s->conf); |
| |
| skip_update: |
| os_free(value); |
| value = NULL; |
| wpa_dbus_dict_entry_clear(&entry); |
| } |
| |
| return TRUE; |
| |
| error: |
| os_free(value); |
| wpa_dbus_dict_entry_clear(&entry); |
| dbus_set_error_const(error, DBUS_ERROR_INVALID_ARGS, |
| "invalid message format"); |
| return FALSE; |
| } |
| |
| |
| /** |
| * wpas_dbus_simple_property_getter - Get basic type property |
| * @iter: Message iter to use when appending arguments |
| * @type: DBus type of property (must be basic type) |
| * @val: pointer to place holding property value |
| * @error: On failure an error describing the failure |
| * Returns: TRUE if the request was successful, FALSE if it failed |
| * |
| * Generic getter for basic type properties. Type is required to be basic. |
| */ |
| dbus_bool_t wpas_dbus_simple_property_getter(DBusMessageIter *iter, |
| const int type, |
| const void *val, |
| DBusError *error) |
| { |
| DBusMessageIter variant_iter; |
| |
| if (!dbus_type_is_basic(type)) { |
| dbus_set_error(error, DBUS_ERROR_FAILED, |
| "%s: given type is not basic", __func__); |
| return FALSE; |
| } |
| |
| if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT, |
| wpa_dbus_type_as_string(type), |
| &variant_iter) || |
| !dbus_message_iter_append_basic(&variant_iter, type, val) || |
| !dbus_message_iter_close_container(iter, &variant_iter)) { |
| dbus_set_error(error, DBUS_ERROR_FAILED, |
| "%s: error constructing reply", __func__); |
| return FALSE; |
| } |
| |
| return TRUE; |
| } |
| |
| |
| /** |
| * wpas_dbus_simple_property_setter - Set basic type property |
| * @message: Pointer to incoming dbus message |
| * @type: DBus type of property (must be basic type) |
| * @val: pointer to place where value being set will be stored |
| * Returns: TRUE if the request was successful, FALSE if it failed |
| * |
| * Generic setter for basic type properties. Type is required to be basic. |
| */ |
| dbus_bool_t wpas_dbus_simple_property_setter(DBusMessageIter *iter, |
| DBusError *error, |
| const int type, void *val) |
| { |
| DBusMessageIter variant_iter; |
| |
| if (!dbus_type_is_basic(type)) { |
| dbus_set_error(error, DBUS_ERROR_FAILED, |
| "%s: given type is not basic", __func__); |
| return FALSE; |
| } |
| |
| /* Look at the new value */ |
| dbus_message_iter_recurse(iter, &variant_iter); |
| if (dbus_message_iter_get_arg_type(&variant_iter) != type) { |
| dbus_set_error_const(error, DBUS_ERROR_FAILED, |
| "wrong property type"); |
| return FALSE; |
| } |
| dbus_message_iter_get_basic(&variant_iter, val); |
| |
| return TRUE; |
| } |
| |
| |
| /** |
| * wpas_dbus_simple_array_property_getter - Get array type property |
| * @iter: Pointer to incoming dbus message iterator |
| * @type: DBus type of property array elements (must be basic type) |
| * @array: pointer to array of elements to put into response message |
| * @array_len: length of above array |
| * @error: a pointer to an error to fill on failure |
| * Returns: TRUE if the request succeeded, FALSE if it failed |
| * |
| * Generic getter for array type properties. Array elements type is |
| * required to be basic. |
| */ |
| dbus_bool_t wpas_dbus_simple_array_property_getter(DBusMessageIter *iter, |
| const int type, |
| const void *array, |
| size_t array_len, |
| DBusError *error) |
| { |
| DBusMessageIter variant_iter, array_iter; |
| char type_str[] = "a?"; /* ? will be replaced with subtype letter; */ |
| const char *sub_type_str; |
| size_t element_size, i; |
| |
| if (!dbus_type_is_basic(type)) { |
| dbus_set_error(error, DBUS_ERROR_FAILED, |
| "%s: given type is not basic", __func__); |
| return FALSE; |
| } |
| |
| sub_type_str = wpa_dbus_type_as_string(type); |
| type_str[1] = sub_type_str[0]; |
| |
| if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT, |
| type_str, &variant_iter) || |
| !dbus_message_iter_open_container(&variant_iter, DBUS_TYPE_ARRAY, |
| sub_type_str, &array_iter)) { |
| dbus_set_error(error, DBUS_ERROR_FAILED, |
| "%s: failed to construct message", __func__); |
| return FALSE; |
| } |
| |
| switch (type) { |
| case DBUS_TYPE_BYTE: |
| case DBUS_TYPE_BOOLEAN: |
| element_size = 1; |
| break; |
| case DBUS_TYPE_INT16: |
| case DBUS_TYPE_UINT16: |
| element_size = sizeof(uint16_t); |
| break; |
| case DBUS_TYPE_INT32: |
| case DBUS_TYPE_UINT32: |
| element_size = sizeof(uint32_t); |
| break; |
| case DBUS_TYPE_INT64: |
| case DBUS_TYPE_UINT64: |
| element_size = sizeof(uint64_t); |
| break; |
| case DBUS_TYPE_DOUBLE: |
| element_size = sizeof(double); |
| break; |
| case DBUS_TYPE_STRING: |
| case DBUS_TYPE_OBJECT_PATH: |
| element_size = sizeof(char *); |
| break; |
| default: |
| dbus_set_error(error, DBUS_ERROR_FAILED, |
| "%s: unknown element type %d", __func__, type); |
| return FALSE; |
| } |
| |
| for (i = 0; i < array_len; i++) { |
| if (!dbus_message_iter_append_basic(&array_iter, type, |
| (const char *) array + |
| i * element_size)) { |
| dbus_set_error(error, DBUS_ERROR_FAILED, |
| "%s: failed to construct message 2.5", |
| __func__); |
| return FALSE; |
| } |
| } |
| |
| if (!dbus_message_iter_close_container(&variant_iter, &array_iter) || |
| !dbus_message_iter_close_container(iter, &variant_iter)) { |
| dbus_set_error(error, DBUS_ERROR_FAILED, |
| "%s: failed to construct message 3", __func__); |
| return FALSE; |
| } |
| |
| return TRUE; |
| } |
| |
| |
| /** |
| * wpas_dbus_simple_array_array_property_getter - Get array array type property |
| * @iter: Pointer to incoming dbus message iterator |
| * @type: DBus type of property array elements (must be basic type) |
| * @array: pointer to array of elements to put into response message |
| * @array_len: length of above array |
| * @error: a pointer to an error to fill on failure |
| * Returns: TRUE if the request succeeded, FALSE if it failed |
| * |
| * Generic getter for array type properties. Array elements type is |
| * required to be basic. |
| */ |
| dbus_bool_t wpas_dbus_simple_array_array_property_getter(DBusMessageIter *iter, |
| const int type, |
| struct wpabuf **array, |
| size_t array_len, |
| DBusError *error) |
| { |
| DBusMessageIter variant_iter, array_iter; |
| char type_str[] = "aa?"; |
| char inner_type_str[] = "a?"; |
| const char *sub_type_str; |
| size_t i; |
| |
| if (!dbus_type_is_basic(type)) { |
| dbus_set_error(error, DBUS_ERROR_FAILED, |
| "%s: given type is not basic", __func__); |
| return FALSE; |
| } |
| |
| sub_type_str = wpa_dbus_type_as_string(type); |
| type_str[2] = sub_type_str[0]; |
| inner_type_str[1] = sub_type_str[0]; |
| |
| if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT, |
| type_str, &variant_iter) || |
| !dbus_message_iter_open_container(&variant_iter, DBUS_TYPE_ARRAY, |
| inner_type_str, &array_iter)) { |
| dbus_set_error(error, DBUS_ERROR_FAILED, |
| "%s: failed to construct message", __func__); |
| return FALSE; |
| } |
| |
| for (i = 0; i < array_len && array[i]; i++) { |
| wpa_dbus_dict_bin_array_add_element(&array_iter, |
| wpabuf_head(array[i]), |
| wpabuf_len(array[i])); |
| |
| } |
| |
| if (!dbus_message_iter_close_container(&variant_iter, &array_iter) || |
| !dbus_message_iter_close_container(iter, &variant_iter)) { |
| dbus_set_error(error, DBUS_ERROR_FAILED, |
| "%s: failed to close message", __func__); |
| return FALSE; |
| } |
| |
| return TRUE; |
| } |
| |
| |
| /** |
| * wpas_dbus_string_property_getter - Get string type property |
| * @iter: Message iter to use when appending arguments |
| * @val: Pointer to place holding property value, can be %NULL |
| * @error: On failure an error describing the failure |
| * Returns: TRUE if the request was successful, FALSE if it failed |
| * |
| * Generic getter for string type properties. %NULL is converted to an empty |
| * string. |
| */ |
| dbus_bool_t wpas_dbus_string_property_getter(DBusMessageIter *iter, |
| const void *val, |
| DBusError *error) |
| { |
| if (!val) |
| val = ""; |
| return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING, |
| &val, error); |
| } |
| |
| |
| /** |
| * wpas_dbus_handler_create_interface - Request registration of a network iface |
| * @message: Pointer to incoming dbus message |
| * @global: %wpa_supplicant global data structure |
| * Returns: The object path of the new interface object, |
| * or a dbus error message with more information |
| * |
| * Handler function for "CreateInterface" method call. Handles requests |
| * by dbus clients to register a network interface that wpa_supplicant |
| * will manage. |
| */ |
| DBusMessage * wpas_dbus_handler_create_interface(DBusMessage *message, |
| struct wpa_global *global) |
| { |
| DBusMessageIter iter_dict; |
| DBusMessage *reply = NULL; |
| DBusMessageIter iter; |
| struct wpa_dbus_dict_entry entry; |
| char *driver = NULL; |
| char *ifname = NULL; |
| char *confname = NULL; |
| char *bridge_ifname = NULL; |
| |
| dbus_message_iter_init(message, &iter); |
| |
| if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL)) |
| goto error; |
| while (wpa_dbus_dict_has_dict_entry(&iter_dict)) { |
| if (!wpa_dbus_dict_get_entry(&iter_dict, &entry)) |
| goto error; |
| if (os_strcmp(entry.key, "Driver") == 0 && |
| entry.type == DBUS_TYPE_STRING) { |
| os_free(driver); |
| driver = os_strdup(entry.str_value); |
| wpa_dbus_dict_entry_clear(&entry); |
| if (driver == NULL) |
| goto oom; |
| } else if (os_strcmp(entry.key, "Ifname") == 0 && |
| entry.type == DBUS_TYPE_STRING) { |
| os_free(ifname); |
| ifname = os_strdup(entry.str_value); |
| wpa_dbus_dict_entry_clear(&entry); |
| if (ifname == NULL) |
| goto oom; |
| } else if (os_strcmp(entry.key, "ConfigFile") == 0 && |
| entry.type == DBUS_TYPE_STRING) { |
| os_free(confname); |
| confname = os_strdup(entry.str_value); |
| wpa_dbus_dict_entry_clear(&entry); |
| if (confname == NULL) |
| goto oom; |
| } else if (os_strcmp(entry.key, "BridgeIfname") == 0 && |
| entry.type == DBUS_TYPE_STRING) { |
| os_free(bridge_ifname); |
| bridge_ifname = os_strdup(entry.str_value); |
| wpa_dbus_dict_entry_clear(&entry); |
| if (bridge_ifname == NULL) |
| goto oom; |
| } else { |
| wpa_dbus_dict_entry_clear(&entry); |
| goto error; |
| } |
| } |
| |
| if (ifname == NULL) |
| goto error; /* Required Ifname argument missing */ |
| |
| /* |
| * Try to get the wpa_supplicant record for this iface, return |
| * an error if we already control it. |
| */ |
| if (wpa_supplicant_get_iface(global, ifname) != NULL) { |
| reply = dbus_message_new_error( |
| message, WPAS_DBUS_ERROR_IFACE_EXISTS, |
| "wpa_supplicant already controls this interface."); |
| } else { |
| struct wpa_supplicant *wpa_s; |
| struct wpa_interface iface; |
| |
| os_memset(&iface, 0, sizeof(iface)); |
| iface.driver = driver; |
| iface.ifname = ifname; |
| iface.confname = confname; |
| iface.bridge_ifname = bridge_ifname; |
| /* Otherwise, have wpa_supplicant attach to it. */ |
| wpa_s = wpa_supplicant_add_iface(global, &iface, NULL); |
| if (wpa_s && wpa_s->dbus_new_path) { |
| const char *path = wpa_s->dbus_new_path; |
| |
| reply = dbus_message_new_method_return(message); |
| dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH, |
| &path, DBUS_TYPE_INVALID); |
| } else { |
| reply = wpas_dbus_error_unknown_error( |
| message, |
| "wpa_supplicant couldn't grab this interface."); |
| } |
| } |
| |
| out: |
| os_free(driver); |
| os_free(ifname); |
| os_free(confname); |
| os_free(bridge_ifname); |
| return reply; |
| |
| error: |
| reply = wpas_dbus_error_invalid_args(message, NULL); |
| goto out; |
| oom: |
| reply = wpas_dbus_error_no_memory(message); |
| goto out; |
| } |
| |
| |
| /** |
| * wpas_dbus_handler_remove_interface - Request deregistration of an interface |
| * @message: Pointer to incoming dbus message |
| * @global: wpa_supplicant global data structure |
| * Returns: a dbus message containing a UINT32 indicating success (1) or |
| * failure (0), or returns a dbus error message with more information |
| * |
| * Handler function for "removeInterface" method call. Handles requests |
| * by dbus clients to deregister a network interface that wpa_supplicant |
| * currently manages. |
| */ |
| DBusMessage * wpas_dbus_handler_remove_interface(DBusMessage *message, |
| struct wpa_global *global) |
| { |
| struct wpa_supplicant *wpa_s; |
| char *path; |
| DBusMessage *reply = NULL; |
| |
| dbus_message_get_args(message, NULL, DBUS_TYPE_OBJECT_PATH, &path, |
| DBUS_TYPE_INVALID); |
| |
| wpa_s = get_iface_by_dbus_path(global, path); |
| if (wpa_s == NULL) |
| reply = wpas_dbus_error_iface_unknown(message); |
| else if (wpa_supplicant_remove_iface(global, wpa_s, 0)) { |
| reply = wpas_dbus_error_unknown_error( |
| message, |
| "wpa_supplicant couldn't remove this interface."); |
| } |
| |
| return reply; |
| } |
| |
| |
| /** |
| * wpas_dbus_handler_get_interface - Get the object path for an interface name |
| * @message: Pointer to incoming dbus message |
| * @global: %wpa_supplicant global data structure |
| * Returns: The object path of the interface object, |
| * or a dbus error message with more information |
| * |
| * Handler function for "getInterface" method call. |
| */ |
| DBusMessage * wpas_dbus_handler_get_interface(DBusMessage *message, |
| struct wpa_global *global) |
| { |
| DBusMessage *reply = NULL; |
| const char *ifname; |
| const char *path; |
| struct wpa_supplicant *wpa_s; |
| |
| dbus_message_get_args(message, NULL, DBUS_TYPE_STRING, &ifname, |
| DBUS_TYPE_INVALID); |
| |
| wpa_s = wpa_supplicant_get_iface(global, ifname); |
| if (wpa_s == NULL || wpa_s->dbus_new_path == NULL) |
| return wpas_dbus_error_iface_unknown(message); |
| |
| path = wpa_s->dbus_new_path; |
| reply = dbus_message_new_method_return(message); |
| if (reply == NULL) |
| return wpas_dbus_error_no_memory(message); |
| if (!dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH, &path, |
| DBUS_TYPE_INVALID)) { |
| dbus_message_unref(reply); |
| return wpas_dbus_error_no_memory(message); |
| } |
| |
| return reply; |
| } |
| |
| |
| /** |
| * wpas_dbus_getter_debug_level - Get debug level |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Getter for "DebugLevel" property. |
| */ |
| dbus_bool_t wpas_dbus_getter_debug_level( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| const char *str; |
| int idx = wpa_debug_level; |
| |
| if (idx < 0) |
| idx = 0; |
| if (idx > 5) |
| idx = 5; |
| str = debug_strings[idx]; |
| return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING, |
| &str, error); |
| } |
| |
| |
| /** |
| * wpas_dbus_getter_debug_timestamp - Get debug timestamp |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Getter for "DebugTimestamp" property. |
| */ |
| dbus_bool_t wpas_dbus_getter_debug_timestamp( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_BOOLEAN, |
| &wpa_debug_timestamp, error); |
| |
| } |
| |
| |
| /** |
| * wpas_dbus_getter_debug_show_keys - Get debug show keys |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Getter for "DebugShowKeys" property. |
| */ |
| dbus_bool_t wpas_dbus_getter_debug_show_keys( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_BOOLEAN, |
| &wpa_debug_show_keys, error); |
| |
| } |
| |
| /** |
| * wpas_dbus_setter_debug_level - Set debug level |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Setter for "DebugLevel" property. |
| */ |
| dbus_bool_t wpas_dbus_setter_debug_level( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct wpa_global *global = user_data; |
| const char *str = NULL; |
| int i, val = -1; |
| |
| if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_STRING, |
| &str)) |
| return FALSE; |
| |
| for (i = 0; debug_strings[i]; i++) |
| if (os_strcmp(debug_strings[i], str) == 0) { |
| val = i; |
| break; |
| } |
| |
| if (val < 0 || |
| wpa_supplicant_set_debug_params(global, val, wpa_debug_timestamp, |
| wpa_debug_show_keys)) { |
| dbus_set_error_const(error, DBUS_ERROR_FAILED, |
| "wrong debug level value"); |
| return FALSE; |
| } |
| |
| return TRUE; |
| } |
| |
| |
| /** |
| * wpas_dbus_setter_debug_timestamp - Set debug timestamp |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Setter for "DebugTimestamp" property. |
| */ |
| dbus_bool_t wpas_dbus_setter_debug_timestamp( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct wpa_global *global = user_data; |
| dbus_bool_t val; |
| |
| if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_BOOLEAN, |
| &val)) |
| return FALSE; |
| |
| wpa_supplicant_set_debug_params(global, wpa_debug_level, val ? 1 : 0, |
| wpa_debug_show_keys); |
| return TRUE; |
| } |
| |
| |
| /** |
| * wpas_dbus_setter_debug_show_keys - Set debug show keys |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Setter for "DebugShowKeys" property. |
| */ |
| dbus_bool_t wpas_dbus_setter_debug_show_keys( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct wpa_global *global = user_data; |
| dbus_bool_t val; |
| |
| if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_BOOLEAN, |
| &val)) |
| return FALSE; |
| |
| wpa_supplicant_set_debug_params(global, wpa_debug_level, |
| wpa_debug_timestamp, |
| val ? 1 : 0); |
| return TRUE; |
| } |
| |
| |
| /** |
| * wpas_dbus_getter_interfaces - Request registered interfaces list |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Getter for "Interfaces" property. Handles requests |
| * by dbus clients to return list of registered interfaces objects |
| * paths |
| */ |
| dbus_bool_t wpas_dbus_getter_interfaces( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct wpa_global *global = user_data; |
| struct wpa_supplicant *wpa_s; |
| const char **paths; |
| unsigned int i = 0, num = 0; |
| dbus_bool_t success; |
| |
| for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) { |
| if (wpa_s->dbus_new_path) |
| num++; |
| } |
| |
| paths = os_calloc(num, sizeof(char *)); |
| if (!paths) { |
| dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory"); |
| return FALSE; |
| } |
| |
| for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) { |
| if (wpa_s->dbus_new_path) |
| paths[i++] = wpa_s->dbus_new_path; |
| } |
| |
| success = wpas_dbus_simple_array_property_getter(iter, |
| DBUS_TYPE_OBJECT_PATH, |
| paths, num, error); |
| |
| os_free(paths); |
| return success; |
| } |
| |
| |
| /** |
| * wpas_dbus_getter_eap_methods - Request supported EAP methods list |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Getter for "EapMethods" property. Handles requests |
| * by dbus clients to return list of strings with supported EAP methods |
| */ |
| dbus_bool_t wpas_dbus_getter_eap_methods( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| char **eap_methods; |
| size_t num_items = 0; |
| dbus_bool_t success; |
| |
| eap_methods = eap_get_names_as_string_array(&num_items); |
| if (!eap_methods) { |
| dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory"); |
| return FALSE; |
| } |
| |
| success = wpas_dbus_simple_array_property_getter(iter, |
| DBUS_TYPE_STRING, |
| eap_methods, |
| num_items, error); |
| |
| while (num_items) |
| os_free(eap_methods[--num_items]); |
| os_free(eap_methods); |
| return success; |
| } |
| |
| |
| /** |
| * wpas_dbus_getter_global_capabilities - Request supported global capabilities |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Getter for "Capabilities" property. Handles requests by dbus clients to |
| * return a list of strings with supported capabilities like AP, RSN IBSS, |
| * and P2P that are determined at compile time. |
| */ |
| dbus_bool_t wpas_dbus_getter_global_capabilities( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| const char *capabilities[13]; |
| size_t num_items = 0; |
| struct wpa_global *global = user_data; |
| struct wpa_supplicant *wpa_s; |
| #ifdef CONFIG_FILS |
| int fils_supported = 0, fils_sk_pfs_supported = 0; |
| #endif /* CONFIG_FILS */ |
| int ext_key_id_supported = 0; |
| |
| for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) { |
| #ifdef CONFIG_FILS |
| if (wpa_is_fils_supported(wpa_s)) |
| fils_supported = 1; |
| if (wpa_is_fils_sk_pfs_supported(wpa_s)) |
| fils_sk_pfs_supported = 1; |
| #endif /* CONFIG_FILS */ |
| if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_EXTENDED_KEY_ID) |
| ext_key_id_supported = 1; |
| } |
| |
| #ifdef CONFIG_AP |
| capabilities[num_items++] = "ap"; |
| #endif /* CONFIG_AP */ |
| #ifdef CONFIG_IBSS_RSN |
| capabilities[num_items++] = "ibss-rsn"; |
| #endif /* CONFIG_IBSS_RSN */ |
| #ifdef CONFIG_P2P |
| capabilities[num_items++] = "p2p"; |
| #endif /* CONFIG_P2P */ |
| #ifdef CONFIG_INTERWORKING |
| capabilities[num_items++] = "interworking"; |
| #endif /* CONFIG_INTERWORKING */ |
| capabilities[num_items++] = "pmf"; |
| #ifdef CONFIG_MESH |
| capabilities[num_items++] = "mesh"; |
| #endif /* CONFIG_MESH */ |
| #ifdef CONFIG_FILS |
| if (fils_supported) |
| capabilities[num_items++] = "fils"; |
| if (fils_sk_pfs_supported) |
| capabilities[num_items++] = "fils_sk_pfs"; |
| #endif /* CONFIG_FILS */ |
| #ifdef CONFIG_IEEE80211R |
| capabilities[num_items++] = "ft"; |
| #endif /* CONFIG_IEEE80211R */ |
| #ifdef CONFIG_SHA384 |
| capabilities[num_items++] = "sha384"; |
| #endif /* CONFIG_SHA384 */ |
| #ifdef CONFIG_OWE |
| capabilities[num_items++] = "owe"; |
| #endif /* CONFIG_OWE */ |
| #ifdef CONFIG_SUITEB192 |
| capabilities[num_items++] = "suiteb192"; |
| #endif /* CONFIG_SUITEB192 */ |
| if (ext_key_id_supported) |
| capabilities[num_items++] = "extended_key_id"; |
| |
| return wpas_dbus_simple_array_property_getter(iter, |
| DBUS_TYPE_STRING, |
| capabilities, |
| num_items, error); |
| } |
| |
| |
| static int wpas_dbus_get_scan_type(DBusMessage *message, DBusMessageIter *var, |
| char **type, DBusMessage **reply) |
| { |
| if (dbus_message_iter_get_arg_type(var) != DBUS_TYPE_STRING) { |
| wpa_printf(MSG_DEBUG, "%s[dbus]: Type must be a string", |
| __func__); |
| *reply = wpas_dbus_error_invalid_args( |
| message, "Wrong Type value type. String required"); |
| return -1; |
| } |
| dbus_message_iter_get_basic(var, type); |
| return 0; |
| } |
| |
| |
| static int wpas_dbus_get_scan_ssids(DBusMessage *message, DBusMessageIter *var, |
| struct wpa_driver_scan_params *params, |
| DBusMessage **reply) |
| { |
| struct wpa_driver_scan_ssid *ssids = params->ssids; |
| size_t ssids_num = 0; |
| u8 *ssid; |
| DBusMessageIter array_iter, sub_array_iter; |
| char *val; |
| int len; |
| |
| if (dbus_message_iter_get_arg_type(var) != DBUS_TYPE_ARRAY) { |
| wpa_printf(MSG_DEBUG, |
| "%s[dbus]: ssids must be an array of arrays of bytes", |
| __func__); |
| *reply = wpas_dbus_error_invalid_args( |
| message, |
| "Wrong SSIDs value type. Array of arrays of bytes required"); |
| return -1; |
| } |
| |
| dbus_message_iter_recurse(var, &array_iter); |
| |
| if (dbus_message_iter_get_arg_type(&array_iter) != DBUS_TYPE_ARRAY || |
| dbus_message_iter_get_element_type(&array_iter) != DBUS_TYPE_BYTE) { |
| wpa_printf(MSG_DEBUG, |
| "%s[dbus]: ssids must be an array of arrays of bytes", |
| __func__); |
| *reply = wpas_dbus_error_invalid_args( |
| message, |
| "Wrong SSIDs value type. Array of arrays of bytes required"); |
| return -1; |
| } |
| |
| while (dbus_message_iter_get_arg_type(&array_iter) == DBUS_TYPE_ARRAY) { |
| if (ssids_num >= WPAS_MAX_SCAN_SSIDS) { |
| wpa_printf(MSG_DEBUG, |
| "%s[dbus]: Too many ssids specified on scan dbus call", |
| __func__); |
| *reply = wpas_dbus_error_invalid_args( |
| message, |
| "Too many ssids specified. Specify at most four"); |
| return -1; |
| } |
| |
| dbus_message_iter_recurse(&array_iter, &sub_array_iter); |
| |
| dbus_message_iter_get_fixed_array(&sub_array_iter, &val, &len); |
| |
| if (len > SSID_MAX_LEN) { |
| wpa_printf(MSG_DEBUG, |
| "%s[dbus]: SSID too long (len=%d max_len=%d)", |
| __func__, len, SSID_MAX_LEN); |
| *reply = wpas_dbus_error_invalid_args( |
| message, "Invalid SSID: too long"); |
| return -1; |
| } |
| |
| if (len != 0) { |
| ssid = os_memdup(val, len); |
| if (ssid == NULL) { |
| *reply = wpas_dbus_error_no_memory(message); |
| return -1; |
| } |
| } else { |
| /* Allow zero-length SSIDs */ |
| ssid = NULL; |
| } |
| |
| ssids[ssids_num].ssid = ssid; |
| ssids[ssids_num].ssid_len = len; |
| |
| dbus_message_iter_next(&array_iter); |
| ssids_num++; |
| } |
| |
| params->num_ssids = ssids_num; |
| return 0; |
| } |
| |
| |
| static int wpas_dbus_get_scan_ies(DBusMessage *message, DBusMessageIter *var, |
| struct wpa_driver_scan_params *params, |
| DBusMessage **reply) |
| { |
| u8 *ies = NULL, *nies; |
| size_t ies_len = 0; |
| DBusMessageIter array_iter, sub_array_iter; |
| char *val; |
| int len; |
| |
| if (dbus_message_iter_get_arg_type(var) != DBUS_TYPE_ARRAY) { |
| wpa_printf(MSG_DEBUG, |
| "%s[dbus]: ies must be an array of arrays of bytes", |
| __func__); |
| *reply = wpas_dbus_error_invalid_args( |
| message, |
| "Wrong IEs value type. Array of arrays of bytes required"); |
| return -1; |
| } |
| |
| dbus_message_iter_recurse(var, &array_iter); |
| |
| if (dbus_message_iter_get_arg_type(&array_iter) != DBUS_TYPE_ARRAY || |
| dbus_message_iter_get_element_type(&array_iter) != DBUS_TYPE_BYTE) { |
| wpa_printf(MSG_DEBUG, |
| "%s[dbus]: ies must be an array of arrays of bytes", |
| __func__); |
| *reply = wpas_dbus_error_invalid_args( |
| message, "Wrong IEs value type. Array required"); |
| return -1; |
| } |
| |
| while (dbus_message_iter_get_arg_type(&array_iter) == DBUS_TYPE_ARRAY) { |
| dbus_message_iter_recurse(&array_iter, &sub_array_iter); |
| |
| dbus_message_iter_get_fixed_array(&sub_array_iter, &val, &len); |
| if (len <= 0) { |
| dbus_message_iter_next(&array_iter); |
| continue; |
| } |
| |
| nies = os_realloc(ies, ies_len + len); |
| if (nies == NULL) { |
| os_free(ies); |
| *reply = wpas_dbus_error_no_memory(message); |
| return -1; |
| } |
| ies = nies; |
| os_memcpy(ies + ies_len, val, len); |
| ies_len += len; |
| |
| dbus_message_iter_next(&array_iter); |
| } |
| |
| params->extra_ies = ies; |
| params->extra_ies_len = ies_len; |
| return 0; |
| } |
| |
| |
| static int wpas_dbus_get_scan_channels(DBusMessage *message, |
| DBusMessageIter *var, |
| struct wpa_driver_scan_params *params, |
| DBusMessage **reply) |
| { |
| DBusMessageIter array_iter, sub_array_iter; |
| int *freqs = NULL, *nfreqs; |
| size_t freqs_num = 0; |
| |
| if (dbus_message_iter_get_arg_type(var) != DBUS_TYPE_ARRAY) { |
| wpa_printf(MSG_DEBUG, |
| "%s[dbus]: Channels must be an array of structs", |
| __func__); |
| *reply = wpas_dbus_error_invalid_args( |
| message, |
| "Wrong Channels value type. Array of structs required"); |
| return -1; |
| } |
| |
| dbus_message_iter_recurse(var, &array_iter); |
| |
| if (dbus_message_iter_get_arg_type(&array_iter) != DBUS_TYPE_STRUCT) { |
| wpa_printf(MSG_DEBUG, |
| "%s[dbus]: Channels must be an array of structs", |
| __func__); |
| *reply = wpas_dbus_error_invalid_args( |
| message, |
| "Wrong Channels value type. Array of structs required"); |
| return -1; |
| } |
| |
| while (dbus_message_iter_get_arg_type(&array_iter) == DBUS_TYPE_STRUCT) |
| { |
| int freq, width; |
| |
| dbus_message_iter_recurse(&array_iter, &sub_array_iter); |
| |
| if (dbus_message_iter_get_arg_type(&sub_array_iter) != |
| DBUS_TYPE_UINT32) { |
| wpa_printf(MSG_DEBUG, |
| "%s[dbus]: Channel must by specified by struct of two UINT32s %c", |
| __func__, |
| dbus_message_iter_get_arg_type( |
| &sub_array_iter)); |
| *reply = wpas_dbus_error_invalid_args( |
| message, |
| "Wrong Channel struct. Two UINT32s required"); |
| os_free(freqs); |
| return -1; |
| } |
| dbus_message_iter_get_basic(&sub_array_iter, &freq); |
| |
| if (!dbus_message_iter_next(&sub_array_iter) || |
| dbus_message_iter_get_arg_type(&sub_array_iter) != |
| DBUS_TYPE_UINT32) { |
| wpa_printf(MSG_DEBUG, |
| "%s[dbus]: Channel must by specified by struct of two UINT32s", |
| __func__); |
| *reply = wpas_dbus_error_invalid_args( |
| message, |
| "Wrong Channel struct. Two UINT32s required"); |
| os_free(freqs); |
| return -1; |
| } |
| |
| dbus_message_iter_get_basic(&sub_array_iter, &width); |
| |
| #define FREQS_ALLOC_CHUNK 32 |
| if (freqs_num % FREQS_ALLOC_CHUNK == 0) { |
| nfreqs = os_realloc_array( |
| freqs, freqs_num + FREQS_ALLOC_CHUNK, |
| sizeof(int)); |
| if (nfreqs == NULL) |
| os_free(freqs); |
| freqs = nfreqs; |
| } |
| if (freqs == NULL) { |
| *reply = wpas_dbus_error_no_memory(message); |
| return -1; |
| } |
| |
| freqs[freqs_num] = freq; |
| |
| freqs_num++; |
| dbus_message_iter_next(&array_iter); |
| } |
| |
| nfreqs = os_realloc_array(freqs, freqs_num + 1, sizeof(int)); |
| if (nfreqs == NULL) |
| os_free(freqs); |
| freqs = nfreqs; |
| if (freqs == NULL) { |
| *reply = wpas_dbus_error_no_memory(message); |
| return -1; |
| } |
| freqs[freqs_num] = 0; |
| |
| params->freqs = freqs; |
| return 0; |
| } |
| |
| |
| static int wpas_dbus_get_scan_allow_roam(DBusMessage *message, |
| DBusMessageIter *var, |
| dbus_bool_t *allow, |
| DBusMessage **reply) |
| { |
| if (dbus_message_iter_get_arg_type(var) != DBUS_TYPE_BOOLEAN) { |
| wpa_printf(MSG_DEBUG, "%s[dbus]: Type must be a boolean", |
| __func__); |
| *reply = wpas_dbus_error_invalid_args( |
| message, "Wrong Type value type. Boolean required"); |
| return -1; |
| } |
| dbus_message_iter_get_basic(var, allow); |
| return 0; |
| } |
| |
| |
| /** |
| * wpas_dbus_handler_scan - Request a wireless scan on an interface |
| * @message: Pointer to incoming dbus message |
| * @wpa_s: wpa_supplicant structure for a network interface |
| * Returns: NULL indicating success or DBus error message on failure |
| * |
| * Handler function for "Scan" method call of a network device. Requests |
| * that wpa_supplicant perform a wireless scan as soon as possible |
| * on a particular wireless interface. |
| */ |
| DBusMessage * wpas_dbus_handler_scan(DBusMessage *message, |
| struct wpa_supplicant *wpa_s) |
| { |
| DBusMessage *reply = NULL; |
| DBusMessageIter iter, dict_iter, entry_iter, variant_iter; |
| char *key = NULL, *type = NULL; |
| struct wpa_driver_scan_params params; |
| size_t i; |
| dbus_bool_t allow_roam = 1; |
| |
| os_memset(¶ms, 0, sizeof(params)); |
| |
| dbus_message_iter_init(message, &iter); |
| |
| dbus_message_iter_recurse(&iter, &dict_iter); |
| |
| while (dbus_message_iter_get_arg_type(&dict_iter) == |
| DBUS_TYPE_DICT_ENTRY) { |
| dbus_message_iter_recurse(&dict_iter, &entry_iter); |
| dbus_message_iter_get_basic(&entry_iter, &key); |
| dbus_message_iter_next(&entry_iter); |
| dbus_message_iter_recurse(&entry_iter, &variant_iter); |
| |
| if (os_strcmp(key, "Type") == 0) { |
| if (wpas_dbus_get_scan_type(message, &variant_iter, |
| &type, &reply) < 0) |
| goto out; |
| } else if (os_strcmp(key, "SSIDs") == 0) { |
| if (wpas_dbus_get_scan_ssids(message, &variant_iter, |
| ¶ms, &reply) < 0) |
| goto out; |
| } else if (os_strcmp(key, "IEs") == 0) { |
| if (wpas_dbus_get_scan_ies(message, &variant_iter, |
| ¶ms, &reply) < 0) |
| goto out; |
| } else if (os_strcmp(key, "Channels") == 0) { |
| if (wpas_dbus_get_scan_channels(message, &variant_iter, |
| ¶ms, &reply) < 0) |
| goto out; |
| } else if (os_strcmp(key, "AllowRoam") == 0) { |
| if (wpas_dbus_get_scan_allow_roam(message, |
| &variant_iter, |
| &allow_roam, |
| &reply) < 0) |
| goto out; |
| } else { |
| wpa_printf(MSG_DEBUG, "%s[dbus]: Unknown argument %s", |
| __func__, key); |
| reply = wpas_dbus_error_invalid_args(message, key); |
| goto out; |
| } |
| |
| dbus_message_iter_next(&dict_iter); |
| } |
| |
| if (!type) { |
| wpa_printf(MSG_DEBUG, "%s[dbus]: Scan type not specified", |
| __func__); |
| reply = wpas_dbus_error_invalid_args(message, key); |
| goto out; |
| } |
| |
| if (os_strcmp(type, "passive") == 0) { |
| if (params.num_ssids || params.extra_ies_len) { |
| wpa_printf(MSG_DEBUG, |
| "%s[dbus]: SSIDs or IEs specified for passive scan.", |
| __func__); |
| reply = wpas_dbus_error_invalid_args( |
| message, |
| "You can specify only Channels in passive scan"); |
| goto out; |
| } else { |
| if (wpa_s->sched_scanning) { |
| wpa_printf(MSG_DEBUG, |
| "%s[dbus]: Stop ongoing sched_scan to allow requested scan to proceed", |
| __func__); |
| wpa_supplicant_cancel_sched_scan(wpa_s); |
| } |
| |
| if (params.freqs && params.freqs[0]) { |
| wpa_s->last_scan_req = MANUAL_SCAN_REQ; |
| if (wpa_supplicant_trigger_scan(wpa_s, |
| ¶ms)) { |
| reply = wpas_dbus_error_scan_error( |
| message, |
| "Scan request rejected"); |
| } |
| } else { |
| wpa_s->scan_req = MANUAL_SCAN_REQ; |
| wpa_supplicant_req_scan(wpa_s, 0, 0); |
| } |
| } |
| } else if (os_strcmp(type, "active") == 0) { |
| if (!params.num_ssids) { |
| /* Add wildcard ssid */ |
| params.num_ssids++; |
| } |
| #ifdef CONFIG_AUTOSCAN |
| autoscan_deinit(wpa_s); |
| #endif /* CONFIG_AUTOSCAN */ |
| if (wpa_s->sched_scanning) { |
| wpa_printf(MSG_DEBUG, |
| "%s[dbus]: Stop ongoing sched_scan to allow requested scan to proceed", |
| __func__); |
| wpa_supplicant_cancel_sched_scan(wpa_s); |
| } |
| |
| wpa_s->last_scan_req = MANUAL_SCAN_REQ; |
| if (wpa_supplicant_trigger_scan(wpa_s, ¶ms)) { |
| reply = wpas_dbus_error_scan_error( |
| message, "Scan request rejected"); |
| } |
| } else { |
| wpa_printf(MSG_DEBUG, "%s[dbus]: Unknown scan type: %s", |
| __func__, type); |
| reply = wpas_dbus_error_invalid_args(message, |
| "Wrong scan type"); |
| goto out; |
| } |
| |
| if (!allow_roam) |
| wpa_s->scan_res_handler = scan_only_handler; |
| |
| out: |
| for (i = 0; i < WPAS_MAX_SCAN_SSIDS; i++) |
| os_free((u8 *) params.ssids[i].ssid); |
| os_free((u8 *) params.extra_ies); |
| os_free(params.freqs); |
| return reply; |
| } |
| |
| |
| /* |
| * wpas_dbus_handler_abort_scan - Request an ongoing scan to be aborted |
| * @message: Pointer to incoming dbus message |
| * @wpa_s: wpa_supplicant structure for a network interface |
| * Returns: Abort failed or no scan in progress DBus error message on failure |
| * or NULL otherwise. |
| * |
| * Handler function for "AbortScan" method call of network interface. |
| */ |
| DBusMessage * wpas_dbus_handler_abort_scan(DBusMessage *message, |
| struct wpa_supplicant *wpa_s) |
| { |
| if (wpas_abort_ongoing_scan(wpa_s) < 0) |
| return dbus_message_new_error( |
| message, WPAS_DBUS_ERROR_IFACE_SCAN_ERROR, |
| "Abort failed or no scan in progress"); |
| |
| return NULL; |
| } |
| |
| |
| /** |
| * wpas_dbus_handler_signal_poll - Request immediate signal properties |
| * @message: Pointer to incoming dbus message |
| * @wpa_s: wpa_supplicant structure for a network interface |
| * Returns: NULL indicating success or DBus error message on failure |
| * |
| * Handler function for "SignalPoll" method call of a network device. Requests |
| * that wpa_supplicant read signal properties like RSSI, noise, and link |
| * speed and return them. |
| */ |
| DBusMessage * wpas_dbus_handler_signal_poll(DBusMessage *message, |
| struct wpa_supplicant *wpa_s) |
| { |
| struct wpa_signal_info si; |
| DBusMessage *reply = NULL; |
| DBusMessageIter iter, iter_dict, variant_iter; |
| int ret; |
| |
| ret = wpa_drv_signal_poll(wpa_s, &si); |
| if (ret) { |
| return dbus_message_new_error(message, DBUS_ERROR_FAILED, |
| "Failed to read signal"); |
| } |
| |
| reply = dbus_message_new_method_return(message); |
| if (reply == NULL) |
| goto nomem; |
| |
| dbus_message_iter_init_append(reply, &iter); |
| |
| if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT, |
| "a{sv}", &variant_iter) || |
| !wpa_dbus_dict_open_write(&variant_iter, &iter_dict) || |
| !wpa_dbus_dict_append_int32(&iter_dict, "rssi", |
| si.current_signal) || |
| !wpa_dbus_dict_append_int32(&iter_dict, "linkspeed", |
| si.current_txrate / 1000) || |
| !wpa_dbus_dict_append_int32(&iter_dict, "noise", |
| si.current_noise) || |
| !wpa_dbus_dict_append_uint32(&iter_dict, "frequency", |
| si.frequency) || |
| (si.chanwidth != CHAN_WIDTH_UNKNOWN && |
| !wpa_dbus_dict_append_string( |
| &iter_dict, "width", |
| channel_width_to_string(si.chanwidth))) || |
| (si.center_frq1 > 0 && si.center_frq2 > 0 && |
| (!wpa_dbus_dict_append_int32(&iter_dict, "center-frq1", |
| si.center_frq1) || |
| !wpa_dbus_dict_append_int32(&iter_dict, "center-frq2", |
| si.center_frq2))) || |
| (si.avg_signal && |
| !wpa_dbus_dict_append_int32(&iter_dict, "avg-rssi", |
| si.avg_signal)) || |
| !wpa_dbus_dict_close_write(&variant_iter, &iter_dict) || |
| !dbus_message_iter_close_container(&iter, &variant_iter)) |
| goto nomem; |
| |
| return reply; |
| |
| nomem: |
| if (reply) |
| dbus_message_unref(reply); |
| return wpas_dbus_error_no_memory(message); |
| } |
| |
| |
| /* |
| * wpas_dbus_handler_disconnect - Terminate the current connection |
| * @message: Pointer to incoming dbus message |
| * @wpa_s: wpa_supplicant structure for a network interface |
| * Returns: NotConnected DBus error message if already not connected |
| * or NULL otherwise. |
| * |
| * Handler function for "Disconnect" method call of network interface. |
| */ |
| DBusMessage * wpas_dbus_handler_disconnect(DBusMessage *message, |
| struct wpa_supplicant *wpa_s) |
| { |
| if (wpa_s->current_ssid != NULL) { |
| wpas_request_disconnection(wpa_s); |
| return NULL; |
| } |
| |
| return dbus_message_new_error(message, WPAS_DBUS_ERROR_NOT_CONNECTED, |
| "This interface is not connected"); |
| } |
| |
| |
| /** |
| * wpas_dbus_new_iface_add_network - Add a new configured network |
| * @message: Pointer to incoming dbus message |
| * @wpa_s: wpa_supplicant structure for a network interface |
| * Returns: A dbus message containing the object path of the new network |
| * |
| * Handler function for "AddNetwork" method call of a network interface. |
| */ |
| DBusMessage * wpas_dbus_handler_add_network(DBusMessage *message, |
| struct wpa_supplicant *wpa_s) |
| { |
| DBusMessage *reply = NULL; |
| DBusMessageIter iter; |
| struct wpa_ssid *ssid = NULL; |
| char path_buf[WPAS_DBUS_OBJECT_PATH_MAX], *path = path_buf; |
| DBusError error; |
| |
| dbus_message_iter_init(message, &iter); |
| |
| if (wpa_s->dbus_new_path) |
| ssid = wpa_supplicant_add_network(wpa_s); |
| if (ssid == NULL) { |
| wpa_printf(MSG_ERROR, "%s[dbus]: can't add new interface.", |
| __func__); |
| reply = wpas_dbus_error_unknown_error( |
| message, |
| "wpa_supplicant could not add a network on this interface."); |
| goto err; |
| } |
| |
| dbus_error_init(&error); |
| if (!set_network_properties(wpa_s, ssid, &iter, &error)) { |
| wpa_printf(MSG_DEBUG, |
| "%s[dbus]: control interface couldn't set network properties", |
| __func__); |
| reply = wpas_dbus_reply_new_from_error(message, &error, |
| DBUS_ERROR_INVALID_ARGS, |
| "Failed to add network"); |
| dbus_error_free(&error); |
| goto err; |
| } |
| |
| /* Construct the object path for this network. */ |
| os_snprintf(path, WPAS_DBUS_OBJECT_PATH_MAX, |
| "%s/" WPAS_DBUS_NEW_NETWORKS_PART "/%d", |
| wpa_s->dbus_new_path, ssid->id); |
| |
| reply = dbus_message_new_method_return(message); |
| if (reply == NULL) { |
| reply = wpas_dbus_error_no_memory(message); |
| goto err; |
| } |
| if (!dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH, &path, |
| DBUS_TYPE_INVALID)) { |
| dbus_message_unref(reply); |
| reply = wpas_dbus_error_no_memory(message); |
| goto err; |
| } |
| |
| return reply; |
| |
| err: |
| if (ssid) { |
| wpas_notify_network_removed(wpa_s, ssid); |
| wpa_config_remove_network(wpa_s->conf, ssid->id); |
| } |
| return reply; |
| } |
| |
| |
| /** |
| * wpas_dbus_handler_reassociate - Reassociate |
| * @message: Pointer to incoming dbus message |
| * @wpa_s: wpa_supplicant structure for a network interface |
| * Returns: InterfaceDisabled DBus error message if disabled |
| * or NULL otherwise. |
| * |
| * Handler function for "Reassociate" method call of network interface. |
| */ |
| DBusMessage * wpas_dbus_handler_reassociate(DBusMessage *message, |
| struct wpa_supplicant *wpa_s) |
| { |
| if (wpa_s->wpa_state != WPA_INTERFACE_DISABLED) { |
| wpas_request_connection(wpa_s); |
| return NULL; |
| } |
| |
| return dbus_message_new_error(message, WPAS_DBUS_ERROR_IFACE_DISABLED, |
| "This interface is disabled"); |
| } |
| |
| |
| /** |
| * wpas_dbus_handler_expect_disconnect - ExpectDisconnect |
| * @message: Pointer to incoming dbus message |
| * @global: %wpa_supplicant global data structure |
| * Returns: NULL |
| * |
| * Handler function for notifying system there will be a expected disconnect. |
| * This will prevent wpa_supplicant from adding the BSSID to the ignore list |
| * upon next disconnect. |
| */ |
| DBusMessage * wpas_dbus_handler_expect_disconnect(DBusMessage *message, |
| struct wpa_global *global) |
| { |
| struct wpa_supplicant *wpa_s = global->ifaces; |
| |
| for (; wpa_s; wpa_s = wpa_s->next) |
| if (wpa_s->wpa_state >= WPA_ASSOCIATED) |
| wpa_s->own_disconnect_req = 1; |
| return NULL; |
| } |
| |
| |
| /** |
| * wpas_dbus_handler_reattach - Reattach to current AP |
| * @message: Pointer to incoming dbus message |
| * @wpa_s: wpa_supplicant structure for a network interface |
| * Returns: NotConnected DBus error message if not connected |
| * or NULL otherwise. |
| * |
| * Handler function for "Reattach" method call of network interface. |
| */ |
| DBusMessage * wpas_dbus_handler_reattach(DBusMessage *message, |
| struct wpa_supplicant *wpa_s) |
| { |
| if (wpa_s->current_ssid != NULL) { |
| wpa_s->reattach = 1; |
| wpas_request_connection(wpa_s); |
| return NULL; |
| } |
| |
| return dbus_message_new_error(message, WPAS_DBUS_ERROR_NOT_CONNECTED, |
| "This interface is not connected"); |
| } |
| |
| |
| /** |
| * wpas_dbus_handler_reconnect - Reconnect if disconnected |
| * @message: Pointer to incoming dbus message |
| * @wpa_s: wpa_supplicant structure for a network interface |
| * Returns: InterfaceDisabled DBus error message if disabled |
| * or NULL otherwise. |
| * |
| * Handler function for "Reconnect" method call of network interface. |
| */ |
| DBusMessage * wpas_dbus_handler_reconnect(DBusMessage *message, |
| struct wpa_supplicant *wpa_s) |
| { |
| if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED) { |
| return dbus_message_new_error(message, |
| WPAS_DBUS_ERROR_IFACE_DISABLED, |
| "This interface is disabled"); |
| } |
| |
| if (wpa_s->disconnected) |
| wpas_request_connection(wpa_s); |
| return NULL; |
| } |
| |
| |
| /** |
| * wpas_dbus_handler_remove_network - Remove a configured network |
| * @message: Pointer to incoming dbus message |
| * @wpa_s: wpa_supplicant structure for a network interface |
| * Returns: NULL on success or dbus error on failure |
| * |
| * Handler function for "RemoveNetwork" method call of a network interface. |
| */ |
| DBusMessage * wpas_dbus_handler_remove_network(DBusMessage *message, |
| struct wpa_supplicant *wpa_s) |
| { |
| DBusMessage *reply = NULL; |
| const char *op; |
| char *iface, *net_id; |
| int id; |
| int result; |
| |
| dbus_message_get_args(message, NULL, DBUS_TYPE_OBJECT_PATH, &op, |
| DBUS_TYPE_INVALID); |
| |
| /* Extract the network ID and ensure the network */ |
| /* is actually a child of this interface */ |
| iface = wpas_dbus_new_decompose_object_path(op, |
| WPAS_DBUS_NEW_NETWORKS_PART, |
| &net_id); |
| if (iface == NULL || net_id == NULL || !wpa_s->dbus_new_path || |
| os_strcmp(iface, wpa_s->dbus_new_path) != 0) { |
| reply = wpas_dbus_error_invalid_args(message, op); |
| goto out; |
| } |
| |
| errno = 0; |
| id = strtoul(net_id, NULL, 10); |
| if (errno != 0) { |
| reply = wpas_dbus_error_invalid_args(message, op); |
| goto out; |
| } |
| |
| result = wpa_supplicant_remove_network(wpa_s, id); |
| if (result == -1) { |
| reply = wpas_dbus_error_network_unknown(message); |
| goto out; |
| } |
| if (result == -2) { |
| wpa_printf(MSG_ERROR, |
| "%s[dbus]: error occurred when removing network %d", |
| __func__, id); |
| reply = wpas_dbus_error_unknown_error( |
| message, |
| "error removing the specified network on is interface."); |
| goto out; |
| } |
| |
| out: |
| os_free(iface); |
| return reply; |
| } |
| |
| |
| /** |
| * wpas_dbus_handler_remove_all_networks - Remove all configured networks |
| * @message: Pointer to incoming dbus message |
| * @wpa_s: wpa_supplicant structure for a network interface |
| * Returns: NULL on success or dbus error on failure |
| * |
| * Handler function for "RemoveAllNetworks" method call of a network interface. |
| */ |
| DBusMessage * wpas_dbus_handler_remove_all_networks( |
| DBusMessage *message, struct wpa_supplicant *wpa_s) |
| { |
| /* NB: could check for failure and return an error */ |
| wpa_supplicant_remove_all_networks(wpa_s); |
| return NULL; |
| } |
| |
| |
| /** |
| * wpas_dbus_handler_select_network - Attempt association with a network |
| * @message: Pointer to incoming dbus message |
| * @wpa_s: wpa_supplicant structure for a network interface |
| * Returns: NULL on success or dbus error on failure |
| * |
| * Handler function for "SelectNetwork" method call of network interface. |
| */ |
| DBusMessage * wpas_dbus_handler_select_network(DBusMessage *message, |
| struct wpa_supplicant *wpa_s) |
| { |
| DBusMessage *reply = NULL; |
| const char *op; |
| char *iface, *net_id; |
| int id; |
| struct wpa_ssid *ssid; |
| |
| dbus_message_get_args(message, NULL, DBUS_TYPE_OBJECT_PATH, &op, |
| DBUS_TYPE_INVALID); |
| |
| /* Extract the network ID and ensure the network */ |
| /* is actually a child of this interface */ |
| iface = wpas_dbus_new_decompose_object_path(op, |
| WPAS_DBUS_NEW_NETWORKS_PART, |
| &net_id); |
| if (iface == NULL || net_id == NULL || !wpa_s->dbus_new_path || |
| os_strcmp(iface, wpa_s->dbus_new_path) != 0) { |
| reply = wpas_dbus_error_invalid_args(message, op); |
| goto out; |
| } |
| |
| errno = 0; |
| id = strtoul(net_id, NULL, 10); |
| if (errno != 0) { |
| reply = wpas_dbus_error_invalid_args(message, op); |
| goto out; |
| } |
| |
| ssid = wpa_config_get_network(wpa_s->conf, id); |
| if (ssid == NULL) { |
| reply = wpas_dbus_error_network_unknown(message); |
| goto out; |
| } |
| |
| /* Finally, associate with the network */ |
| wpa_supplicant_select_network(wpa_s, ssid); |
| |
| out: |
| os_free(iface); |
| return reply; |
| } |
| |
| |
| /** |
| * wpas_dbus_handler_network_reply - Reply to a NetworkRequest signal |
| * @message: Pointer to incoming dbus message |
| * @wpa_s: wpa_supplicant structure for a network interface |
| * Returns: NULL on success or dbus error on failure |
| * |
| * Handler function for "NetworkReply" method call of network interface. |
| */ |
| DBusMessage * wpas_dbus_handler_network_reply(DBusMessage *message, |
| struct wpa_supplicant *wpa_s) |
| { |
| #ifdef IEEE8021X_EAPOL |
| DBusMessage *reply = NULL; |
| const char *op, *field, *value; |
| char *iface, *net_id; |
| int id; |
| struct wpa_ssid *ssid; |
| |
| if (!dbus_message_get_args(message, NULL, |
| DBUS_TYPE_OBJECT_PATH, &op, |
| DBUS_TYPE_STRING, &field, |
| DBUS_TYPE_STRING, &value, |
| DBUS_TYPE_INVALID)) |
| return wpas_dbus_error_invalid_args(message, NULL); |
| |
| /* Extract the network ID and ensure the network */ |
| /* is actually a child of this interface */ |
| iface = wpas_dbus_new_decompose_object_path(op, |
| WPAS_DBUS_NEW_NETWORKS_PART, |
| &net_id); |
| if (iface == NULL || net_id == NULL || !wpa_s->dbus_new_path || |
| os_strcmp(iface, wpa_s->dbus_new_path) != 0) { |
| reply = wpas_dbus_error_invalid_args(message, op); |
| goto out; |
| } |
| |
| errno = 0; |
| id = strtoul(net_id, NULL, 10); |
| if (errno != 0) { |
| reply = wpas_dbus_error_invalid_args(message, net_id); |
| goto out; |
| } |
| |
| ssid = wpa_config_get_network(wpa_s->conf, id); |
| if (ssid == NULL) { |
| reply = wpas_dbus_error_network_unknown(message); |
| goto out; |
| } |
| |
| if (wpa_supplicant_ctrl_iface_ctrl_rsp_handle(wpa_s, ssid, |
| field, value) < 0) |
| reply = wpas_dbus_error_invalid_args(message, field); |
| else { |
| /* Tell EAP to retry immediately */ |
| eapol_sm_notify_ctrl_response(wpa_s->eapol); |
| } |
| |
| out: |
| os_free(iface); |
| return reply; |
| #else /* IEEE8021X_EAPOL */ |
| wpa_printf(MSG_DEBUG, "dbus: 802.1X not included"); |
| return wpas_dbus_error_unknown_error(message, "802.1X not included"); |
| #endif /* IEEE8021X_EAPOL */ |
| } |
| |
| |
| /** |
| * wpas_dbus_handler_roam - Initiate a roam to another BSS within the ESS |
| * @message: Pointer to incoming dbus message |
| * @wpa_s: wpa_supplicant structure for a network interface |
| * Returns: NULL on success or dbus error on failure |
| * |
| * Handler function for "Roam" method call of network interface. |
| */ |
| DBusMessage * wpas_dbus_handler_roam(DBusMessage *message, |
| struct wpa_supplicant *wpa_s) |
| { |
| #ifdef CONFIG_NO_SCAN_PROCESSING |
| return wpas_dbus_error_unknown_error(message, |
| "scan processing not included"); |
| #else /* CONFIG_NO_SCAN_PROCESSING */ |
| u8 bssid[ETH_ALEN]; |
| struct wpa_bss *bss; |
| struct wpa_ssid *ssid = wpa_s->current_ssid; |
| char *addr; |
| |
| if (!dbus_message_get_args(message, NULL, DBUS_TYPE_STRING, &addr, |
| DBUS_TYPE_INVALID)) |
| return wpas_dbus_error_invalid_args(message, NULL); |
| |
| if (hwaddr_aton(addr, bssid)) |
| return wpas_dbus_error_invalid_args( |
| message, "Invalid hardware address format"); |
| |
| wpa_printf(MSG_DEBUG, "dbus: Roam " MACSTR, MAC2STR(bssid)); |
| |
| if (!ssid) |
| return dbus_message_new_error( |
| message, WPAS_DBUS_ERROR_NOT_CONNECTED, |
| "This interface is not connected"); |
| |
| bss = wpa_bss_get(wpa_s, bssid, ssid->ssid, ssid->ssid_len); |
| if (!bss) { |
| wpa_printf(MSG_DEBUG, "dbus: Roam: Target BSS not found"); |
| return wpas_dbus_error_invalid_args( |
| message, "Target BSS not found"); |
| } |
| |
| wpa_s->reassociate = 1; |
| wpa_supplicant_connect(wpa_s, bss, ssid); |
| |
| return NULL; |
| #endif /* CONFIG_NO_SCAN_PROCESSING */ |
| } |
| |
| #ifndef CONFIG_NO_CONFIG_BLOBS |
| |
| /** |
| * wpas_dbus_handler_add_blob - Store named binary blob (ie, for certificates) |
| * @message: Pointer to incoming dbus message |
| * @wpa_s: %wpa_supplicant data structure |
| * Returns: A dbus message containing an error on failure or NULL on success |
| * |
| * Asks wpa_supplicant to internally store a binary blobs. |
| */ |
| DBusMessage * wpas_dbus_handler_add_blob(DBusMessage *message, |
| struct wpa_supplicant *wpa_s) |
| { |
| DBusMessage *reply = NULL; |
| DBusMessageIter iter, array_iter; |
| |
| char *blob_name; |
| u8 *blob_data; |
| int blob_len; |
| struct wpa_config_blob *blob = NULL; |
| |
| dbus_message_iter_init(message, &iter); |
| dbus_message_iter_get_basic(&iter, &blob_name); |
| |
| if (wpa_config_get_blob(wpa_s->conf, blob_name)) { |
| return dbus_message_new_error(message, |
| WPAS_DBUS_ERROR_BLOB_EXISTS, |
| NULL); |
| } |
| |
| dbus_message_iter_next(&iter); |
| dbus_message_iter_recurse(&iter, &array_iter); |
| |
| dbus_message_iter_get_fixed_array(&array_iter, &blob_data, &blob_len); |
| |
| blob = os_zalloc(sizeof(*blob)); |
| if (!blob) { |
| reply = wpas_dbus_error_no_memory(message); |
| goto err; |
| } |
| |
| blob->data = os_memdup(blob_data, blob_len); |
| blob->name = os_strdup(blob_name); |
| if (!blob->data || !blob->name) { |
| reply = wpas_dbus_error_no_memory(message); |
| goto err; |
| } |
| blob->len = blob_len; |
| |
| wpa_config_set_blob(wpa_s->conf, blob); |
| wpas_notify_blob_added(wpa_s, blob->name); |
| |
| return reply; |
| |
| err: |
| if (blob) { |
| os_free(blob->name); |
| os_free(blob->data); |
| os_free(blob); |
| } |
| return reply; |
| } |
| |
| |
| /** |
| * wpas_dbus_handler_get_blob - Get named binary blob (ie, for certificates) |
| * @message: Pointer to incoming dbus message |
| * @wpa_s: %wpa_supplicant data structure |
| * Returns: A dbus message containing array of bytes (blob) |
| * |
| * Gets one wpa_supplicant's binary blobs. |
| */ |
| DBusMessage * wpas_dbus_handler_get_blob(DBusMessage *message, |
| struct wpa_supplicant *wpa_s) |
| { |
| DBusMessage *reply = NULL; |
| DBusMessageIter iter, array_iter; |
| |
| char *blob_name; |
| const struct wpa_config_blob *blob; |
| |
| dbus_message_get_args(message, NULL, DBUS_TYPE_STRING, &blob_name, |
| DBUS_TYPE_INVALID); |
| |
| blob = wpa_config_get_blob(wpa_s->conf, blob_name); |
| if (!blob) { |
| return dbus_message_new_error(message, |
| WPAS_DBUS_ERROR_BLOB_UNKNOWN, |
| "Blob id not set"); |
| } |
| |
| reply = dbus_message_new_method_return(message); |
| if (!reply) |
| return wpas_dbus_error_no_memory(message); |
| |
| dbus_message_iter_init_append(reply, &iter); |
| |
| if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, |
| DBUS_TYPE_BYTE_AS_STRING, |
| &array_iter) || |
| !dbus_message_iter_append_fixed_array(&array_iter, DBUS_TYPE_BYTE, |
| &(blob->data), blob->len) || |
| !dbus_message_iter_close_container(&iter, &array_iter)) { |
| dbus_message_unref(reply); |
| reply = wpas_dbus_error_no_memory(message); |
| } |
| |
| return reply; |
| } |
| |
| |
| /** |
| * wpas_remove_handler_remove_blob - Remove named binary blob |
| * @message: Pointer to incoming dbus message |
| * @wpa_s: %wpa_supplicant data structure |
| * Returns: NULL on success or dbus error |
| * |
| * Asks wpa_supplicant to internally remove a binary blobs. |
| */ |
| DBusMessage * wpas_dbus_handler_remove_blob(DBusMessage *message, |
| struct wpa_supplicant *wpa_s) |
| { |
| DBusMessage *reply = NULL; |
| char *blob_name; |
| |
| dbus_message_get_args(message, NULL, DBUS_TYPE_STRING, &blob_name, |
| DBUS_TYPE_INVALID); |
| |
| if (wpa_config_remove_blob(wpa_s->conf, blob_name)) { |
| return dbus_message_new_error(message, |
| WPAS_DBUS_ERROR_BLOB_UNKNOWN, |
| "Blob id not set"); |
| } |
| wpas_notify_blob_removed(wpa_s, blob_name); |
| |
| return reply; |
| |
| } |
| |
| #endif /* CONFIG_NO_CONFIG_BLOBS */ |
| |
| |
| /* |
| * wpas_dbus_handler_flush_bss - Flush the BSS cache |
| * @message: Pointer to incoming dbus message |
| * @wpa_s: wpa_supplicant structure for a network interface |
| * Returns: NULL |
| * |
| * Handler function for "FlushBSS" method call of network interface. |
| */ |
| DBusMessage * wpas_dbus_handler_flush_bss(DBusMessage *message, |
| struct wpa_supplicant *wpa_s) |
| { |
| dbus_uint32_t age; |
| |
| dbus_message_get_args(message, NULL, DBUS_TYPE_UINT32, &age, |
| DBUS_TYPE_INVALID); |
| |
| if (age == 0) |
| wpa_bss_flush(wpa_s); |
| else |
| wpa_bss_flush_by_age(wpa_s, age); |
| |
| return NULL; |
| } |
| |
| |
| #ifdef CONFIG_AUTOSCAN |
| /** |
| * wpas_dbus_handler_autoscan - Set autoscan parameters for the interface |
| * @message: Pointer to incoming dbus message |
| * @wpa_s: wpa_supplicant structure for a network interface |
| * Returns: NULL |
| * |
| * Handler function for "AutoScan" method call of network interface. |
| */ |
| DBusMessage * wpas_dbus_handler_autoscan(DBusMessage *message, |
| struct wpa_supplicant *wpa_s) |
| { |
| DBusMessage *reply = NULL; |
| enum wpa_states state = wpa_s->wpa_state; |
| char *arg; |
| |
| dbus_message_get_args(message, NULL, DBUS_TYPE_STRING, &arg, |
| DBUS_TYPE_INVALID); |
| |
| if (arg != NULL && os_strlen(arg) > 0) { |
| char *tmp; |
| |
| tmp = os_strdup(arg); |
| if (tmp == NULL) { |
| reply = wpas_dbus_error_no_memory(message); |
| } else { |
| os_free(wpa_s->conf->autoscan); |
| wpa_s->conf->autoscan = tmp; |
| if (state == WPA_DISCONNECTED || state == WPA_INACTIVE) |
| autoscan_init(wpa_s, 1); |
| else if (state == WPA_SCANNING) |
| wpa_supplicant_reinit_autoscan(wpa_s); |
| } |
| } else if (arg != NULL && os_strlen(arg) == 0) { |
| os_free(wpa_s->conf->autoscan); |
| wpa_s->conf->autoscan = NULL; |
| autoscan_deinit(wpa_s); |
| } else |
| reply = dbus_message_new_error(message, |
| DBUS_ERROR_INVALID_ARGS, |
| NULL); |
| |
| return reply; |
| } |
| #endif /* CONFIG_AUTOSCAN */ |
| |
| |
| /* |
| * wpas_dbus_handler_eap_logoff - IEEE 802.1X EAPOL state machine logoff |
| * @message: Pointer to incoming dbus message |
| * @wpa_s: wpa_supplicant structure for a network interface |
| * Returns: NULL |
| * |
| * Handler function for "EAPLogoff" method call of network interface. |
| */ |
| DBusMessage * wpas_dbus_handler_eap_logoff(DBusMessage *message, |
| struct wpa_supplicant *wpa_s) |
| { |
| eapol_sm_notify_logoff(wpa_s->eapol, TRUE); |
| return NULL; |
| } |
| |
| |
| /* |
| * wpas_dbus_handler_eap_logon - IEEE 802.1X EAPOL state machine logon |
| * @message: Pointer to incoming dbus message |
| * @wpa_s: wpa_supplicant structure for a network interface |
| * Returns: NULL |
| * |
| * Handler function for "EAPLogin" method call of network interface. |
| */ |
| DBusMessage * wpas_dbus_handler_eap_logon(DBusMessage *message, |
| struct wpa_supplicant *wpa_s) |
| { |
| eapol_sm_notify_logoff(wpa_s->eapol, FALSE); |
| return NULL; |
| } |
| |
| |
| #ifdef CONFIG_TDLS |
| |
| static int get_peer_hwaddr_helper(DBusMessage *message, const char *func_name, |
| u8 *peer_address, DBusMessage **error) |
| { |
| const char *peer_string; |
| |
| *error = NULL; |
| |
| if (!dbus_message_get_args(message, NULL, |
| DBUS_TYPE_STRING, &peer_string, |
| DBUS_TYPE_INVALID)) { |
| *error = wpas_dbus_error_invalid_args(message, NULL); |
| return -1; |
| } |
| |
| if (hwaddr_aton(peer_string, peer_address)) { |
| wpa_printf(MSG_DEBUG, "%s: invalid address '%s'", |
| func_name, peer_string); |
| *error = wpas_dbus_error_invalid_args( |
| message, "Invalid hardware address format"); |
| return -1; |
| } |
| |
| return 0; |
| } |
| |
| |
| /* |
| * wpas_dbus_handler_tdls_discover - Discover TDLS peer |
| * @message: Pointer to incoming dbus message |
| * @wpa_s: wpa_supplicant structure for a network interface |
| * Returns: NULL indicating success or DBus error message on failure |
| * |
| * Handler function for "TDLSDiscover" method call of network interface. |
| */ |
| DBusMessage * wpas_dbus_handler_tdls_discover(DBusMessage *message, |
| struct wpa_supplicant *wpa_s) |
| { |
| u8 peer[ETH_ALEN]; |
| DBusMessage *error_reply; |
| int ret; |
| |
| if (get_peer_hwaddr_helper(message, __func__, peer, &error_reply) < 0) |
| return error_reply; |
| |
| wpa_printf(MSG_DEBUG, "DBUS TDLS_DISCOVER " MACSTR, MAC2STR(peer)); |
| |
| if (wpa_tdls_is_external_setup(wpa_s->wpa)) |
| ret = wpa_tdls_send_discovery_request(wpa_s->wpa, peer); |
| else |
| ret = wpa_drv_tdls_oper(wpa_s, TDLS_DISCOVERY_REQ, peer); |
| |
| if (ret) { |
| return wpas_dbus_error_unknown_error( |
| message, "error performing TDLS discovery"); |
| } |
| |
| return NULL; |
| } |
| |
| |
| /* |
| * wpas_dbus_handler_tdls_setup - Setup TDLS session |
| * @message: Pointer to incoming dbus message |
| * @wpa_s: wpa_supplicant structure for a network interface |
| * Returns: NULL indicating success or DBus error message on failure |
| * |
| * Handler function for "TDLSSetup" method call of network interface. |
| */ |
| DBusMessage * wpas_dbus_handler_tdls_setup(DBusMessage *message, |
| struct wpa_supplicant *wpa_s) |
| { |
| u8 peer[ETH_ALEN]; |
| DBusMessage *error_reply; |
| int ret; |
| |
| if (get_peer_hwaddr_helper(message, __func__, peer, &error_reply) < 0) |
| return error_reply; |
| |
| wpa_printf(MSG_DEBUG, "DBUS TDLS_SETUP " MACSTR, MAC2STR(peer)); |
| |
| wpa_tdls_remove(wpa_s->wpa, peer); |
| if (wpa_tdls_is_external_setup(wpa_s->wpa)) |
| ret = wpa_tdls_start(wpa_s->wpa, peer); |
| else |
| ret = wpa_drv_tdls_oper(wpa_s, TDLS_SETUP, peer); |
| |
| if (ret) { |
| return wpas_dbus_error_unknown_error( |
| message, "error performing TDLS setup"); |
| } |
| |
| return NULL; |
| } |
| |
| |
| /* |
| * wpas_dbus_handler_tdls_status - Return TDLS session status |
| * @message: Pointer to incoming dbus message |
| * @wpa_s: wpa_supplicant structure for a network interface |
| * Returns: A string representing the state of the link to this TDLS peer |
| * |
| * Handler function for "TDLSStatus" method call of network interface. |
| */ |
| DBusMessage * wpas_dbus_handler_tdls_status(DBusMessage *message, |
| struct wpa_supplicant *wpa_s) |
| { |
| u8 peer[ETH_ALEN]; |
| DBusMessage *reply; |
| const char *tdls_status; |
| |
| if (get_peer_hwaddr_helper(message, __func__, peer, &reply) < 0) |
| return reply; |
| |
| wpa_printf(MSG_DEBUG, "DBUS TDLS_STATUS " MACSTR, MAC2STR(peer)); |
| |
| tdls_status = wpa_tdls_get_link_status(wpa_s->wpa, peer); |
| |
| reply = dbus_message_new_method_return(message); |
| dbus_message_append_args(reply, DBUS_TYPE_STRING, |
| &tdls_status, DBUS_TYPE_INVALID); |
| return reply; |
| } |
| |
| |
| /* |
| * wpas_dbus_handler_tdls_teardown - Teardown TDLS session |
| * @message: Pointer to incoming dbus message |
| * @wpa_s: wpa_supplicant structure for a network interface |
| * Returns: NULL indicating success or DBus error message on failure |
| * |
| * Handler function for "TDLSTeardown" method call of network interface. |
| */ |
| DBusMessage * wpas_dbus_handler_tdls_teardown(DBusMessage *message, |
| struct wpa_supplicant *wpa_s) |
| { |
| u8 peer[ETH_ALEN]; |
| DBusMessage *error_reply; |
| int ret; |
| |
| if (get_peer_hwaddr_helper(message, __func__, peer, &error_reply) < 0) |
| return error_reply; |
| |
| wpa_printf(MSG_DEBUG, "DBUS TDLS_TEARDOWN " MACSTR, MAC2STR(peer)); |
| |
| if (wpa_tdls_is_external_setup(wpa_s->wpa)) |
| ret = wpa_tdls_teardown_link( |
| wpa_s->wpa, peer, |
| WLAN_REASON_TDLS_TEARDOWN_UNSPECIFIED); |
| else |
| ret = wpa_drv_tdls_oper(wpa_s, TDLS_TEARDOWN, peer); |
| |
| if (ret) { |
| return wpas_dbus_error_unknown_error( |
| message, "error performing TDLS teardown"); |
| } |
| |
| return NULL; |
| } |
| |
| /* |
| * wpas_dbus_handler_tdls_channel_switch - Enable channel switching with TDLS peer |
| * @message: Pointer to incoming dbus message |
| * @wpa_s: wpa_supplicant structure for a network interface |
| * Returns: NULL indicating success or DBus error message on failure |
| * |
| * Handler function for "TDLSChannelSwitch" method call of network interface. |
| */ |
| DBusMessage * |
| wpas_dbus_handler_tdls_channel_switch(DBusMessage *message, |
| struct wpa_supplicant *wpa_s) |
| { |
| DBusMessageIter iter, iter_dict; |
| struct wpa_dbus_dict_entry entry; |
| u8 peer[ETH_ALEN]; |
| struct hostapd_freq_params freq_params; |
| u8 oper_class = 0; |
| int ret; |
| int is_peer_present = 0; |
| |
| if (!wpa_tdls_is_external_setup(wpa_s->wpa)) { |
| wpa_printf(MSG_INFO, |
| "tdls_chanswitch: Only supported with external setup"); |
| return wpas_dbus_error_unknown_error(message, "TDLS is not using external setup"); |
| } |
| |
| os_memset(&freq_params, 0, sizeof(freq_params)); |
| |
| dbus_message_iter_init(message, &iter); |
| |
| if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL)) |
| return wpas_dbus_error_invalid_args(message, NULL); |
| |
| while (wpa_dbus_dict_has_dict_entry(&iter_dict)) { |
| if (!wpa_dbus_dict_get_entry(&iter_dict, &entry)) |
| return wpas_dbus_error_invalid_args(message, NULL); |
| |
| if (os_strcmp(entry.key, "PeerAddress") == 0 && |
| entry.type == DBUS_TYPE_STRING) { |
| if (hwaddr_aton(entry.str_value, peer)) { |
| wpa_printf(MSG_DEBUG, |
| "tdls_chanswitch: Invalid address '%s'", |
| entry.str_value); |
| wpa_dbus_dict_entry_clear(&entry); |
| return wpas_dbus_error_invalid_args(message, |
| NULL); |
| } |
| |
| is_peer_present = 1; |
| } else if (os_strcmp(entry.key, "OperClass") == 0 && |
| entry.type == DBUS_TYPE_BYTE) { |
| oper_class = entry.byte_value; |
| } else if (os_strcmp(entry.key, "Frequency") == 0 && |
| entry.type == DBUS_TYPE_UINT32) { |
| freq_params.freq = entry.uint32_value; |
| } else if (os_strcmp(entry.key, "SecChannelOffset") == 0 && |
| entry.type == DBUS_TYPE_UINT32) { |
| freq_params.sec_channel_offset = entry.uint32_value; |
| } else if (os_strcmp(entry.key, "CenterFrequency1") == 0 && |
| entry.type == DBUS_TYPE_UINT32) { |
| freq_params.center_freq1 = entry.uint32_value; |
| } else if (os_strcmp(entry.key, "CenterFrequency2") == 0 && |
| entry.type == DBUS_TYPE_UINT32) { |
| freq_params.center_freq2 = entry.uint32_value; |
| } else if (os_strcmp(entry.key, "Bandwidth") == 0 && |
| entry.type == DBUS_TYPE_UINT32) { |
| freq_params.bandwidth = entry.uint32_value; |
| } else if (os_strcmp(entry.key, "HT") == 0 && |
| entry.type == DBUS_TYPE_BOOLEAN) { |
| freq_params.ht_enabled = entry.bool_value; |
| } else if (os_strcmp(entry.key, "VHT") == 0 && |
| entry.type == DBUS_TYPE_BOOLEAN) { |
| freq_params.vht_enabled = entry.bool_value; |
| } else { |
| wpa_dbus_dict_entry_clear(&entry); |
| return wpas_dbus_error_invalid_args(message, NULL); |
| } |
| |
| wpa_dbus_dict_entry_clear(&entry); |
| } |
| |
| if (oper_class == 0) { |
| wpa_printf(MSG_INFO, |
| "tdls_chanswitch: Invalid op class provided"); |
| return wpas_dbus_error_invalid_args( |
| message, "Invalid op class provided"); |
| } |
| |
| if (freq_params.freq == 0) { |
| wpa_printf(MSG_INFO, |
| "tdls_chanswitch: Invalid freq provided"); |
| return wpas_dbus_error_invalid_args(message, |
| "Invalid freq provided"); |
| } |
| |
| if (is_peer_present == 0) { |
| wpa_printf(MSG_DEBUG, |
| "tdls_chanswitch: peer address not provided"); |
| return wpas_dbus_error_invalid_args( |
| message, "peer address not provided"); |
| } |
| |
| wpa_printf(MSG_DEBUG, "dbus: TDLS_CHAN_SWITCH " MACSTR |
| " OP CLASS %d FREQ %d CENTER1 %d CENTER2 %d BW %d SEC_OFFSET %d%s%s", |
| MAC2STR(peer), oper_class, freq_params.freq, |
| freq_params.center_freq1, freq_params.center_freq2, |
| freq_params.bandwidth, freq_params.sec_channel_offset, |
| freq_params.ht_enabled ? " HT" : "", |
| freq_params.vht_enabled ? " VHT" : ""); |
| |
| ret = wpa_tdls_enable_chan_switch(wpa_s->wpa, peer, oper_class, |
| &freq_params); |
| if (ret) |
| return wpas_dbus_error_unknown_error( |
| message, "error processing TDLS channel switch"); |
| |
| return NULL; |
| } |
| |
| /* |
| * wpas_dbus_handler_tdls_cancel_channel_switch - Disable channel switching with TDLS peer |
| * @message: Pointer to incoming dbus message |
| * @wpa_s: wpa_supplicant structure for a network interface |
| * Returns: NULL indicating success or DBus error message on failure |
| * |
| * Handler function for "TDLSCancelChannelSwitch" method call of network |
| * interface. |
| */ |
| DBusMessage * |
| wpas_dbus_handler_tdls_cancel_channel_switch(DBusMessage *message, |
| struct wpa_supplicant *wpa_s) |
| { |
| u8 peer[ETH_ALEN]; |
| DBusMessage *error_reply; |
| int ret; |
| |
| if (get_peer_hwaddr_helper(message, __func__, peer, &error_reply) < 0) |
| return error_reply; |
| |
| wpa_printf(MSG_DEBUG, "dbus: TDLS_CANCEL_CHAN_SWITCH " MACSTR, |
| MAC2STR(peer)); |
| |
| ret = wpa_tdls_disable_chan_switch(wpa_s->wpa, peer); |
| if (ret) |
| return wpas_dbus_error_unknown_error( |
| message, "error canceling TDLS channel switch"); |
| |
| return NULL; |
| } |
| |
| #endif /* CONFIG_TDLS */ |
| |
| |
| #ifndef CONFIG_NO_CONFIG_WRITE |
| /** |
| * wpas_dbus_handler_save_config - Save configuration to configuration file |
| * @message: Pointer to incoming dbus message |
| * @wpa_s: wpa_supplicant structure for a network interface |
| * Returns: NULL on Success, Otherwise error message |
| * |
| * Handler function for "SaveConfig" method call of network interface. |
| */ |
| DBusMessage * wpas_dbus_handler_save_config(DBusMessage *message, |
| struct wpa_supplicant *wpa_s) |
| { |
| int ret; |
| |
| if (!wpa_s->conf->update_config) { |
| return wpas_dbus_error_unknown_error( |
| message, |
| "Not allowed to update configuration (update_config=0)"); |
| } |
| |
| ret = wpa_config_write(wpa_s->confname, wpa_s->conf); |
| if (ret) |
| return wpas_dbus_error_unknown_error( |
| message, "Failed to update configuration"); |
| return NULL; |
| } |
| #endif /* CONFIG_NO_CONFIG_WRITE */ |
| |
| |
| /** |
| * wpas_dbus_handler_set_pkcs11_engine_and_module_path - Set PKCS #11 engine and module path |
| * @message: Pointer to incoming dbus message |
| * @wpa_s: %wpa_supplicant data structure |
| * Returns: A dbus message containing an error on failure or NULL on success |
| * |
| * Sets the PKCS #11 engine and module path. |
| */ |
| DBusMessage * wpas_dbus_handler_set_pkcs11_engine_and_module_path( |
| DBusMessage *message, struct wpa_supplicant *wpa_s) |
| { |
| DBusMessageIter iter; |
| char *value = NULL; |
| char *pkcs11_engine_path = NULL; |
| char *pkcs11_module_path = NULL; |
| |
| dbus_message_iter_init(message, &iter); |
| dbus_message_iter_get_basic(&iter, &value); |
| if (value == NULL) { |
| return dbus_message_new_error( |
| message, DBUS_ERROR_INVALID_ARGS, |
| "Invalid pkcs11_engine_path argument"); |
| } |
| /* Empty path defaults to NULL */ |
| if (os_strlen(value)) |
| pkcs11_engine_path = value; |
| |
| dbus_message_iter_next(&iter); |
| dbus_message_iter_get_basic(&iter, &value); |
| if (value == NULL) { |
| os_free(pkcs11_engine_path); |
| return dbus_message_new_error( |
| message, DBUS_ERROR_INVALID_ARGS, |
| "Invalid pkcs11_module_path argument"); |
| } |
| /* Empty path defaults to NULL */ |
| if (os_strlen(value)) |
| pkcs11_module_path = value; |
| |
| if (wpas_set_pkcs11_engine_and_module_path(wpa_s, pkcs11_engine_path, |
| pkcs11_module_path)) |
| return dbus_message_new_error( |
| message, DBUS_ERROR_FAILED, |
| "Reinit of the EAPOL state machine with the new PKCS #11 engine and module path failed."); |
| |
| if (wpa_s->dbus_new_path) { |
| wpa_dbus_mark_property_changed( |
| wpa_s->global->dbus, wpa_s->dbus_new_path, |
| WPAS_DBUS_NEW_IFACE_INTERFACE, "PKCS11EnginePath"); |
| wpa_dbus_mark_property_changed( |
| wpa_s->global->dbus, wpa_s->dbus_new_path, |
| WPAS_DBUS_NEW_IFACE_INTERFACE, "PKCS11ModulePath"); |
| } |
| |
| return NULL; |
| } |
| |
| |
| /** |
| * wpas_dbus_getter_capabilities - Return interface capabilities |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Getter for "Capabilities" property of an interface. |
| */ |
| dbus_bool_t wpas_dbus_getter_capabilities( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct wpa_supplicant *wpa_s = user_data; |
| struct wpa_driver_capa capa; |
| int res; |
| DBusMessageIter iter_dict, iter_dict_entry, iter_dict_val, iter_array, |
| variant_iter; |
| const char *scans[] = { "active", "passive", "ssid" }; |
| |
| if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT, |
| "a{sv}", &variant_iter) || |
| !wpa_dbus_dict_open_write(&variant_iter, &iter_dict)) |
| goto nomem; |
| |
| res = wpa_drv_get_capa(wpa_s, &capa); |
| |
| /***** pairwise cipher */ |
| if (res < 0) { |
| #ifdef CONFIG_NO_TKIP |
| const char *args[] = {"ccmp", "none"}; |
| #else /* CONFIG_NO_TKIP */ |
| const char *args[] = {"ccmp", "tkip", "none"}; |
| #endif /* CONFIG_NO_TKIP */ |
| |
| if (!wpa_dbus_dict_append_string_array( |
| &iter_dict, "Pairwise", args, |
| ARRAY_SIZE(args))) |
| goto nomem; |
| } else { |
| if (!wpa_dbus_dict_begin_string_array(&iter_dict, "Pairwise", |
| &iter_dict_entry, |
| &iter_dict_val, |
| &iter_array) || |
| ((capa.enc & WPA_DRIVER_CAPA_ENC_CCMP_256) && |
| !wpa_dbus_dict_string_array_add_element( |
| &iter_array, "ccmp-256")) || |
| ((capa.enc & WPA_DRIVER_CAPA_ENC_GCMP_256) && |
| !wpa_dbus_dict_string_array_add_element( |
| &iter_array, "gcmp-256")) || |
| ((capa.enc & WPA_DRIVER_CAPA_ENC_CCMP) && |
| !wpa_dbus_dict_string_array_add_element( |
| &iter_array, "ccmp")) || |
| ((capa.enc & WPA_DRIVER_CAPA_ENC_GCMP) && |
| !wpa_dbus_dict_string_array_add_element( |
| &iter_array, "gcmp")) || |
| #ifndef CONFIG_NO_TKIP |
| ((capa.enc & WPA_DRIVER_CAPA_ENC_TKIP) && |
| !wpa_dbus_dict_string_array_add_element( |
| &iter_array, "tkip")) || |
| #endif /* CONFIG_NO_TKIP */ |
| ((capa.key_mgmt & WPA_DRIVER_CAPA_KEY_MGMT_WPA_NONE) && |
| !wpa_dbus_dict_string_array_add_element( |
| &iter_array, "none")) || |
| !wpa_dbus_dict_end_string_array(&iter_dict, |
| &iter_dict_entry, |
| &iter_dict_val, |
| &iter_array)) |
| goto nomem; |
| } |
| |
| /***** group cipher */ |
| if (res < 0) { |
| const char *args[] = { |
| "ccmp", |
| #ifndef CONFIG_NO_TKIP |
| "tkip", |
| #endif /* CONFIG_NO_TKIP */ |
| #ifdef CONFIG_WEP |
| "wep104", "wep40" |
| #endif /* CONFIG_WEP */ |
| }; |
| |
| if (!wpa_dbus_dict_append_string_array( |
| &iter_dict, "Group", args, |
| ARRAY_SIZE(args))) |
| goto nomem; |
| } else { |
| if (!wpa_dbus_dict_begin_string_array(&iter_dict, "Group", |
| &iter_dict_entry, |
| &iter_dict_val, |
| &iter_array) || |
| ((capa.enc & WPA_DRIVER_CAPA_ENC_CCMP_256) && |
| !wpa_dbus_dict_string_array_add_element( |
| &iter_array, "ccmp-256")) || |
| ((capa.enc & WPA_DRIVER_CAPA_ENC_GCMP_256) && |
| !wpa_dbus_dict_string_array_add_element( |
| &iter_array, "gcmp-256")) || |
| ((capa.enc & WPA_DRIVER_CAPA_ENC_CCMP) && |
| !wpa_dbus_dict_string_array_add_element( |
| &iter_array, "ccmp")) || |
| ((capa.enc & WPA_DRIVER_CAPA_ENC_GCMP) && |
| !wpa_dbus_dict_string_array_add_element( |
| &iter_array, "gcmp")) || |
| #ifndef CONFIG_NO_TKIP |
| ((capa.enc & WPA_DRIVER_CAPA_ENC_TKIP) && |
| !wpa_dbus_dict_string_array_add_element( |
| &iter_array, "tkip")) || |
| #endif /* CONFIG_NO_TKIP */ |
| #ifdef CONFIG_WEP |
| ((capa.enc & WPA_DRIVER_CAPA_ENC_WEP104) && |
| !wpa_dbus_dict_string_array_add_element( |
| &iter_array, "wep104")) || |
| ((capa.enc & WPA_DRIVER_CAPA_ENC_WEP40) && |
| !wpa_dbus_dict_string_array_add_element( |
| &iter_array, "wep40")) || |
| #endif /* CONFIG_WEP */ |
| !wpa_dbus_dict_end_string_array(&iter_dict, |
| &iter_dict_entry, |
| &iter_dict_val, |
| &iter_array)) |
| goto nomem; |
| } |
| |
| if (!wpa_dbus_dict_begin_string_array(&iter_dict, "GroupMgmt", |
| &iter_dict_entry, |
| &iter_dict_val, |
| &iter_array) || |
| (res == 0 && (capa.enc & WPA_DRIVER_CAPA_ENC_BIP) && |
| !wpa_dbus_dict_string_array_add_element( |
| &iter_array, "aes-128-cmac")) || |
| (res == 0 && (capa.enc & WPA_DRIVER_CAPA_ENC_BIP_GMAC_128) && |
| !wpa_dbus_dict_string_array_add_element( |
| &iter_array, "bip-gmac-128")) || |
| (res == 0 && (capa.enc & WPA_DRIVER_CAPA_ENC_BIP_GMAC_256) && |
| !wpa_dbus_dict_string_array_add_element( |
| &iter_array, "bip-gmac-256")) || |
| (res == 0 && (capa.enc & WPA_DRIVER_CAPA_ENC_BIP_CMAC_256) && |
| !wpa_dbus_dict_string_array_add_element( |
| &iter_array, "bip-cmac-256")) || |
| !wpa_dbus_dict_end_string_array(&iter_dict, |
| &iter_dict_entry, |
| &iter_dict_val, |
| &iter_array)) |
| goto nomem; |
| |
| /***** key management */ |
| if (res < 0) { |
| const char *args[] = { |
| "wpa-psk", "wpa-eap", "ieee8021x", "wpa-none", |
| #ifdef CONFIG_WPS |
| "wps", |
| #endif /* CONFIG_WPS */ |
| "none" |
| }; |
| if (!wpa_dbus_dict_append_string_array( |
| &iter_dict, "KeyMgmt", args, |
| ARRAY_SIZE(args))) |
| goto nomem; |
| } else { |
| if (!wpa_dbus_dict_begin_string_array(&iter_dict, "KeyMgmt", |
| &iter_dict_entry, |
| &iter_dict_val, |
| &iter_array) || |
| !wpa_dbus_dict_string_array_add_element(&iter_array, |
| "none") || |
| !wpa_dbus_dict_string_array_add_element(&iter_array, |
| "ieee8021x")) |
| goto nomem; |
| |
| if (capa.key_mgmt & (WPA_DRIVER_CAPA_KEY_MGMT_WPA | |
| WPA_DRIVER_CAPA_KEY_MGMT_WPA2)) { |
| if (!wpa_dbus_dict_string_array_add_element( |
| &iter_array, "wpa-eap") || |
| ((capa.key_mgmt & WPA_DRIVER_CAPA_KEY_MGMT_FT) && |
| !wpa_dbus_dict_string_array_add_element( |
| &iter_array, "wpa-ft-eap"))) |
| goto nomem; |
| |
| /* TODO: Ensure that driver actually supports sha256 encryption. */ |
| if (!wpa_dbus_dict_string_array_add_element( |
| &iter_array, "wpa-eap-sha256")) |
| goto nomem; |
| } |
| |
| if (capa.key_mgmt & (WPA_DRIVER_CAPA_KEY_MGMT_WPA_PSK | |
| WPA_DRIVER_CAPA_KEY_MGMT_WPA2_PSK)) { |
| if (!wpa_dbus_dict_string_array_add_element( |
| &iter_array, "wpa-psk") || |
| ((capa.key_mgmt & |
| WPA_DRIVER_CAPA_KEY_MGMT_FT_PSK) && |
| !wpa_dbus_dict_string_array_add_element( |
| &iter_array, "wpa-ft-psk"))) |
| goto nomem; |
| |
| /* TODO: Ensure that driver actually supports sha256 encryption. */ |
| if (!wpa_dbus_dict_string_array_add_element( |
| &iter_array, "wpa-psk-sha256")) |
| goto nomem; |
| } |
| |
| if ((capa.key_mgmt & WPA_DRIVER_CAPA_KEY_MGMT_WPA_NONE) && |
| !wpa_dbus_dict_string_array_add_element(&iter_array, |
| "wpa-none")) |
| goto nomem; |
| |
| |
| #ifdef CONFIG_WPS |
| if (!wpa_dbus_dict_string_array_add_element(&iter_array, |
| "wps")) |
| goto nomem; |
| #endif /* CONFIG_WPS */ |
| |
| #ifdef CONFIG_SAE |
| if ((capa.key_mgmt & WPA_DRIVER_CAPA_KEY_MGMT_SAE) && |
| !wpa_dbus_dict_string_array_add_element(&iter_array, "sae")) |
| goto nomem; |
| #endif /* CONFIG_SAE */ |
| |
| #ifdef CONFIG_OWE |
| if ((capa.key_mgmt & WPA_DRIVER_CAPA_KEY_MGMT_OWE) && |
| !wpa_dbus_dict_string_array_add_element(&iter_array, "owe")) |
| goto nomem; |
| #endif /* CONFIG_OWE */ |
| |
| if (!wpa_dbus_dict_end_string_array(&iter_dict, |
| &iter_dict_entry, |
| &iter_dict_val, |
| &iter_array)) |
| goto nomem; |
| } |
| |
| /***** WPA protocol */ |
| if (res < 0) { |
| const char *args[] = { "rsn", "wpa" }; |
| |
| if (!wpa_dbus_dict_append_string_array( |
| &iter_dict, "Protocol", args, |
| ARRAY_SIZE(args))) |
| goto nomem; |
| } else { |
| if (!wpa_dbus_dict_begin_string_array(&iter_dict, "Protocol", |
| &iter_dict_entry, |
| &iter_dict_val, |
| &iter_array) || |
| ((capa.key_mgmt & (WPA_DRIVER_CAPA_KEY_MGMT_WPA2 | |
| WPA_DRIVER_CAPA_KEY_MGMT_WPA2_PSK)) && |
| !wpa_dbus_dict_string_array_add_element( |
| &iter_array, "rsn")) || |
| ((capa.key_mgmt & (WPA_DRIVER_CAPA_KEY_MGMT_WPA | |
| WPA_DRIVER_CAPA_KEY_MGMT_WPA_PSK)) && |
| !wpa_dbus_dict_string_array_add_element( |
| &iter_array, "wpa")) || |
| !wpa_dbus_dict_end_string_array(&iter_dict, |
| &iter_dict_entry, |
| &iter_dict_val, |
| &iter_array)) |
| goto nomem; |
| } |
| |
| /***** auth alg */ |
| if (res < 0) { |
| const char *args[] = { "open", "shared", "leap" }; |
| |
| if (!wpa_dbus_dict_append_string_array( |
| &iter_dict, "AuthAlg", args, |
| ARRAY_SIZE(args))) |
| goto nomem; |
| } else { |
| if (!wpa_dbus_dict_begin_string_array(&iter_dict, "AuthAlg", |
| &iter_dict_entry, |
| &iter_dict_val, |
| &iter_array)) |
| goto nomem; |
| |
| if (((capa.auth & WPA_DRIVER_AUTH_OPEN) && |
| !wpa_dbus_dict_string_array_add_element( |
| &iter_array, "open")) || |
| ((capa.auth & WPA_DRIVER_AUTH_SHARED) && |
| !wpa_dbus_dict_string_array_add_element( |
| &iter_array, "shared")) || |
| ((capa.auth & WPA_DRIVER_AUTH_LEAP) && |
| !wpa_dbus_dict_string_array_add_element( |
| &iter_array, "leap")) || |
| !wpa_dbus_dict_end_string_array(&iter_dict, |
| &iter_dict_entry, |
| &iter_dict_val, |
| &iter_array)) |
| goto nomem; |
| } |
| |
| /***** Scan */ |
| if (!wpa_dbus_dict_append_string_array(&iter_dict, "Scan", scans, |
| ARRAY_SIZE(scans))) |
| goto nomem; |
| |
| /***** Modes */ |
| if (!wpa_dbus_dict_begin_string_array(&iter_dict, "Modes", |
| &iter_dict_entry, |
| &iter_dict_val, |
| &iter_array) || |
| !wpa_dbus_dict_string_array_add_element( |
| &iter_array, "infrastructure") || |
| (res >= 0 && (capa.flags & WPA_DRIVER_FLAGS_IBSS) && |
| !wpa_dbus_dict_string_array_add_element( |
| &iter_array, "ad-hoc")) || |
| (res >= 0 && (capa.flags & WPA_DRIVER_FLAGS_AP) && |
| !wpa_dbus_dict_string_array_add_element( |
| &iter_array, "ap")) || |
| (res >= 0 && (capa.flags & WPA_DRIVER_FLAGS_P2P_CAPABLE) && |
| !wpa_s->conf->p2p_disabled && |
| !wpa_dbus_dict_string_array_add_element( |
| &iter_array, "p2p")) || |
| #ifdef CONFIG_MESH |
| (res >= 0 && (capa.flags & WPA_DRIVER_FLAGS_MESH) && |
| !wpa_dbus_dict_string_array_add_element( |
| &iter_array, "mesh")) || |
| #endif /* CONFIG_MESH */ |
| !wpa_dbus_dict_end_string_array(&iter_dict, |
| &iter_dict_entry, |
| &iter_dict_val, |
| &iter_array)) |
| goto nomem; |
| /***** Modes end */ |
| |
| if (res >= 0) { |
| dbus_int32_t max_scan_ssid = capa.max_scan_ssids; |
| |
| if (!wpa_dbus_dict_append_int32(&iter_dict, "MaxScanSSID", |
| max_scan_ssid)) |
| goto nomem; |
| } |
| |
| if (!wpa_dbus_dict_close_write(&variant_iter, &iter_dict) || |
| !dbus_message_iter_close_container(iter, &variant_iter)) |
| goto nomem; |
| |
| return TRUE; |
| |
| nomem: |
| dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory"); |
| return FALSE; |
| } |
| |
| |
| /** |
| * wpas_dbus_getter_state - Get interface state |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Getter for "State" property. |
| */ |
| dbus_bool_t wpas_dbus_getter_state( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct wpa_supplicant *wpa_s = user_data; |
| const char *str_state; |
| char *state_ls, *tmp; |
| dbus_bool_t success = FALSE; |
| |
| str_state = wpa_supplicant_state_txt(wpa_s->wpa_state); |
| |
| /* make state string lowercase to fit new DBus API convention |
| */ |
| state_ls = tmp = os_strdup(str_state); |
| if (!tmp) { |
| dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory"); |
| return FALSE; |
| } |
| while (*tmp) { |
| *tmp = tolower(*tmp); |
| tmp++; |
| } |
| |
| success = wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING, |
| &state_ls, error); |
| |
| os_free(state_ls); |
| |
| return success; |
| } |
| |
| |
| /** |
| * wpas_dbus_new_iface_get_scanning - Get interface scanning state |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Getter for "scanning" property. |
| */ |
| dbus_bool_t wpas_dbus_getter_scanning( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct wpa_supplicant *wpa_s = user_data; |
| dbus_bool_t scanning = wpa_s->scanning ? TRUE : FALSE; |
| |
| return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_BOOLEAN, |
| &scanning, error); |
| } |
| |
| |
| /** |
| * wpas_dbus_getter_ap_scan - Control roaming mode |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Getter function for "ApScan" property. |
| */ |
| dbus_bool_t wpas_dbus_getter_ap_scan( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct wpa_supplicant *wpa_s = user_data; |
| dbus_uint32_t ap_scan = wpa_s->conf->ap_scan; |
| |
| return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_UINT32, |
| &ap_scan, error); |
| } |
| |
| |
| /** |
| * wpas_dbus_setter_ap_scan - Control roaming mode |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Setter function for "ApScan" property. |
| */ |
| dbus_bool_t wpas_dbus_setter_ap_scan( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct wpa_supplicant *wpa_s = user_data; |
| dbus_uint32_t ap_scan; |
| |
| if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_UINT32, |
| &ap_scan)) |
| return FALSE; |
| |
| if (wpa_supplicant_set_ap_scan(wpa_s, ap_scan)) { |
| dbus_set_error_const(error, DBUS_ERROR_FAILED, |
| "ap_scan must be 0, 1, or 2"); |
| return FALSE; |
| } |
| return TRUE; |
| } |
| |
| |
| /** |
| * wpas_dbus_getter_fast_reauth - Control fast |
| * reauthentication (TLS session resumption) |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Getter function for "FastReauth" property. |
| */ |
| dbus_bool_t wpas_dbus_getter_fast_reauth( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct wpa_supplicant *wpa_s = user_data; |
| dbus_bool_t fast_reauth = wpa_s->conf->fast_reauth ? TRUE : FALSE; |
| |
| return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_BOOLEAN, |
| &fast_reauth, error); |
| } |
| |
| |
| /** |
| * wpas_dbus_setter_fast_reauth - Control fast |
| * reauthentication (TLS session resumption) |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Setter function for "FastReauth" property. |
| */ |
| dbus_bool_t wpas_dbus_setter_fast_reauth( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct wpa_supplicant *wpa_s = user_data; |
| dbus_bool_t fast_reauth; |
| |
| if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_BOOLEAN, |
| &fast_reauth)) |
| return FALSE; |
| |
| wpa_s->conf->fast_reauth = fast_reauth; |
| return TRUE; |
| } |
| |
| |
| /** |
| * wpas_dbus_getter_disconnect_reason - Get most recent reason for disconnect |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Getter for "DisconnectReason" property. The reason is negative if it is |
| * locally generated. |
| */ |
| dbus_bool_t wpas_dbus_getter_disconnect_reason( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct wpa_supplicant *wpa_s = user_data; |
| dbus_int32_t reason = wpa_s->disconnect_reason; |
| |
| return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_INT32, |
| &reason, error); |
| } |
| |
| |
| /** |
| * wpas_dbus_getter_auth_status_code - Get most recent auth status code |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Getter for "AuthStatusCode" property. |
| */ |
| dbus_bool_t wpas_dbus_getter_auth_status_code( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct wpa_supplicant *wpa_s = user_data; |
| dbus_int32_t reason = wpa_s->auth_status_code; |
| |
| return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_INT32, |
| &reason, error); |
| } |
| |
| |
| /** |
| * wpas_dbus_getter_assoc_status_code - Get most recent failed assoc status code |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Getter for "AssocStatusCode" property. |
| */ |
| dbus_bool_t wpas_dbus_getter_assoc_status_code( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct wpa_supplicant *wpa_s = user_data; |
| dbus_int32_t status_code = wpa_s->assoc_status_code; |
| |
| return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_INT32, |
| &status_code, error); |
| } |
| |
| |
| /** |
| * wpas_dbus_getter_roam_time - Get most recent roam time |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Getter for "RoamTime" property. |
| */ |
| dbus_bool_t wpas_dbus_getter_roam_time( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct wpa_supplicant *wpa_s = user_data; |
| dbus_uint32_t roam_time = wpa_s->roam_time.sec * 1000 + |
| wpa_s->roam_time.usec / 1000; |
| |
| return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_UINT32, |
| &roam_time, error); |
| } |
| |
| |
| /** |
| * wpas_dbus_getter_roam_complete - Get most recent roam success or failure |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Getter for "RoamComplete" property. |
| */ |
| dbus_bool_t wpas_dbus_getter_roam_complete( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct wpa_supplicant *wpa_s = user_data; |
| dbus_bool_t roam_complete = os_reltime_initialized(&wpa_s->roam_time); |
| |
| return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_BOOLEAN, |
| &roam_complete, error); |
| } |
| |
| |
| /** |
| * wpas_dbus_getter_session_length - Get most recent BSS session length |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Getter for "SessionLength" property. |
| */ |
| dbus_bool_t wpas_dbus_getter_session_length( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct wpa_supplicant *wpa_s = user_data; |
| dbus_uint32_t session_length = wpa_s->session_length.sec * 1000 + |
| wpa_s->session_length.usec / 1000; |
| |
| return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_UINT32, |
| &session_length, error); |
| } |
| |
| |
| /** |
| * wpas_dbus_getter_bss_tm_status - Get most BSS Transition Management request |
| * status code |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Getter for "BSSTMStatus" property. |
| */ |
| dbus_bool_t wpas_dbus_getter_bss_tm_status( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| #ifdef CONFIG_WNM |
| struct wpa_supplicant *wpa_s = user_data; |
| dbus_uint32_t bss_tm_status = wpa_s->bss_tm_status; |
| #else /* CONFIG_WNM */ |
| dbus_uint32_t bss_tm_status = 0; |
| #endif /* CONFIG_WNM */ |
| |
| return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_UINT32, |
| &bss_tm_status, error); |
| } |
| |
| |
| /** |
| * wpas_dbus_getter_bss_expire_age - Get BSS entry expiration age |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Getter function for "BSSExpireAge" property. |
| */ |
| dbus_bool_t wpas_dbus_getter_bss_expire_age( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct wpa_supplicant *wpa_s = user_data; |
| dbus_uint32_t expire_age = wpa_s->conf->bss_expiration_age; |
| |
| return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_UINT32, |
| &expire_age, error); |
| } |
| |
| |
| /** |
| * wpas_dbus_setter_bss_expire_age - Control BSS entry expiration age |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Setter function for "BSSExpireAge" property. |
| */ |
| dbus_bool_t wpas_dbus_setter_bss_expire_age( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct wpa_supplicant *wpa_s = user_data; |
| dbus_uint32_t expire_age; |
| |
| if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_UINT32, |
| &expire_age)) |
| return FALSE; |
| |
| if (wpa_supplicant_set_bss_expiration_age(wpa_s, expire_age)) { |
| dbus_set_error_const(error, DBUS_ERROR_FAILED, |
| "BSSExpireAge must be >= 10"); |
| return FALSE; |
| } |
| return TRUE; |
| } |
| |
| |
| /** |
| * wpas_dbus_getter_bss_expire_count - Get BSS entry expiration scan count |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Getter function for "BSSExpireCount" property. |
| */ |
| dbus_bool_t wpas_dbus_getter_bss_expire_count( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct wpa_supplicant *wpa_s = user_data; |
| dbus_uint32_t expire_count = wpa_s->conf->bss_expiration_scan_count; |
| |
| return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_UINT32, |
| &expire_count, error); |
| } |
| |
| |
| /** |
| * wpas_dbus_setter_bss_expire_count - Control BSS entry expiration scan count |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Setter function for "BSSExpireCount" property. |
| */ |
| dbus_bool_t wpas_dbus_setter_bss_expire_count( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct wpa_supplicant *wpa_s = user_data; |
| dbus_uint32_t expire_count; |
| |
| if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_UINT32, |
| &expire_count)) |
| return FALSE; |
| |
| if (wpa_supplicant_set_bss_expiration_count(wpa_s, expire_count)) { |
| dbus_set_error_const(error, DBUS_ERROR_FAILED, |
| "BSSExpireCount must be > 0"); |
| return FALSE; |
| } |
| return TRUE; |
| } |
| |
| |
| /** |
| * wpas_dbus_getter_country - Control country code |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Getter function for "Country" property. |
| */ |
| dbus_bool_t wpas_dbus_getter_country( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct wpa_supplicant *wpa_s = user_data; |
| char country[3]; |
| char *str = country; |
| |
| country[0] = wpa_s->conf->country[0]; |
| country[1] = wpa_s->conf->country[1]; |
| country[2] = '\0'; |
| |
| return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING, |
| &str, error); |
| } |
| |
| |
| /** |
| * wpas_dbus_setter_country - Control country code |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Setter function for "Country" property. |
| */ |
| dbus_bool_t wpas_dbus_setter_country( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct wpa_supplicant *wpa_s = user_data; |
| const char *country; |
| |
| if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_STRING, |
| &country)) |
| return FALSE; |
| |
| if (!country[0] || !country[1]) { |
| dbus_set_error_const(error, DBUS_ERROR_FAILED, |
| "invalid country code"); |
| return FALSE; |
| } |
| |
| if (wpa_s->drv_priv != NULL && wpa_drv_set_country(wpa_s, country)) { |
| wpa_printf(MSG_DEBUG, "Failed to set country"); |
| dbus_set_error_const(error, DBUS_ERROR_FAILED, |
| "failed to set country code"); |
| return FALSE; |
| } |
| |
| wpa_s->conf->country[0] = country[0]; |
| wpa_s->conf->country[1] = country[1]; |
| return TRUE; |
| } |
| |
| |
| /** |
| * wpas_dbus_getter_scan_interval - Get scan interval |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Getter function for "ScanInterval" property. |
| */ |
| dbus_bool_t wpas_dbus_getter_scan_interval( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct wpa_supplicant *wpa_s = user_data; |
| dbus_int32_t scan_interval = wpa_s->scan_interval; |
| |
| return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_INT32, |
| &scan_interval, error); |
| } |
| |
| |
| /** |
| * wpas_dbus_setter_scan_interval - Control scan interval |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Setter function for "ScanInterval" property. |
| */ |
| dbus_bool_t wpas_dbus_setter_scan_interval( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct wpa_supplicant *wpa_s = user_data; |
| dbus_int32_t scan_interval; |
| |
| if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_INT32, |
| &scan_interval)) |
| return FALSE; |
| |
| if (wpa_supplicant_set_scan_interval(wpa_s, scan_interval)) { |
| dbus_set_error_const(error, DBUS_ERROR_FAILED, |
| "scan_interval must be >= 0"); |
| return FALSE; |
| } |
| return TRUE; |
| } |
| |
| |
| /** |
| * wpas_dbus_getter_ifname - Get interface name |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Getter for "Ifname" property. |
| */ |
| dbus_bool_t wpas_dbus_getter_ifname( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct wpa_supplicant *wpa_s = user_data; |
| |
| return wpas_dbus_string_property_getter(iter, wpa_s->ifname, error); |
| } |
| |
| |
| /** |
| * wpas_dbus_getter_driver - Get interface name |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Getter for "Driver" property. |
| */ |
| dbus_bool_t wpas_dbus_getter_driver( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct wpa_supplicant *wpa_s = user_data; |
| |
| if (wpa_s->driver == NULL || wpa_s->driver->name == NULL) { |
| wpa_printf(MSG_DEBUG, "%s[dbus]: wpa_s has no driver set", |
| __func__); |
| dbus_set_error(error, DBUS_ERROR_FAILED, "%s: no driver set", |
| __func__); |
| return FALSE; |
| } |
| |
| return wpas_dbus_string_property_getter(iter, wpa_s->driver->name, |
| error); |
| } |
| |
| |
| /** |
| * wpas_dbus_getter_current_bss - Get current bss object path |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Getter for "CurrentBSS" property. |
| */ |
| dbus_bool_t wpas_dbus_getter_current_bss( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct wpa_supplicant *wpa_s = user_data; |
| char path_buf[WPAS_DBUS_OBJECT_PATH_MAX], *bss_obj_path = path_buf; |
| |
| if (wpa_s->current_bss && wpa_s->dbus_new_path) |
| os_snprintf(bss_obj_path, WPAS_DBUS_OBJECT_PATH_MAX, |
| "%s/" WPAS_DBUS_NEW_BSSIDS_PART "/%u", |
| wpa_s->dbus_new_path, wpa_s->current_bss->id); |
| else |
| os_snprintf(bss_obj_path, WPAS_DBUS_OBJECT_PATH_MAX, "/"); |
| |
| return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_OBJECT_PATH, |
| &bss_obj_path, error); |
| } |
| |
| |
| /** |
| * wpas_dbus_getter_current_network - Get current network object path |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Getter for "CurrentNetwork" property. |
| */ |
| dbus_bool_t wpas_dbus_getter_current_network( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct wpa_supplicant *wpa_s = user_data; |
| char path_buf[WPAS_DBUS_OBJECT_PATH_MAX], *net_obj_path = path_buf; |
| |
| if (wpa_s->current_ssid && wpa_s->dbus_new_path) |
| os_snprintf(net_obj_path, WPAS_DBUS_OBJECT_PATH_MAX, |
| "%s/" WPAS_DBUS_NEW_NETWORKS_PART "/%u", |
| wpa_s->dbus_new_path, wpa_s->current_ssid->id); |
| else |
| os_snprintf(net_obj_path, WPAS_DBUS_OBJECT_PATH_MAX, "/"); |
| |
| return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_OBJECT_PATH, |
| &net_obj_path, error); |
| } |
| |
| |
| /** |
| * wpas_dbus_getter_current_auth_mode - Get current authentication type |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Getter for "CurrentAuthMode" property. |
| */ |
| dbus_bool_t wpas_dbus_getter_current_auth_mode( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct wpa_supplicant *wpa_s = user_data; |
| const char *eap_mode; |
| const char *auth_mode; |
| char eap_mode_buf[WPAS_DBUS_AUTH_MODE_MAX]; |
| |
| if (wpa_s->wpa_state != WPA_COMPLETED) { |
| auth_mode = "INACTIVE"; |
| } else if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X || |
| wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) { |
| eap_mode = wpa_supplicant_get_eap_mode(wpa_s); |
| os_snprintf(eap_mode_buf, WPAS_DBUS_AUTH_MODE_MAX, |
| "EAP-%s", eap_mode); |
| auth_mode = eap_mode_buf; |
| |
| } else if (wpa_s->current_ssid) { |
| auth_mode = wpa_key_mgmt_txt(wpa_s->key_mgmt, |
| wpa_s->current_ssid->proto); |
| } else { |
| auth_mode = "UNKNOWN"; |
| } |
| |
| return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING, |
| &auth_mode, error); |
| } |
| |
| |
| /** |
| * wpas_dbus_getter_bridge_ifname - Get interface name |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Getter for "BridgeIfname" property. |
| */ |
| dbus_bool_t wpas_dbus_getter_bridge_ifname( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct wpa_supplicant *wpa_s = user_data; |
| |
| return wpas_dbus_string_property_getter(iter, wpa_s->bridge_ifname, |
| error); |
| } |
| |
| |
| dbus_bool_t wpas_dbus_setter_bridge_ifname( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct wpa_supplicant *wpa_s = user_data; |
| const char *bridge_ifname = NULL; |
| const char *msg; |
| int r; |
| |
| if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_STRING, |
| &bridge_ifname)) |
| return FALSE; |
| |
| r = wpa_supplicant_update_bridge_ifname(wpa_s, bridge_ifname); |
| if (r != 0) { |
| switch (r) { |
| case -EINVAL: |
| msg = "invalid interface name"; |
| break; |
| case -EBUSY: |
| msg = "interface is busy"; |
| break; |
| case -EIO: |
| msg = "socket error"; |
| break; |
| default: |
| msg = "unknown error"; |
| break; |
| } |
| dbus_set_error_const(error, DBUS_ERROR_FAILED, msg); |
| return FALSE; |
| } |
| |
| return TRUE; |
| } |
| |
| |
| /** |
| * wpas_dbus_getter_config_file - Get interface configuration file path |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Getter for "ConfigFile" property. |
| */ |
| dbus_bool_t wpas_dbus_getter_config_file( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct wpa_supplicant *wpa_s = user_data; |
| |
| return wpas_dbus_string_property_getter(iter, wpa_s->confname, error); |
| } |
| |
| |
| /** |
| * wpas_dbus_getter_bsss - Get array of BSSs objects |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Getter for "BSSs" property. |
| */ |
| dbus_bool_t wpas_dbus_getter_bsss( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct wpa_supplicant *wpa_s = user_data; |
| struct wpa_bss *bss; |
| char **paths; |
| unsigned int i = 0; |
| dbus_bool_t success = FALSE; |
| |
| if (!wpa_s->dbus_new_path) { |
| dbus_set_error(error, DBUS_ERROR_FAILED, |
| "%s: no D-Bus interface", __func__); |
| return FALSE; |
| } |
| |
| paths = os_calloc(wpa_s->num_bss, sizeof(char *)); |
| if (!paths) { |
| dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory"); |
| return FALSE; |
| } |
| |
| /* Loop through scan results and append each result's object path */ |
| dl_list_for_each(bss, &wpa_s->bss_id, struct wpa_bss, list_id) { |
| paths[i] = os_zalloc(WPAS_DBUS_OBJECT_PATH_MAX); |
| if (paths[i] == NULL) { |
| dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, |
| "no memory"); |
| goto out; |
| } |
| /* Construct the object path for this BSS. */ |
| os_snprintf(paths[i++], WPAS_DBUS_OBJECT_PATH_MAX, |
| "%s/" WPAS_DBUS_NEW_BSSIDS_PART "/%u", |
| wpa_s->dbus_new_path, bss->id); |
| } |
| |
| success = wpas_dbus_simple_array_property_getter(iter, |
| DBUS_TYPE_OBJECT_PATH, |
| paths, wpa_s->num_bss, |
| error); |
| |
| out: |
| while (i) |
| os_free(paths[--i]); |
| os_free(paths); |
| return success; |
| } |
| |
| |
| /** |
| * wpas_dbus_getter_networks - Get array of networks objects |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Getter for "Networks" property. |
| */ |
| dbus_bool_t wpas_dbus_getter_networks( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct wpa_supplicant *wpa_s = user_data; |
| struct wpa_ssid *ssid; |
| char **paths; |
| unsigned int i = 0, num = 0; |
| dbus_bool_t success = FALSE; |
| |
| if (!wpa_s->dbus_new_path) { |
| dbus_set_error(error, DBUS_ERROR_FAILED, |
| "%s: no D-Bus interface", __func__); |
| return FALSE; |
| } |
| |
| for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) |
| if (!network_is_persistent_group(ssid)) |
| num++; |
| |
| paths = os_calloc(num, sizeof(char *)); |
| if (!paths) { |
| dbus_set_error(error, DBUS_ERROR_NO_MEMORY, "no memory"); |
| return FALSE; |
| } |
| |
| /* Loop through configured networks and append object path of each */ |
| for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) { |
| if (network_is_persistent_group(ssid)) |
| continue; |
| paths[i] = os_zalloc(WPAS_DBUS_OBJECT_PATH_MAX); |
| if (paths[i] == NULL) { |
| dbus_set_error(error, DBUS_ERROR_NO_MEMORY, |
| "no memory"); |
| goto out; |
| } |
| |
| /* Construct the object path for this network. */ |
| os_snprintf(paths[i++], WPAS_DBUS_OBJECT_PATH_MAX, |
| "%s/" WPAS_DBUS_NEW_NETWORKS_PART "/%d", |
| wpa_s->dbus_new_path, ssid->id); |
| } |
| |
| success = wpas_dbus_simple_array_property_getter(iter, |
| DBUS_TYPE_OBJECT_PATH, |
| paths, num, error); |
| |
| out: |
| while (i) |
| os_free(paths[--i]); |
| os_free(paths); |
| return success; |
| } |
| |
| |
| /** |
| * wpas_dbus_getter_pkcs11_engine_path - Get PKCS #11 engine path |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: A dbus message containing the PKCS #11 engine path |
| * |
| * Getter for "PKCS11EnginePath" property. |
| */ |
| dbus_bool_t wpas_dbus_getter_pkcs11_engine_path( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct wpa_supplicant *wpa_s = user_data; |
| |
| return wpas_dbus_string_property_getter(iter, |
| wpa_s->conf->pkcs11_engine_path, |
| error); |
| } |
| |
| |
| /** |
| * wpas_dbus_getter_pkcs11_module_path - Get PKCS #11 module path |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: A dbus message containing the PKCS #11 module path |
| * |
| * Getter for "PKCS11ModulePath" property. |
| */ |
| dbus_bool_t wpas_dbus_getter_pkcs11_module_path( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct wpa_supplicant *wpa_s = user_data; |
| |
| return wpas_dbus_string_property_getter(iter, |
| wpa_s->conf->pkcs11_module_path, |
| error); |
| } |
| |
| |
| /** |
| * wpas_dbus_getter_blobs - Get all blobs defined for this interface |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Getter for "Blobs" property. |
| */ |
| dbus_bool_t wpas_dbus_getter_blobs( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct wpa_supplicant *wpa_s = user_data; |
| DBusMessageIter variant_iter, dict_iter, entry_iter, array_iter; |
| struct wpa_config_blob *blob; |
| |
| if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT, |
| "a{say}", &variant_iter) || |
| !dbus_message_iter_open_container(&variant_iter, DBUS_TYPE_ARRAY, |
| "{say}", &dict_iter)) { |
| dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory"); |
| return FALSE; |
| } |
| |
| blob = wpa_s->conf->blobs; |
| while (blob) { |
| if (!dbus_message_iter_open_container(&dict_iter, |
| DBUS_TYPE_DICT_ENTRY, |
| NULL, &entry_iter) || |
| !dbus_message_iter_append_basic(&entry_iter, |
| DBUS_TYPE_STRING, |
| &(blob->name)) || |
| !dbus_message_iter_open_container(&entry_iter, |
| DBUS_TYPE_ARRAY, |
| DBUS_TYPE_BYTE_AS_STRING, |
| &array_iter) || |
| !dbus_message_iter_append_fixed_array(&array_iter, |
| DBUS_TYPE_BYTE, |
| &(blob->data), |
| blob->len) || |
| !dbus_message_iter_close_container(&entry_iter, |
| &array_iter) || |
| !dbus_message_iter_close_container(&dict_iter, |
| &entry_iter)) { |
| dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, |
| "no memory"); |
| return FALSE; |
| } |
| |
| blob = blob->next; |
| } |
| |
| if (!dbus_message_iter_close_container(&variant_iter, &dict_iter) || |
| !dbus_message_iter_close_container(iter, &variant_iter)) { |
| dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory"); |
| return FALSE; |
| } |
| |
| return TRUE; |
| } |
| |
| |
| dbus_bool_t wpas_dbus_getter_iface_global( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct wpa_supplicant *wpa_s = user_data; |
| int ret; |
| char buf[250]; |
| char *p = buf; |
| |
| if (!property_desc->data) { |
| dbus_set_error(error, DBUS_ERROR_INVALID_ARGS, |
| "Unhandled interface property %s", |
| property_desc->dbus_property); |
| return FALSE; |
| } |
| |
| ret = wpa_config_get_value(property_desc->data, wpa_s->conf, buf, |
| sizeof(buf)); |
| if (ret < 0) |
| *p = '\0'; |
| |
| return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING, &p, |
| error); |
| } |
| |
| |
| dbus_bool_t wpas_dbus_setter_iface_global( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct wpa_supplicant *wpa_s = user_data; |
| const char *new_value = NULL; |
| char buf[250]; |
| size_t combined_len; |
| int ret; |
| |
| if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_STRING, |
| &new_value)) |
| return FALSE; |
| |
| combined_len = os_strlen(property_desc->data) + os_strlen(new_value) + |
| 3; |
| if (combined_len >= sizeof(buf)) { |
| dbus_set_error(error, DBUS_ERROR_INVALID_ARGS, |
| "Interface property %s value too large", |
| property_desc->dbus_property); |
| return FALSE; |
| } |
| |
| if (!new_value[0]) |
| new_value = "NULL"; |
| |
| ret = os_snprintf(buf, combined_len, "%s=%s", property_desc->data, |
| new_value); |
| if (os_snprintf_error(combined_len, ret)) { |
| dbus_set_error(error, WPAS_DBUS_ERROR_UNKNOWN_ERROR, |
| "Failed to construct new interface property %s", |
| property_desc->dbus_property); |
| return FALSE; |
| } |
| |
| ret = wpa_config_process_global(wpa_s->conf, buf, -1); |
| if (ret < 0) { |
| dbus_set_error(error, DBUS_ERROR_INVALID_ARGS, |
| "Failed to set interface property %s", |
| property_desc->dbus_property); |
| return FALSE; |
| } else if (ret == 0) { |
| wpa_supplicant_update_config(wpa_s); |
| } |
| return TRUE; |
| } |
| |
| |
| /** |
| * wpas_dbus_getter_stas - Get connected stations for an interface |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: a list of stations |
| * |
| * Getter for "Stations" property. |
| */ |
| dbus_bool_t wpas_dbus_getter_stas( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct wpa_supplicant *wpa_s = user_data; |
| struct sta_info *sta = NULL; |
| char **paths = NULL; |
| unsigned int i = 0, num = 0; |
| dbus_bool_t success = FALSE; |
| |
| if (!wpa_s->dbus_new_path) { |
| dbus_set_error(error, DBUS_ERROR_FAILED, |
| "%s: no D-Bus interface", __func__); |
| return FALSE; |
| } |
| |
| #ifdef CONFIG_AP |
| if (wpa_s->ap_iface) { |
| struct hostapd_data *hapd; |
| |
| hapd = wpa_s->ap_iface->bss[0]; |
| sta = hapd->sta_list; |
| num = hapd->num_sta; |
| } |
| #endif /* CONFIG_AP */ |
| |
| paths = os_calloc(num, sizeof(char *)); |
| if (!paths) { |
| dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory"); |
| return FALSE; |
| } |
| |
| /* Loop through scan results and append each result's object path */ |
| for (; sta; sta = sta->next) { |
| paths[i] = os_zalloc(WPAS_DBUS_OBJECT_PATH_MAX); |
| if (!paths[i]) { |
| dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, |
| "no memory"); |
| goto out; |
| } |
| /* Construct the object path for this BSS. */ |
| os_snprintf(paths[i++], WPAS_DBUS_OBJECT_PATH_MAX, |
| "%s/" WPAS_DBUS_NEW_STAS_PART "/" COMPACT_MACSTR, |
| wpa_s->dbus_new_path, MAC2STR(sta->addr)); |
| } |
| |
| success = wpas_dbus_simple_array_property_getter(iter, |
| DBUS_TYPE_OBJECT_PATH, |
| paths, num, |
| error); |
| |
| out: |
| while (i) |
| os_free(paths[--i]); |
| os_free(paths); |
| return success; |
| } |
| |
| |
| /** |
| * wpas_dbus_setter_mac_address_randomization_mask - Set masks used for |
| * MAC address randomization |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Setter for "MACAddressRandomizationMask" property. |
| */ |
| dbus_bool_t wpas_dbus_setter_mac_address_randomization_mask( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct wpa_supplicant *wpa_s = user_data; |
| DBusMessageIter variant_iter, dict_iter, entry_iter, array_iter; |
| const char *key; |
| unsigned int rand_type = 0; |
| const u8 *mask; |
| int mask_len; |
| unsigned int rand_types_to_disable = MAC_ADDR_RAND_ALL; |
| |
| dbus_message_iter_recurse(iter, &variant_iter); |
| if (dbus_message_iter_get_arg_type(&variant_iter) != DBUS_TYPE_ARRAY) { |
| dbus_set_error_const(error, DBUS_ERROR_INVALID_ARGS, |
| "invalid message format"); |
| return FALSE; |
| } |
| dbus_message_iter_recurse(&variant_iter, &dict_iter); |
| while (dbus_message_iter_get_arg_type(&dict_iter) == |
| DBUS_TYPE_DICT_ENTRY) { |
| dbus_message_iter_recurse(&dict_iter, &entry_iter); |
| if (dbus_message_iter_get_arg_type(&entry_iter) != |
| DBUS_TYPE_STRING) { |
| dbus_set_error(error, DBUS_ERROR_FAILED, |
| "%s: key not a string", __func__); |
| return FALSE; |
| } |
| dbus_message_iter_get_basic(&entry_iter, &key); |
| dbus_message_iter_next(&entry_iter); |
| if (dbus_message_iter_get_arg_type(&entry_iter) != |
| DBUS_TYPE_ARRAY || |
| dbus_message_iter_get_element_type(&entry_iter) != |
| DBUS_TYPE_BYTE) { |
| dbus_set_error(error, DBUS_ERROR_FAILED, |
| "%s: mask was not a byte array", |
| __func__); |
| return FALSE; |
| } |
| dbus_message_iter_recurse(&entry_iter, &array_iter); |
| dbus_message_iter_get_fixed_array(&array_iter, &mask, |
| &mask_len); |
| |
| if (os_strcmp(key, "scan") == 0) { |
| rand_type = MAC_ADDR_RAND_SCAN; |
| } else if (os_strcmp(key, "sched_scan") == 0) { |
| rand_type = MAC_ADDR_RAND_SCHED_SCAN; |
| } else if (os_strcmp(key, "pno") == 0) { |
| rand_type = MAC_ADDR_RAND_PNO; |
| } else { |
| dbus_set_error(error, DBUS_ERROR_FAILED, |
| "%s: bad scan type \"%s\"", |
| __func__, key); |
| return FALSE; |
| } |
| |
| if (mask_len != ETH_ALEN) { |
| dbus_set_error(error, DBUS_ERROR_FAILED, |
| "%s: malformed MAC mask given", |
| __func__); |
| return FALSE; |
| } |
| |
| if (wpas_enable_mac_addr_randomization( |
| wpa_s, rand_type, wpa_s->perm_addr, mask)) { |
| dbus_set_error(error, DBUS_ERROR_FAILED, |
| "%s: failed to set up MAC address randomization for %s", |
| __func__, key); |
| return FALSE; |
| } |
| |
| wpa_printf(MSG_DEBUG, |
| "%s: Enabled MAC address randomization for %s with mask: " |
| MACSTR, wpa_s->ifname, key, MAC2STR(mask)); |
| rand_types_to_disable &= ~rand_type; |
| dbus_message_iter_next(&dict_iter); |
| } |
| |
| if (rand_types_to_disable && |
| wpas_disable_mac_addr_randomization(wpa_s, rand_types_to_disable)) { |
| dbus_set_error(error, DBUS_ERROR_FAILED, |
| "%s: failed to disable MAC address randomization", |
| __func__); |
| return FALSE; |
| } |
| |
| return TRUE; |
| } |
| |
| |
| dbus_bool_t wpas_dbus_getter_mac_address_randomization_mask( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct wpa_supplicant *wpa_s = user_data; |
| DBusMessageIter variant_iter, dict_iter, entry_iter, array_iter; |
| unsigned int i; |
| u8 mask_buf[ETH_ALEN]; |
| /* Read docs on dbus_message_iter_append_fixed_array() for why this |
| * is necessary... */ |
| u8 *mask = mask_buf; |
| static const struct { |
| const char *key; |
| unsigned int type; |
| } types[] = { |
| { "scan", MAC_ADDR_RAND_SCAN }, |
| { "sched_scan", MAC_ADDR_RAND_SCHED_SCAN }, |
| { "pno", MAC_ADDR_RAND_PNO } |
| }; |
| |
| if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT, |
| "a{say}", &variant_iter) || |
| !dbus_message_iter_open_container(&variant_iter, DBUS_TYPE_ARRAY, |
| "{say}", &dict_iter)) { |
| dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory"); |
| return FALSE; |
| } |
| |
| for (i = 0; i < ARRAY_SIZE(types); i++) { |
| if (wpas_mac_addr_rand_scan_get_mask(wpa_s, types[i].type, |
| mask)) |
| continue; |
| |
| if (!dbus_message_iter_open_container(&dict_iter, |
| DBUS_TYPE_DICT_ENTRY, |
| NULL, &entry_iter) || |
| !dbus_message_iter_append_basic(&entry_iter, |
| DBUS_TYPE_STRING, |
| &types[i].key) || |
| !dbus_message_iter_open_container(&entry_iter, |
| DBUS_TYPE_ARRAY, |
| DBUS_TYPE_BYTE_AS_STRING, |
| &array_iter) || |
| !dbus_message_iter_append_fixed_array(&array_iter, |
| DBUS_TYPE_BYTE, |
| &mask, |
| ETH_ALEN) || |
| !dbus_message_iter_close_container(&entry_iter, |
| &array_iter) || |
| !dbus_message_iter_close_container(&dict_iter, |
| &entry_iter)) { |
| dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, |
| "no memory"); |
| return FALSE; |
| } |
| } |
| |
| if (!dbus_message_iter_close_container(&variant_iter, &dict_iter) || |
| !dbus_message_iter_close_container(iter, &variant_iter)) { |
| dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory"); |
| return FALSE; |
| } |
| |
| return TRUE; |
| } |
| |
| |
| /** |
| * wpas_dbus_getter_sta_address - Return the address of a connected station |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Getter for "Address" property. |
| */ |
| dbus_bool_t wpas_dbus_getter_sta_address( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| #ifdef CONFIG_AP |
| struct sta_handler_args *args = user_data; |
| struct sta_info *sta; |
| |
| sta = ap_get_sta(args->wpa_s->ap_iface->bss[0], args->sta); |
| if (!sta) |
| return FALSE; |
| |
| return wpas_dbus_simple_array_property_getter(iter, DBUS_TYPE_BYTE, |
| sta->addr, ETH_ALEN, |
| error); |
| #else /* CONFIG_AP */ |
| return FALSE; |
| #endif /* CONFIG_AP */ |
| } |
| |
| |
| /** |
| * wpas_dbus_getter_sta_aid - Return the AID of a connected station |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Getter for "AID" property. |
| */ |
| dbus_bool_t wpas_dbus_getter_sta_aid( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| #ifdef CONFIG_AP |
| struct sta_handler_args *args = user_data; |
| struct sta_info *sta; |
| |
| sta = ap_get_sta(args->wpa_s->ap_iface->bss[0], args->sta); |
| if (!sta) |
| return FALSE; |
| |
| return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_UINT16, |
| &sta->aid, |
| error); |
| #else /* CONFIG_AP */ |
| return FALSE; |
| #endif /* CONFIG_AP */ |
| } |
| |
| |
| /** |
| * wpas_dbus_getter_sta_caps - Return the capabilities of a station |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Getter for "Capabilities" property. |
| */ |
| dbus_bool_t wpas_dbus_getter_sta_caps( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| #ifdef CONFIG_AP |
| struct sta_handler_args *args = user_data; |
| struct sta_info *sta; |
| |
| sta = ap_get_sta(args->wpa_s->ap_iface->bss[0], args->sta); |
| if (!sta) |
| return FALSE; |
| |
| return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_UINT16, |
| &sta->capability, |
| error); |
| #else /* CONFIG_AP */ |
| return FALSE; |
| #endif /* CONFIG_AP */ |
| } |
| |
| |
| /** |
| * wpas_dbus_getter_rx_packets - Return the received packets for a station |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Getter for "RxPackets" property. |
| */ |
| dbus_bool_t wpas_dbus_getter_sta_rx_packets( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| #ifdef CONFIG_AP |
| struct sta_handler_args *args = user_data; |
| struct sta_info *sta; |
| struct hostap_sta_driver_data data; |
| struct hostapd_data *hapd; |
| |
| if (!args->wpa_s->ap_iface) |
| return FALSE; |
| |
| hapd = args->wpa_s->ap_iface->bss[0]; |
| sta = ap_get_sta(hapd, args->sta); |
| if (!sta) |
| return FALSE; |
| |
| if (hostapd_drv_read_sta_data(hapd, &data, sta->addr) < 0) |
| return FALSE; |
| |
| return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_UINT64, |
| &data.rx_packets, |
| error); |
| #else /* CONFIG_AP */ |
| return FALSE; |
| #endif /* CONFIG_AP */ |
| } |
| |
| |
| /** |
| * wpas_dbus_getter_tx_packets - Return the transmitted packets for a station |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Getter for "TxPackets" property. |
| */ |
| dbus_bool_t wpas_dbus_getter_sta_tx_packets( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| #ifdef CONFIG_AP |
| struct sta_handler_args *args = user_data; |
| struct sta_info *sta; |
| struct hostap_sta_driver_data data; |
| struct hostapd_data *hapd; |
| |
| if (!args->wpa_s->ap_iface) |
| return FALSE; |
| |
| hapd = args->wpa_s->ap_iface->bss[0]; |
| sta = ap_get_sta(hapd, args->sta); |
| if (!sta) |
| return FALSE; |
| |
| if (hostapd_drv_read_sta_data(hapd, &data, sta->addr) < 0) |
| return FALSE; |
| |
| return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_UINT64, |
| &data.tx_packets, |
| error); |
| #else /* CONFIG_AP */ |
| return FALSE; |
| #endif /* CONFIG_AP */ |
| } |
| |
| |
| /** |
| * wpas_dbus_getter_tx_bytes - Return the transmitted bytes for a station |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Getter for "TxBytes" property. |
| */ |
| dbus_bool_t wpas_dbus_getter_sta_tx_bytes( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| #ifdef CONFIG_AP |
| struct sta_handler_args *args = user_data; |
| struct sta_info *sta; |
| struct hostap_sta_driver_data data; |
| struct hostapd_data *hapd; |
| |
| if (!args->wpa_s->ap_iface) |
| return FALSE; |
| |
| hapd = args->wpa_s->ap_iface->bss[0]; |
| sta = ap_get_sta(hapd, args->sta); |
| if (!sta) |
| return FALSE; |
| |
| if (hostapd_drv_read_sta_data(hapd, &data, sta->addr) < 0) |
| return FALSE; |
| |
| return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_UINT64, |
| &data.tx_bytes, |
| error); |
| #else /* CONFIG_AP */ |
| return FALSE; |
| #endif /* CONFIG_AP */ |
| } |
| |
| |
| /** |
| * wpas_dbus_getter_rx_bytes - Return the received bytes for a station |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Getter for "RxBytes" property. |
| */ |
| dbus_bool_t wpas_dbus_getter_sta_rx_bytes( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| #ifdef CONFIG_AP |
| struct sta_handler_args *args = user_data; |
| struct sta_info *sta; |
| struct hostap_sta_driver_data data; |
| struct hostapd_data *hapd; |
| |
| if (!args->wpa_s->ap_iface) |
| return FALSE; |
| |
| hapd = args->wpa_s->ap_iface->bss[0]; |
| sta = ap_get_sta(hapd, args->sta); |
| if (!sta) |
| return FALSE; |
| |
| if (hostapd_drv_read_sta_data(hapd, &data, sta->addr) < 0) |
| return FALSE; |
| |
| return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_UINT64, |
| &data.rx_bytes, |
| error); |
| #else /* CONFIG_AP */ |
| return FALSE; |
| #endif /* CONFIG_AP */ |
| } |
| |
| |
| static struct wpa_bss * get_bss_helper(struct bss_handler_args *args, |
| DBusError *error, const char *func_name) |
| { |
| struct wpa_bss *res = wpa_bss_get_id(args->wpa_s, args->id); |
| |
| if (!res) { |
| wpa_printf(MSG_ERROR, "%s[dbus]: no bss with id %d found", |
| func_name, args->id); |
| dbus_set_error(error, DBUS_ERROR_FAILED, |
| "%s: BSS %d not found", |
| func_name, args->id); |
| } |
| |
| return res; |
| } |
| |
| |
| /** |
| * wpas_dbus_getter_bss_bssid - Return the BSSID of a BSS |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Getter for "BSSID" property. |
| */ |
| dbus_bool_t wpas_dbus_getter_bss_bssid( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct bss_handler_args *args = user_data; |
| struct wpa_bss *res; |
| |
| res = get_bss_helper(args, error, __func__); |
| if (!res) |
| return FALSE; |
| |
| return wpas_dbus_simple_array_property_getter(iter, DBUS_TYPE_BYTE, |
| res->bssid, ETH_ALEN, |
| error); |
| } |
| |
| |
| /** |
| * wpas_dbus_getter_bss_ssid - Return the SSID of a BSS |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Getter for "SSID" property. |
| */ |
| dbus_bool_t wpas_dbus_getter_bss_ssid( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct bss_handler_args *args = user_data; |
| struct wpa_bss *res; |
| |
| res = get_bss_helper(args, error, __func__); |
| if (!res) |
| return FALSE; |
| |
| return wpas_dbus_simple_array_property_getter(iter, DBUS_TYPE_BYTE, |
| res->ssid, res->ssid_len, |
| error); |
| } |
| |
| |
| /** |
| * wpas_dbus_getter_bss_privacy - Return the privacy flag of a BSS |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Getter for "Privacy" property. |
| */ |
| dbus_bool_t wpas_dbus_getter_bss_privacy( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct bss_handler_args *args = user_data; |
| struct wpa_bss *res; |
| dbus_bool_t privacy; |
| |
| res = get_bss_helper(args, error, __func__); |
| if (!res) |
| return FALSE; |
| |
| privacy = (res->caps & IEEE80211_CAP_PRIVACY) ? TRUE : FALSE; |
| return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_BOOLEAN, |
| &privacy, error); |
| } |
| |
| |
| /** |
| * wpas_dbus_getter_bss_mode - Return the mode of a BSS |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Getter for "Mode" property. |
| */ |
| dbus_bool_t wpas_dbus_getter_bss_mode( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct bss_handler_args *args = user_data; |
| struct wpa_bss *res; |
| const char *mode; |
| const u8 *mesh; |
| |
| res = get_bss_helper(args, error, __func__); |
| if (!res) |
| return FALSE; |
| if (bss_is_dmg(res)) { |
| switch (res->caps & IEEE80211_CAP_DMG_MASK) { |
| case IEEE80211_CAP_DMG_PBSS: |
| case IEEE80211_CAP_DMG_IBSS: |
| mode = "ad-hoc"; |
| break; |
| case IEEE80211_CAP_DMG_AP: |
| mode = "infrastructure"; |
| break; |
| default: |
| mode = ""; |
| break; |
| } |
| } else { |
| mesh = wpa_bss_get_ie(res, WLAN_EID_MESH_ID); |
| if (mesh) |
| mode = "mesh"; |
| else if (res->caps & IEEE80211_CAP_IBSS) |
| mode = "ad-hoc"; |
| else |
| mode = "infrastructure"; |
| } |
| |
| return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING, |
| &mode, error); |
| } |
| |
| |
| /** |
| * wpas_dbus_getter_bss_level - Return the signal strength of a BSS |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Getter for "Level" property. |
| */ |
| dbus_bool_t wpas_dbus_getter_bss_signal( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct bss_handler_args *args = user_data; |
| struct wpa_bss *res; |
| s16 level; |
| |
| res = get_bss_helper(args, error, __func__); |
| if (!res) |
| return FALSE; |
| |
| level = (s16) res->level; |
| return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_INT16, |
| &level, error); |
| } |
| |
| |
| /** |
| * wpas_dbus_getter_bss_frequency - Return the frequency of a BSS |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Getter for "Frequency" property. |
| */ |
| dbus_bool_t wpas_dbus_getter_bss_frequency( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct bss_handler_args *args = user_data; |
| struct wpa_bss *res; |
| u16 freq; |
| |
| res = get_bss_helper(args, error, __func__); |
| if (!res) |
| return FALSE; |
| |
| freq = (u16) res->freq; |
| return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_UINT16, |
| &freq, error); |
| } |
| |
| |
| static int cmp_u8s_desc(const void *a, const void *b) |
| { |
| return (*(u8 *) b - *(u8 *) a); |
| } |
| |
| |
| /** |
| * wpas_dbus_getter_bss_rates - Return available bit rates of a BSS |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Getter for "Rates" property. |
| */ |
| dbus_bool_t wpas_dbus_getter_bss_rates( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct bss_handler_args *args = user_data; |
| struct wpa_bss *res; |
| u8 *ie_rates = NULL; |
| u32 *real_rates; |
| int rates_num, i; |
| dbus_bool_t success = FALSE; |
| |
| res = get_bss_helper(args, error, __func__); |
| if (!res) |
| return FALSE; |
| |
| rates_num = wpa_bss_get_bit_rates(res, &ie_rates); |
| if (rates_num < 0) |
| return FALSE; |
| |
| qsort(ie_rates, rates_num, 1, cmp_u8s_desc); |
| |
| real_rates = os_malloc(sizeof(u32) * rates_num); |
| if (!real_rates) { |
| os_free(ie_rates); |
| dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory"); |
| return FALSE; |
| } |
| |
| for (i = 0; i < rates_num; i++) |
| real_rates[i] = ie_rates[i] * 500000; |
| |
| success = wpas_dbus_simple_array_property_getter(iter, DBUS_TYPE_UINT32, |
| real_rates, rates_num, |
| error); |
| |
| os_free(ie_rates); |
| os_free(real_rates); |
| return success; |
| } |
| |
| |
| static dbus_bool_t wpas_dbus_get_bss_security_prop( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, struct wpa_ie_data *ie_data, DBusError *error) |
| { |
| DBusMessageIter iter_dict, variant_iter; |
| const char *group; |
| const char *pairwise[5]; /* max 5 pairwise ciphers is supported */ |
| const char *key_mgmt[16]; /* max 16 key managements may be supported */ |
| int n; |
| |
| if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT, |
| "a{sv}", &variant_iter)) |
| goto nomem; |
| |
| if (!wpa_dbus_dict_open_write(&variant_iter, &iter_dict)) |
| goto nomem; |
| |
| /* |
| * KeyMgmt |
| * |
| * When adding a new entry here, please take care to extend key_mgmt[] |
| * and keep documentation in doc/dbus.doxygen up to date. |
| */ |
| n = 0; |
| if (ie_data->key_mgmt & WPA_KEY_MGMT_PSK) |
| key_mgmt[n++] = "wpa-psk"; |
| if (ie_data->key_mgmt & WPA_KEY_MGMT_FT_PSK) |
| key_mgmt[n++] = "wpa-ft-psk"; |
| if (ie_data->key_mgmt & WPA_KEY_MGMT_PSK_SHA256) |
| key_mgmt[n++] = "wpa-psk-sha256"; |
| if (ie_data->key_mgmt & WPA_KEY_MGMT_IEEE8021X) |
| key_mgmt[n++] = "wpa-eap"; |
| if (ie_data->key_mgmt & WPA_KEY_MGMT_FT_IEEE8021X) |
| key_mgmt[n++] = "wpa-ft-eap"; |
| if (ie_data->key_mgmt & WPA_KEY_MGMT_IEEE8021X_SHA256) |
| key_mgmt[n++] = "wpa-eap-sha256"; |
| #ifdef CONFIG_SUITEB |
| if (ie_data->key_mgmt & WPA_KEY_MGMT_IEEE8021X_SUITE_B) |
| key_mgmt[n++] = "wpa-eap-suite-b"; |
| #endif /* CONFIG_SUITEB */ |
| #ifdef CONFIG_SUITEB192 |
| if (ie_data->key_mgmt & WPA_KEY_MGMT_IEEE8021X_SUITE_B_192) |
| key_mgmt[n++] = "wpa-eap-suite-b-192"; |
| #endif /* CONFIG_SUITEB192 */ |
| #ifdef CONFIG_FILS |
| if (ie_data->key_mgmt & WPA_KEY_MGMT_FILS_SHA256) |
| key_mgmt[n++] = "wpa-fils-sha256"; |
| if (ie_data->key_mgmt & WPA_KEY_MGMT_FILS_SHA384) |
| key_mgmt[n++] = "wpa-fils-sha384"; |
| if (ie_data->key_mgmt & WPA_KEY_MGMT_FT_FILS_SHA256) |
| key_mgmt[n++] = "wpa-ft-fils-sha256"; |
| if (ie_data->key_mgmt & WPA_KEY_MGMT_FT_FILS_SHA384) |
| key_mgmt[n++] = "wpa-ft-fils-sha384"; |
| #endif /* CONFIG_FILS */ |
| #ifdef CONFIG_SAE |
| if (ie_data->key_mgmt & WPA_KEY_MGMT_SAE) |
| key_mgmt[n++] = "sae"; |
| if (ie_data->key_mgmt & WPA_KEY_MGMT_FT_SAE) |
| key_mgmt[n++] = "ft-sae"; |
| #endif /* CONFIG_SAE */ |
| #ifdef CONFIG_OWE |
| if (ie_data->key_mgmt & WPA_KEY_MGMT_OWE) |
| key_mgmt[n++] = "owe"; |
| #endif /* CONFIG_OWE */ |
| if (ie_data->key_mgmt & WPA_KEY_MGMT_NONE) |
| key_mgmt[n++] = "wpa-none"; |
| |
| if (!wpa_dbus_dict_append_string_array(&iter_dict, "KeyMgmt", |
| key_mgmt, n)) |
| goto nomem; |
| |
| /* Group */ |
| switch (ie_data->group_cipher) { |
| #ifdef CONFIG_WEP |
| case WPA_CIPHER_WEP40: |
| group = "wep40"; |
| break; |
| case WPA_CIPHER_WEP104: |
| group = "wep104"; |
| break; |
| #endif /* CONFIG_WEP */ |
| #ifndef CONFIG_NO_TKIP |
| case WPA_CIPHER_TKIP: |
| group = "tkip"; |
| break; |
| #endif /* CONFIG_NO_TKIP */ |
| case WPA_CIPHER_CCMP: |
| group = "ccmp"; |
| break; |
| case WPA_CIPHER_GCMP: |
| group = "gcmp"; |
| break; |
| case WPA_CIPHER_CCMP_256: |
| group = "ccmp-256"; |
| break; |
| case WPA_CIPHER_GCMP_256: |
| group = "gcmp-256"; |
| break; |
| default: |
| group = ""; |
| break; |
| } |
| |
| if (!wpa_dbus_dict_append_string(&iter_dict, "Group", group)) |
| goto nomem; |
| |
| /* Pairwise */ |
| n = 0; |
| #ifndef CONFIG_NO_TKIP |
| if (ie_data->pairwise_cipher & WPA_CIPHER_TKIP) |
| pairwise[n++] = "tkip"; |
| #endif /* CONFIG_NO_TKIP */ |
| if (ie_data->pairwise_cipher & WPA_CIPHER_CCMP) |
| pairwise[n++] = "ccmp"; |
| if (ie_data->pairwise_cipher & WPA_CIPHER_GCMP) |
| pairwise[n++] = "gcmp"; |
| if (ie_data->pairwise_cipher & WPA_CIPHER_CCMP_256) |
| pairwise[n++] = "ccmp-256"; |
| if (ie_data->pairwise_cipher & WPA_CIPHER_GCMP_256) |
| pairwise[n++] = "gcmp-256"; |
| |
| if (!wpa_dbus_dict_append_string_array(&iter_dict, "Pairwise", |
| pairwise, n)) |
| goto nomem; |
| |
| /* Management group (RSN only) */ |
| if (ie_data->proto == WPA_PROTO_RSN) { |
| switch (ie_data->mgmt_group_cipher) { |
| case WPA_CIPHER_AES_128_CMAC: |
| group = "aes128cmac"; |
| break; |
| default: |
| group = ""; |
| break; |
| } |
| |
| if (!wpa_dbus_dict_append_string(&iter_dict, "MgmtGroup", |
| group)) |
| goto nomem; |
| } |
| |
| if (!wpa_dbus_dict_close_write(&variant_iter, &iter_dict) || |
| !dbus_message_iter_close_container(iter, &variant_iter)) |
| goto nomem; |
| |
| return TRUE; |
| |
| nomem: |
| dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory"); |
| return FALSE; |
| } |
| |
| |
| /** |
| * wpas_dbus_getter_bss_wpa - Return the WPA options of a BSS |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Getter for "WPA" property. |
| */ |
| dbus_bool_t wpas_dbus_getter_bss_wpa( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct bss_handler_args *args = user_data; |
| struct wpa_bss *res; |
| struct wpa_ie_data wpa_data; |
| const u8 *ie; |
| |
| res = get_bss_helper(args, error, __func__); |
| if (!res) |
| return FALSE; |
| |
| os_memset(&wpa_data, 0, sizeof(wpa_data)); |
| ie = wpa_bss_get_vendor_ie(res, WPA_IE_VENDOR_TYPE); |
| if (ie && wpa_parse_wpa_ie(ie, 2 + ie[1], &wpa_data) < 0) { |
| dbus_set_error_const(error, DBUS_ERROR_FAILED, |
| "failed to parse WPA IE"); |
| return FALSE; |
| } |
| |
| return wpas_dbus_get_bss_security_prop(property_desc, iter, &wpa_data, error); |
| } |
| |
| |
| /** |
| * wpas_dbus_getter_bss_rsn - Return the RSN options of a BSS |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Getter for "RSN" property. |
| */ |
| dbus_bool_t wpas_dbus_getter_bss_rsn( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct bss_handler_args *args = user_data; |
| struct wpa_bss *res; |
| struct wpa_ie_data wpa_data; |
| const u8 *ie; |
| |
| res = get_bss_helper(args, error, __func__); |
| if (!res) |
| return FALSE; |
| |
| os_memset(&wpa_data, 0, sizeof(wpa_data)); |
| ie = wpa_bss_get_ie(res, WLAN_EID_RSN); |
| if (ie && wpa_parse_wpa_ie(ie, 2 + ie[1], &wpa_data) < 0) { |
| dbus_set_error_const(error, DBUS_ERROR_FAILED, |
| "failed to parse RSN IE"); |
| return FALSE; |
| } |
| |
| return wpas_dbus_get_bss_security_prop(property_desc, iter, &wpa_data, error); |
| } |
| |
| |
| /** |
| * wpas_dbus_getter_bss_wps - Return the WPS options of a BSS |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Getter for "WPS" property. |
| */ |
| dbus_bool_t wpas_dbus_getter_bss_wps( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct bss_handler_args *args = user_data; |
| struct wpa_bss *res; |
| #ifdef CONFIG_WPS |
| struct wpabuf *wps_ie; |
| #endif /* CONFIG_WPS */ |
| DBusMessageIter iter_dict, variant_iter; |
| int wps_support = 0; |
| const char *type = ""; |
| |
| res = get_bss_helper(args, error, __func__); |
| if (!res) |
| return FALSE; |
| |
| if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT, |
| "a{sv}", &variant_iter) || |
| !wpa_dbus_dict_open_write(&variant_iter, &iter_dict)) |
| goto nomem; |
| |
| #ifdef CONFIG_WPS |
| wps_ie = wpa_bss_get_vendor_ie_multi(res, WPS_IE_VENDOR_TYPE); |
| if (wps_ie) { |
| wps_support = 1; |
| if (wps_is_selected_pbc_registrar(wps_ie)) |
| type = "pbc"; |
| else if (wps_is_selected_pin_registrar(wps_ie)) |
| type = "pin"; |
| |
| wpabuf_free(wps_ie); |
| } |
| #endif /* CONFIG_WPS */ |
| |
| if ((wps_support && !wpa_dbus_dict_append_string(&iter_dict, "Type", type)) || |
| !wpa_dbus_dict_close_write(&variant_iter, &iter_dict) || |
| !dbus_message_iter_close_container(iter, &variant_iter)) |
| goto nomem; |
| |
| return TRUE; |
| |
| nomem: |
| dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory"); |
| return FALSE; |
| } |
| |
| |
| /** |
| * wpas_dbus_getter_bss_ies - Return all IEs of a BSS |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Getter for "IEs" property. |
| */ |
| dbus_bool_t wpas_dbus_getter_bss_ies( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct bss_handler_args *args = user_data; |
| struct wpa_bss *res; |
| |
| res = get_bss_helper(args, error, __func__); |
| if (!res) |
| return FALSE; |
| |
| return wpas_dbus_simple_array_property_getter(iter, DBUS_TYPE_BYTE, |
| wpa_bss_ie_ptr(res), |
| res->ie_len, error); |
| } |
| |
| |
| /** |
| * wpas_dbus_getter_bss_age - Return time in seconds since BSS was last seen |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Getter for BSS age |
| */ |
| dbus_bool_t wpas_dbus_getter_bss_age( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct bss_handler_args *args = user_data; |
| struct wpa_bss *res; |
| struct os_reltime now, diff = { 0, 0 }; |
| u32 age; |
| |
| res = get_bss_helper(args, error, __func__); |
| if (!res) |
| return FALSE; |
| |
| os_get_reltime(&now); |
| os_reltime_sub(&now, &res->last_update, &diff); |
| age = diff.sec > 0 ? diff.sec : 0; |
| return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_UINT32, &age, |
| error); |
| } |
| |
| |
| /** |
| * wpas_dbus_getter_enabled - Check whether network is enabled or disabled |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Getter for "enabled" property of a configured network. |
| */ |
| dbus_bool_t wpas_dbus_getter_enabled( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct network_handler_args *net = user_data; |
| dbus_bool_t enabled = net->ssid->disabled ? FALSE : TRUE; |
| |
| return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_BOOLEAN, |
| &enabled, error); |
| } |
| |
| |
| /** |
| * wpas_dbus_setter_enabled - Mark a configured network as enabled or disabled |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Setter for "Enabled" property of a configured network. |
| */ |
| dbus_bool_t wpas_dbus_setter_enabled( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct network_handler_args *net = user_data; |
| struct wpa_supplicant *wpa_s; |
| struct wpa_ssid *ssid; |
| dbus_bool_t enable; |
| |
| if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_BOOLEAN, |
| &enable)) |
| return FALSE; |
| |
| wpa_s = net->wpa_s; |
| ssid = net->ssid; |
| |
| if (enable) |
| wpa_supplicant_enable_network(wpa_s, ssid); |
| else |
| wpa_supplicant_disable_network(wpa_s, ssid); |
| |
| return TRUE; |
| } |
| |
| |
| /** |
| * wpas_dbus_getter_network_properties - Get options for a configured network |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Getter for "Properties" property of a configured network. |
| */ |
| dbus_bool_t wpas_dbus_getter_network_properties( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct network_handler_args *net = user_data; |
| DBusMessageIter variant_iter, dict_iter; |
| char **iterator; |
| char **props = wpa_config_get_all(net->ssid, 1); |
| dbus_bool_t success = FALSE; |
| |
| if (!props) { |
| dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory"); |
| return FALSE; |
| } |
| |
| if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT, "a{sv}", |
| &variant_iter) || |
| !wpa_dbus_dict_open_write(&variant_iter, &dict_iter)) { |
| dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory"); |
| goto out; |
| } |
| |
| iterator = props; |
| while (*iterator) { |
| if (!wpa_dbus_dict_append_string(&dict_iter, *iterator, |
| *(iterator + 1))) { |
| dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, |
| "no memory"); |
| goto out; |
| } |
| iterator += 2; |
| } |
| |
| |
| if (!wpa_dbus_dict_close_write(&variant_iter, &dict_iter) || |
| !dbus_message_iter_close_container(iter, &variant_iter)) { |
| dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory"); |
| goto out; |
| } |
| |
| success = TRUE; |
| |
| out: |
| iterator = props; |
| while (*iterator) { |
| os_free(*iterator); |
| iterator++; |
| } |
| os_free(props); |
| return success; |
| } |
| |
| |
| /** |
| * wpas_dbus_setter_network_properties - Set options for a configured network |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Setter for "Properties" property of a configured network. |
| */ |
| dbus_bool_t wpas_dbus_setter_network_properties( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct network_handler_args *net = user_data; |
| struct wpa_ssid *ssid = net->ssid; |
| DBusMessageIter variant_iter; |
| |
| dbus_message_iter_recurse(iter, &variant_iter); |
| return set_network_properties(net->wpa_s, ssid, &variant_iter, error); |
| } |
| |
| |
| #ifdef CONFIG_AP |
| |
| DBusMessage * wpas_dbus_handler_subscribe_preq( |
| DBusMessage *message, struct wpa_supplicant *wpa_s) |
| { |
| struct wpas_dbus_priv *priv = wpa_s->global->dbus; |
| char *name; |
| |
| if (wpa_s->preq_notify_peer != NULL) { |
| if (os_strcmp(dbus_message_get_sender(message), |
| wpa_s->preq_notify_peer) == 0) |
| return NULL; |
| |
| return dbus_message_new_error(message, |
| WPAS_DBUS_ERROR_SUBSCRIPTION_IN_USE, |
| "Another application is already subscribed"); |
| } |
| |
| name = os_strdup(dbus_message_get_sender(message)); |
| if (!name) |
| return wpas_dbus_error_no_memory(message); |
| |
| wpa_s->preq_notify_peer = name; |
| |
| /* Subscribe to clean up if application closes socket */ |
| wpas_dbus_subscribe_noc(priv); |
| |
| /* |
| * Double-check it's still alive to make sure that we didn't |
| * miss the NameOwnerChanged signal, e.g. while strdup'ing. |
| */ |
| if (!dbus_bus_name_has_owner(priv->con, name, NULL)) { |
| /* |
| * Application no longer exists, clean up. |
| * The return value is irrelevant now. |
| * |
| * Need to check if the NameOwnerChanged handling |
| * already cleaned up because we have processed |
| * DBus messages while checking if the name still |
| * has an owner. |
| */ |
| if (!wpa_s->preq_notify_peer) |
| return NULL; |
| os_free(wpa_s->preq_notify_peer); |
| wpa_s->preq_notify_peer = NULL; |
| wpas_dbus_unsubscribe_noc(priv); |
| } |
| |
| return NULL; |
| } |
| |
| |
| DBusMessage * wpas_dbus_handler_unsubscribe_preq( |
| DBusMessage *message, struct wpa_supplicant *wpa_s) |
| { |
| struct wpas_dbus_priv *priv = wpa_s->global->dbus; |
| |
| if (!wpa_s->preq_notify_peer) |
| return dbus_message_new_error(message, |
| WPAS_DBUS_ERROR_NO_SUBSCRIPTION, |
| "Not subscribed"); |
| |
| if (os_strcmp(wpa_s->preq_notify_peer, |
| dbus_message_get_sender(message))) |
| return dbus_message_new_error(message, |
| WPAS_DBUS_ERROR_SUBSCRIPTION_EPERM, |
| "Can't unsubscribe others"); |
| |
| os_free(wpa_s->preq_notify_peer); |
| wpa_s->preq_notify_peer = NULL; |
| wpas_dbus_unsubscribe_noc(priv); |
| return NULL; |
| } |
| |
| |
| void wpas_dbus_signal_preq(struct wpa_supplicant *wpa_s, |
| const u8 *addr, const u8 *dst, const u8 *bssid, |
| const u8 *ie, size_t ie_len, u32 ssi_signal) |
| { |
| DBusMessage *msg; |
| DBusMessageIter iter, dict_iter; |
| struct wpas_dbus_priv *priv = wpa_s->global->dbus; |
| |
| /* Do nothing if the control interface is not turned on */ |
| if (priv == NULL || !wpa_s->dbus_new_path) |
| return; |
| |
| if (wpa_s->preq_notify_peer == NULL) |
| return; |
| |
| msg = dbus_message_new_signal(wpa_s->dbus_new_path, |
| WPAS_DBUS_NEW_IFACE_INTERFACE, |
| "ProbeRequest"); |
| if (msg == NULL) |
| return; |
| |
| dbus_message_set_destination(msg, wpa_s->preq_notify_peer); |
| |
| dbus_message_iter_init_append(msg, &iter); |
| |
| if (!wpa_dbus_dict_open_write(&iter, &dict_iter) || |
| (addr && !wpa_dbus_dict_append_byte_array(&dict_iter, "addr", |
| (const char *) addr, |
| ETH_ALEN)) || |
| (dst && !wpa_dbus_dict_append_byte_array(&dict_iter, "dst", |
| (const char *) dst, |
| ETH_ALEN)) || |
| (bssid && !wpa_dbus_dict_append_byte_array(&dict_iter, "bssid", |
| (const char *) bssid, |
| ETH_ALEN)) || |
| (ie && ie_len && !wpa_dbus_dict_append_byte_array(&dict_iter, "ies", |
| (const char *) ie, |
| ie_len)) || |
| (ssi_signal && !wpa_dbus_dict_append_int32(&dict_iter, "signal", |
| ssi_signal)) || |
| !wpa_dbus_dict_close_write(&iter, &dict_iter)) |
| goto fail; |
| |
| dbus_connection_send(priv->con, msg, NULL); |
| goto out; |
| fail: |
| wpa_printf(MSG_ERROR, "dbus: Failed to construct signal"); |
| out: |
| dbus_message_unref(msg); |
| } |
| |
| #endif /* CONFIG_AP */ |
| |
| |
| DBusMessage * wpas_dbus_handler_vendor_elem_add(DBusMessage *message, |
| struct wpa_supplicant *wpa_s) |
| { |
| u8 *ielems; |
| int len; |
| struct ieee802_11_elems elems; |
| dbus_int32_t frame_id; |
| DBusMessageIter iter, array; |
| |
| dbus_message_iter_init(message, &iter); |
| dbus_message_iter_get_basic(&iter, &frame_id); |
| if (frame_id < 0 || frame_id >= NUM_VENDOR_ELEM_FRAMES) { |
| return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS, |
| "Invalid ID"); |
| } |
| |
| dbus_message_iter_next(&iter); |
| dbus_message_iter_recurse(&iter, &array); |
| dbus_message_iter_get_fixed_array(&array, &ielems, &len); |
| if (!ielems || len == 0) { |
| return dbus_message_new_error( |
| message, DBUS_ERROR_INVALID_ARGS, "Invalid value"); |
| } |
| |
| if (ieee802_11_parse_elems(ielems, len, &elems, 0) == ParseFailed) { |
| return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS, |
| "Parse error"); |
| } |
| |
| wpa_s = wpas_vendor_elem(wpa_s, frame_id); |
| if (!wpa_s->vendor_elem[frame_id]) { |
| wpa_s->vendor_elem[frame_id] = wpabuf_alloc_copy(ielems, len); |
| wpas_vendor_elem_update(wpa_s); |
| return NULL; |
| } |
| |
| if (wpabuf_resize(&wpa_s->vendor_elem[frame_id], len) < 0) { |
| return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS, |
| "Resize error"); |
| } |
| |
| wpabuf_put_data(wpa_s->vendor_elem[frame_id], ielems, len); |
| wpas_vendor_elem_update(wpa_s); |
| return NULL; |
| } |
| |
| |
| DBusMessage * wpas_dbus_handler_vendor_elem_get(DBusMessage *message, |
| struct wpa_supplicant *wpa_s) |
| { |
| DBusMessage *reply; |
| DBusMessageIter iter, array_iter; |
| dbus_int32_t frame_id; |
| const u8 *elem; |
| size_t elem_len; |
| |
| dbus_message_iter_init(message, &iter); |
| dbus_message_iter_get_basic(&iter, &frame_id); |
| |
| if (frame_id < 0 || frame_id >= NUM_VENDOR_ELEM_FRAMES) { |
| return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS, |
| "Invalid ID"); |
| } |
| |
| wpa_s = wpas_vendor_elem(wpa_s, frame_id); |
| if (!wpa_s->vendor_elem[frame_id]) { |
| return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS, |
| "ID value does not exist"); |
| } |
| |
| reply = dbus_message_new_method_return(message); |
| if (!reply) |
| return wpas_dbus_error_no_memory(message); |
| |
| dbus_message_iter_init_append(reply, &iter); |
| |
| elem = wpabuf_head_u8(wpa_s->vendor_elem[frame_id]); |
| elem_len = wpabuf_len(wpa_s->vendor_elem[frame_id]); |
| |
| if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, |
| DBUS_TYPE_BYTE_AS_STRING, |
| &array_iter) || |
| !dbus_message_iter_append_fixed_array(&array_iter, DBUS_TYPE_BYTE, |
| &elem, elem_len) || |
| !dbus_message_iter_close_container(&iter, &array_iter)) { |
| dbus_message_unref(reply); |
| reply = wpas_dbus_error_no_memory(message); |
| } |
| |
| return reply; |
| } |
| |
| |
| DBusMessage * wpas_dbus_handler_vendor_elem_remove(DBusMessage *message, |
| struct wpa_supplicant *wpa_s) |
| { |
| u8 *ielems; |
| int len; |
| struct ieee802_11_elems elems; |
| DBusMessageIter iter, array; |
| dbus_int32_t frame_id; |
| |
| dbus_message_iter_init(message, &iter); |
| dbus_message_iter_get_basic(&iter, &frame_id); |
| if (frame_id < 0 || frame_id >= NUM_VENDOR_ELEM_FRAMES) { |
| return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS, |
| "Invalid ID"); |
| } |
| |
| dbus_message_iter_next(&iter); |
| dbus_message_iter_recurse(&iter, &array); |
| dbus_message_iter_get_fixed_array(&array, &ielems, &len); |
| if (!ielems || len == 0) { |
| return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS, |
| "Invalid value"); |
| } |
| |
| wpa_s = wpas_vendor_elem(wpa_s, frame_id); |
| |
| if (len == 1 && *ielems == '*') { |
| wpabuf_free(wpa_s->vendor_elem[frame_id]); |
| wpa_s->vendor_elem[frame_id] = NULL; |
| wpas_vendor_elem_update(wpa_s); |
| return NULL; |
| } |
| |
| if (!wpa_s->vendor_elem[frame_id]) { |
| return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS, |
| "ID value does not exist"); |
| } |
| |
| if (ieee802_11_parse_elems(ielems, len, &elems, 0) == ParseFailed) { |
| return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS, |
| "Parse error"); |
| } |
| |
| if (wpas_vendor_elem_remove(wpa_s, frame_id, ielems, len) == 0) |
| return NULL; |
| |
| return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS, |
| "Not found"); |
| } |
| |
| |
| #ifdef CONFIG_MESH |
| |
| /** |
| * wpas_dbus_getter_mesh_peers - Get connected mesh peers |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Getter for "MeshPeers" property. |
| */ |
| dbus_bool_t wpas_dbus_getter_mesh_peers( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct wpa_supplicant *wpa_s = user_data; |
| struct hostapd_data *hapd; |
| struct sta_info *sta; |
| DBusMessageIter variant_iter, array_iter; |
| int i; |
| DBusMessageIter inner_array_iter; |
| |
| if (!wpa_s->ifmsh) |
| return FALSE; |
| hapd = wpa_s->ifmsh->bss[0]; |
| |
| if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT, |
| DBUS_TYPE_ARRAY_AS_STRING |
| DBUS_TYPE_ARRAY_AS_STRING |
| DBUS_TYPE_BYTE_AS_STRING, |
| &variant_iter) || |
| !dbus_message_iter_open_container(&variant_iter, DBUS_TYPE_ARRAY, |
| DBUS_TYPE_ARRAY_AS_STRING |
| DBUS_TYPE_BYTE_AS_STRING, |
| &array_iter)) |
| return FALSE; |
| |
| for (sta = hapd->sta_list; sta; sta = sta->next) { |
| if (!dbus_message_iter_open_container( |
| &array_iter, DBUS_TYPE_ARRAY, |
| DBUS_TYPE_BYTE_AS_STRING, |
| &inner_array_iter)) |
| return FALSE; |
| |
| for (i = 0; i < ETH_ALEN; i++) { |
| if (!dbus_message_iter_append_basic(&inner_array_iter, |
| DBUS_TYPE_BYTE, |
| &(sta->addr[i]))) |
| return FALSE; |
| } |
| |
| if (!dbus_message_iter_close_container( |
| &array_iter, &inner_array_iter)) |
| return FALSE; |
| } |
| |
| if (!dbus_message_iter_close_container(&variant_iter, &array_iter) || |
| !dbus_message_iter_close_container(iter, &variant_iter)) |
| return FALSE; |
| |
| return TRUE; |
| } |
| |
| |
| /** |
| * wpas_dbus_getter_mesh_group - Get mesh group |
| * @iter: Pointer to incoming dbus message iter |
| * @error: Location to store error on failure |
| * @user_data: Function specific data |
| * Returns: TRUE on success, FALSE on failure |
| * |
| * Getter for "MeshGroup" property. |
| */ |
| dbus_bool_t wpas_dbus_getter_mesh_group( |
| const struct wpa_dbus_property_desc *property_desc, |
| DBusMessageIter *iter, DBusError *error, void *user_data) |
| { |
| struct wpa_supplicant *wpa_s = user_data; |
| struct wpa_ssid *ssid = wpa_s->current_ssid; |
| |
| if (!wpa_s->ifmsh || !ssid) |
| return FALSE; |
| |
| if (!wpas_dbus_simple_array_property_getter(iter, DBUS_TYPE_BYTE, |
| (char *) ssid->ssid, |
| ssid->ssid_len, error)) { |
| dbus_set_error(error, DBUS_ERROR_FAILED, |
| "%s: error constructing reply", __func__); |
| return FALSE; |
| } |
| |
| return TRUE; |
| } |
| |
| #endif /* CONFIG_MESH */ |