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