1 /*
2 * WPA Supplicant / dbus-based control interface
3 * Copyright (c) 2006, Dan Williams <dcbw@redhat.com> and Red Hat, Inc.
4 *
5 * This software may be distributed under the terms of the BSD license.
6 * See README for more details.
7 */
8
9 #include "includes.h"
10 #include <dbus/dbus.h>
11
12 #include "common.h"
13 #include "eap_peer/eap_methods.h"
14 #include "common/ieee802_11_defs.h"
15 #include "eapol_supp/eapol_supp_sm.h"
16 #include "rsn_supp/wpa.h"
17 #include "../config.h"
18 #include "../wpa_supplicant_i.h"
19 #include "../driver_i.h"
20 #include "../notify.h"
21 #include "../wpas_glue.h"
22 #include "../bss.h"
23 #include "../scan.h"
24 #include "dbus_old.h"
25 #include "dbus_old_handlers.h"
26 #include "dbus_dict_helpers.h"
27
28 /**
29 * wpas_dbus_new_invalid_opts_error - Return a new invalid options error message
30 * @message: Pointer to incoming dbus message this error refers to
31 * Returns: a dbus error message
32 *
33 * Convenience function to create and return an invalid options error
34 */
wpas_dbus_new_invalid_opts_error(DBusMessage * message,const char * arg)35 DBusMessage * wpas_dbus_new_invalid_opts_error(DBusMessage *message,
36 const char *arg)
37 {
38 DBusMessage *reply;
39
40 reply = dbus_message_new_error(
41 message, WPAS_ERROR_INVALID_OPTS,
42 "Did not receive correct message arguments.");
43 if (arg != NULL)
44 dbus_message_append_args(reply, DBUS_TYPE_STRING, &arg,
45 DBUS_TYPE_INVALID);
46
47 return reply;
48 }
49
50
51 /**
52 * wpas_dbus_new_success_reply - Return a new success reply message
53 * @message: Pointer to incoming dbus message this reply refers to
54 * Returns: a dbus message containing a single UINT32 that indicates
55 * success (ie, a value of 1)
56 *
57 * Convenience function to create and return a success reply message
58 */
wpas_dbus_new_success_reply(DBusMessage * message)59 DBusMessage * wpas_dbus_new_success_reply(DBusMessage *message)
60 {
61 DBusMessage *reply;
62 unsigned int success = 1;
63
64 reply = dbus_message_new_method_return(message);
65 dbus_message_append_args(reply, DBUS_TYPE_UINT32, &success,
66 DBUS_TYPE_INVALID);
67 return reply;
68 }
69
70
71 /**
72 * wpas_dbus_global_add_interface - Request registration of a network interface
73 * @message: Pointer to incoming dbus message
74 * @global: %wpa_supplicant global data structure
75 * Returns: The object path of the new interface object,
76 * or a dbus error message with more information
77 *
78 * Handler function for "addInterface" method call. Handles requests
79 * by dbus clients to register a network interface that wpa_supplicant
80 * will manage.
81 */
wpas_dbus_global_add_interface(DBusMessage * message,struct wpa_global * global)82 DBusMessage * wpas_dbus_global_add_interface(DBusMessage *message,
83 struct wpa_global *global)
84 {
85 char *ifname = NULL;
86 char *driver = NULL;
87 char *driver_param = NULL;
88 char *confname = NULL;
89 char *bridge_ifname = NULL;
90 DBusMessage *reply = NULL;
91 DBusMessageIter iter;
92
93 dbus_message_iter_init(message, &iter);
94
95 /* First argument: interface name (DBUS_TYPE_STRING)
96 * Required; must be non-zero length
97 */
98 if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
99 goto error;
100 dbus_message_iter_get_basic(&iter, &ifname);
101 if (!os_strlen(ifname))
102 goto error;
103
104 /* Second argument: dict of options */
105 if (dbus_message_iter_next(&iter)) {
106 DBusMessageIter iter_dict;
107 struct wpa_dbus_dict_entry entry;
108
109 if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
110 goto error;
111 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
112 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
113 goto error;
114 if (!strcmp(entry.key, "driver") &&
115 entry.type == DBUS_TYPE_STRING) {
116 os_free(driver);
117 driver = os_strdup(entry.str_value);
118 wpa_dbus_dict_entry_clear(&entry);
119 if (driver == NULL)
120 goto error;
121 } else if (!strcmp(entry.key, "driver-params") &&
122 entry.type == DBUS_TYPE_STRING) {
123 os_free(driver_param);
124 driver_param = os_strdup(entry.str_value);
125 wpa_dbus_dict_entry_clear(&entry);
126 if (driver_param == NULL)
127 goto error;
128 } else if (!strcmp(entry.key, "config-file") &&
129 entry.type == DBUS_TYPE_STRING) {
130 os_free(confname);
131 confname = os_strdup(entry.str_value);
132 wpa_dbus_dict_entry_clear(&entry);
133 if (confname == NULL)
134 goto error;
135 } else if (!strcmp(entry.key, "bridge-ifname") &&
136 entry.type == DBUS_TYPE_STRING) {
137 os_free(bridge_ifname);
138 bridge_ifname = os_strdup(entry.str_value);
139 wpa_dbus_dict_entry_clear(&entry);
140 if (bridge_ifname == NULL)
141 goto error;
142 } else {
143 wpa_dbus_dict_entry_clear(&entry);
144 goto error;
145 }
146 }
147 }
148
149 /*
150 * Try to get the wpa_supplicant record for this iface, return
151 * an error if we already control it.
152 */
153 if (wpa_supplicant_get_iface(global, ifname) != NULL) {
154 reply = dbus_message_new_error(
155 message, WPAS_ERROR_EXISTS_ERROR,
156 "wpa_supplicant already controls this interface.");
157 } else {
158 struct wpa_supplicant *wpa_s;
159 struct wpa_interface iface;
160
161 os_memset(&iface, 0, sizeof(iface));
162 iface.ifname = ifname;
163 iface.driver = driver;
164 iface.driver_param = driver_param;
165 iface.confname = confname;
166 iface.bridge_ifname = bridge_ifname;
167 /* Otherwise, have wpa_supplicant attach to it. */
168 wpa_s = wpa_supplicant_add_iface(global, &iface, NULL);
169 if (wpa_s && wpa_s->dbus_path) {
170 const char *path = wpa_s->dbus_path;
171
172 reply = dbus_message_new_method_return(message);
173 dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH,
174 &path, DBUS_TYPE_INVALID);
175 } else {
176 reply = dbus_message_new_error(
177 message, WPAS_ERROR_ADD_ERROR,
178 "wpa_supplicant couldn't grab this interface.");
179 }
180 }
181
182 out:
183 os_free(driver);
184 os_free(driver_param);
185 os_free(confname);
186 os_free(bridge_ifname);
187 return reply;
188
189 error:
190 reply = wpas_dbus_new_invalid_opts_error(message, NULL);
191 goto out;
192 }
193
194
195 /**
196 * wpas_dbus_global_remove_interface - Request deregistration of an interface
197 * @message: Pointer to incoming dbus message
198 * @global: wpa_supplicant global data structure
199 * Returns: a dbus message containing a UINT32 indicating success (1) or
200 * failure (0), or returns a dbus error message with more information
201 *
202 * Handler function for "removeInterface" method call. Handles requests
203 * by dbus clients to deregister a network interface that wpa_supplicant
204 * currently manages.
205 */
wpas_dbus_global_remove_interface(DBusMessage * message,struct wpa_global * global)206 DBusMessage * wpas_dbus_global_remove_interface(DBusMessage *message,
207 struct wpa_global *global)
208 {
209 struct wpa_supplicant *wpa_s;
210 char *path;
211 DBusMessage *reply = NULL;
212
213 if (!dbus_message_get_args(message, NULL,
214 DBUS_TYPE_OBJECT_PATH, &path,
215 DBUS_TYPE_INVALID)) {
216 reply = wpas_dbus_new_invalid_opts_error(message, NULL);
217 goto out;
218 }
219
220 wpa_s = wpa_supplicant_get_iface_by_dbus_path(global, path);
221 if (wpa_s == NULL) {
222 reply = wpas_dbus_new_invalid_iface_error(message);
223 goto out;
224 }
225
226 if (!wpa_supplicant_remove_iface(global, wpa_s, 0)) {
227 reply = wpas_dbus_new_success_reply(message);
228 } else {
229 reply = dbus_message_new_error(
230 message, WPAS_ERROR_REMOVE_ERROR,
231 "wpa_supplicant couldn't remove this interface.");
232 }
233
234 out:
235 return reply;
236 }
237
238
239 /**
240 * wpas_dbus_global_get_interface - Get the object path for an interface name
241 * @message: Pointer to incoming dbus message
242 * @global: %wpa_supplicant global data structure
243 * Returns: The object path of the interface object,
244 * or a dbus error message with more information
245 *
246 * Handler function for "getInterface" method call. Handles requests
247 * by dbus clients for the object path of an specific network interface.
248 */
wpas_dbus_global_get_interface(DBusMessage * message,struct wpa_global * global)249 DBusMessage * wpas_dbus_global_get_interface(DBusMessage *message,
250 struct wpa_global *global)
251 {
252 DBusMessage *reply = NULL;
253 const char *ifname;
254 const char *path;
255 struct wpa_supplicant *wpa_s;
256
257 if (!dbus_message_get_args(message, NULL,
258 DBUS_TYPE_STRING, &ifname,
259 DBUS_TYPE_INVALID)) {
260 reply = wpas_dbus_new_invalid_opts_error(message, NULL);
261 goto out;
262 }
263
264 wpa_s = wpa_supplicant_get_iface(global, ifname);
265 if (wpa_s == NULL || !wpa_s->dbus_path) {
266 reply = wpas_dbus_new_invalid_iface_error(message);
267 goto out;
268 }
269
270 path = wpa_s->dbus_path;
271 reply = dbus_message_new_method_return(message);
272 dbus_message_append_args(reply,
273 DBUS_TYPE_OBJECT_PATH, &path,
274 DBUS_TYPE_INVALID);
275
276 out:
277 return reply;
278 }
279
280
281 /**
282 * wpas_dbus_global_set_debugparams- Set the debug params
283 * @message: Pointer to incoming dbus message
284 * @global: %wpa_supplicant global data structure
285 * Returns: a dbus message containing a UINT32 indicating success (1) or
286 * failure (0), or returns a dbus error message with more information
287 *
288 * Handler function for "setDebugParams" method call. Handles requests
289 * by dbus clients for the object path of an specific network interface.
290 */
wpas_dbus_global_set_debugparams(DBusMessage * message,struct wpa_global * global)291 DBusMessage * wpas_dbus_global_set_debugparams(DBusMessage *message,
292 struct wpa_global *global)
293 {
294 DBusMessage *reply = NULL;
295 int debug_level;
296 dbus_bool_t debug_timestamp;
297 dbus_bool_t debug_show_keys;
298
299 if (!dbus_message_get_args(message, NULL,
300 DBUS_TYPE_INT32, &debug_level,
301 DBUS_TYPE_BOOLEAN, &debug_timestamp,
302 DBUS_TYPE_BOOLEAN, &debug_show_keys,
303 DBUS_TYPE_INVALID)) {
304 return wpas_dbus_new_invalid_opts_error(message, NULL);
305 }
306
307 if (wpa_supplicant_set_debug_params(global, debug_level,
308 debug_timestamp ? 1 : 0,
309 debug_show_keys ? 1 : 0)) {
310 return wpas_dbus_new_invalid_opts_error(message, NULL);
311 }
312
313 reply = wpas_dbus_new_success_reply(message);
314
315 return reply;
316 }
317
318
319 /**
320 * wpas_dbus_iface_scan - Request a wireless scan on an interface
321 * @message: Pointer to incoming dbus message
322 * @wpa_s: wpa_supplicant structure for a network interface
323 * Returns: a dbus message containing a UINT32 indicating success (1) or
324 * failure (0)
325 *
326 * Handler function for "scan" method call of a network device. Requests
327 * that wpa_supplicant perform a wireless scan as soon as possible
328 * on a particular wireless interface.
329 */
wpas_dbus_iface_scan(DBusMessage * message,struct wpa_supplicant * wpa_s)330 DBusMessage * wpas_dbus_iface_scan(DBusMessage *message,
331 struct wpa_supplicant *wpa_s)
332 {
333 wpa_s->scan_req = MANUAL_SCAN_REQ;
334 wpa_supplicant_req_scan(wpa_s, 0, 0);
335 return wpas_dbus_new_success_reply(message);
336 }
337
338
339 /**
340 * wpas_dbus_iface_scan_results - Get the results of a recent scan request
341 * @message: Pointer to incoming dbus message
342 * @wpa_s: wpa_supplicant structure for a network interface
343 * Returns: a dbus message containing a dbus array of objects paths, or returns
344 * a dbus error message if not scan results could be found
345 *
346 * Handler function for "scanResults" method call of a network device. Returns
347 * a dbus message containing the object paths of wireless networks found.
348 */
wpas_dbus_iface_scan_results(DBusMessage * message,struct wpa_supplicant * wpa_s)349 DBusMessage * wpas_dbus_iface_scan_results(DBusMessage *message,
350 struct wpa_supplicant *wpa_s)
351 {
352 DBusMessage *reply;
353 DBusMessageIter iter;
354 DBusMessageIter sub_iter;
355 struct wpa_bss *bss;
356
357 if (!wpa_s->dbus_path)
358 return dbus_message_new_error(message,
359 WPAS_ERROR_INTERNAL_ERROR,
360 "no D-Bus interface available");
361
362 /* Create and initialize the return message */
363 reply = dbus_message_new_method_return(message);
364 dbus_message_iter_init_append(reply, &iter);
365 if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
366 DBUS_TYPE_OBJECT_PATH_AS_STRING,
367 &sub_iter))
368 goto error;
369
370 /* Loop through scan results and append each result's object path */
371 dl_list_for_each(bss, &wpa_s->bss_id, struct wpa_bss, list_id) {
372 char path_buf[WPAS_DBUS_OBJECT_PATH_MAX];
373 char *path = path_buf;
374
375 /* Construct the object path for this network. Note that ':'
376 * is not a valid character in dbus object paths.
377 */
378 os_snprintf(path, WPAS_DBUS_OBJECT_PATH_MAX,
379 "%s/" WPAS_DBUS_BSSIDS_PART "/"
380 WPAS_DBUS_BSSID_FORMAT,
381 wpa_s->dbus_path, MAC2STR(bss->bssid));
382 if (!dbus_message_iter_append_basic(&sub_iter,
383 DBUS_TYPE_OBJECT_PATH,
384 &path))
385 goto error;
386 }
387
388 if (!dbus_message_iter_close_container(&iter, &sub_iter))
389 goto error;
390
391 return reply;
392
393 error:
394 dbus_message_unref(reply);
395 return dbus_message_new_error(message, WPAS_ERROR_INTERNAL_ERROR,
396 "an internal error occurred returning scan results");
397 }
398
399
400 /**
401 * wpas_dbus_bssid_properties - Return the properties of a scanned network
402 * @message: Pointer to incoming dbus message
403 * @wpa_s: wpa_supplicant structure for a network interface
404 * @res: wpa_supplicant scan result for which to get properties
405 * Returns: a dbus message containing the properties for the requested network
406 *
407 * Handler function for "properties" method call of a scanned network.
408 * Returns a dbus message containing the the properties.
409 */
wpas_dbus_bssid_properties(DBusMessage * message,struct wpa_supplicant * wpa_s,struct wpa_bss * bss)410 DBusMessage * wpas_dbus_bssid_properties(DBusMessage *message,
411 struct wpa_supplicant *wpa_s,
412 struct wpa_bss *bss)
413 {
414 DBusMessage *reply;
415 DBusMessageIter iter, iter_dict;
416 const u8 *wpa_ie, *rsn_ie, *wps_ie;
417
418 /* Dump the properties into a dbus message */
419 reply = dbus_message_new_method_return(message);
420
421 wpa_ie = wpa_bss_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE);
422 rsn_ie = wpa_bss_get_ie(bss, WLAN_EID_RSN);
423 wps_ie = wpa_bss_get_vendor_ie(bss, WPS_IE_VENDOR_TYPE);
424
425 dbus_message_iter_init_append(reply, &iter);
426 if (!wpa_dbus_dict_open_write(&iter, &iter_dict) ||
427 !wpa_dbus_dict_append_byte_array(&iter_dict, "bssid",
428 (const char *) bss->bssid,
429 ETH_ALEN) ||
430 !wpa_dbus_dict_append_byte_array(&iter_dict, "ssid",
431 (const char *) bss->ssid,
432 bss->ssid_len) ||
433 (wpa_ie &&
434 !wpa_dbus_dict_append_byte_array(&iter_dict, "wpaie",
435 (const char *) wpa_ie,
436 wpa_ie[1] + 2)) ||
437 (rsn_ie &&
438 !wpa_dbus_dict_append_byte_array(&iter_dict, "rsnie",
439 (const char *) rsn_ie,
440 rsn_ie[1] + 2)) ||
441 (wps_ie &&
442 !wpa_dbus_dict_append_byte_array(&iter_dict, "wpsie",
443 (const char *) wps_ie,
444 wps_ie[1] + 2)) ||
445 (bss->freq &&
446 !wpa_dbus_dict_append_int32(&iter_dict, "frequency", bss->freq)) ||
447 !wpa_dbus_dict_append_uint16(&iter_dict, "capabilities",
448 bss->caps) ||
449 (!(bss->flags & WPA_BSS_QUAL_INVALID) &&
450 !wpa_dbus_dict_append_int32(&iter_dict, "quality", bss->qual)) ||
451 (!(bss->flags & WPA_BSS_NOISE_INVALID) &&
452 !wpa_dbus_dict_append_int32(&iter_dict, "noise", bss->noise)) ||
453 (!(bss->flags & WPA_BSS_LEVEL_INVALID) &&
454 !wpa_dbus_dict_append_int32(&iter_dict, "level", bss->level)) ||
455 !wpa_dbus_dict_append_int32(&iter_dict, "maxrate",
456 wpa_bss_get_max_rate(bss) * 500000) ||
457 !wpa_dbus_dict_close_write(&iter, &iter_dict)) {
458 if (reply)
459 dbus_message_unref(reply);
460 reply = dbus_message_new_error(
461 message, WPAS_ERROR_INTERNAL_ERROR,
462 "an internal error occurred returning BSSID properties.");
463 }
464
465 return reply;
466 }
467
468
469 /**
470 * wpas_dbus_iface_capabilities - Return interface capabilities
471 * @message: Pointer to incoming dbus message
472 * @wpa_s: wpa_supplicant structure for a network interface
473 * Returns: A dbus message containing a dict of strings
474 *
475 * Handler function for "capabilities" method call of an interface.
476 */
wpas_dbus_iface_capabilities(DBusMessage * message,struct wpa_supplicant * wpa_s)477 DBusMessage * wpas_dbus_iface_capabilities(DBusMessage *message,
478 struct wpa_supplicant *wpa_s)
479 {
480 DBusMessage *reply = NULL;
481 struct wpa_driver_capa capa;
482 int res;
483 DBusMessageIter iter, iter_dict;
484 char **eap_methods;
485 size_t num_items;
486 dbus_bool_t strict = FALSE;
487 DBusMessageIter iter_dict_entry, iter_dict_val, iter_array;
488
489 if (!dbus_message_get_args(message, NULL,
490 DBUS_TYPE_BOOLEAN, &strict,
491 DBUS_TYPE_INVALID))
492 strict = FALSE;
493
494 reply = dbus_message_new_method_return(message);
495
496 dbus_message_iter_init_append(reply, &iter);
497 if (!wpa_dbus_dict_open_write(&iter, &iter_dict))
498 goto error;
499
500 /* EAP methods */
501 eap_methods = eap_get_names_as_string_array(&num_items);
502 if (eap_methods) {
503 dbus_bool_t success;
504 size_t i = 0;
505
506 success = wpa_dbus_dict_append_string_array(
507 &iter_dict, "eap", (const char **) eap_methods,
508 num_items);
509
510 /* free returned method array */
511 while (eap_methods[i])
512 os_free(eap_methods[i++]);
513 os_free(eap_methods);
514
515 if (!success)
516 goto error;
517 }
518
519 res = wpa_drv_get_capa(wpa_s, &capa);
520
521 /***** pairwise cipher */
522 if (res < 0) {
523 if (!strict) {
524 const char *args[] = {"CCMP", "TKIP", "NONE"};
525
526 if (!wpa_dbus_dict_append_string_array(
527 &iter_dict, "pairwise", args,
528 ARRAY_SIZE(args)))
529 goto error;
530 }
531 } else {
532 if (!wpa_dbus_dict_begin_string_array(&iter_dict, "pairwise",
533 &iter_dict_entry,
534 &iter_dict_val,
535 &iter_array) ||
536 ((capa.enc & WPA_DRIVER_CAPA_ENC_CCMP) &&
537 !wpa_dbus_dict_string_array_add_element(
538 &iter_array, "CCMP")) ||
539 ((capa.enc & WPA_DRIVER_CAPA_ENC_TKIP) &&
540 !wpa_dbus_dict_string_array_add_element(
541 &iter_array, "TKIP")) ||
542 ((capa.key_mgmt & WPA_DRIVER_CAPA_KEY_MGMT_WPA_NONE) &&
543 !wpa_dbus_dict_string_array_add_element(
544 &iter_array, "NONE")) ||
545 !wpa_dbus_dict_end_string_array(&iter_dict,
546 &iter_dict_entry,
547 &iter_dict_val,
548 &iter_array))
549 goto error;
550 }
551
552 /***** group cipher */
553 if (res < 0) {
554 if (!strict) {
555 const char *args[] = {
556 "CCMP", "TKIP", "WEP104", "WEP40"
557 };
558
559 if (!wpa_dbus_dict_append_string_array(
560 &iter_dict, "group", args,
561 ARRAY_SIZE(args)))
562 goto error;
563 }
564 } else {
565 if (!wpa_dbus_dict_begin_string_array(&iter_dict, "group",
566 &iter_dict_entry,
567 &iter_dict_val,
568 &iter_array))
569 goto error;
570
571 if (((capa.enc & WPA_DRIVER_CAPA_ENC_CCMP) &&
572 !wpa_dbus_dict_string_array_add_element(
573 &iter_array, "CCMP")) ||
574 ((capa.enc & WPA_DRIVER_CAPA_ENC_TKIP) &&
575 !wpa_dbus_dict_string_array_add_element(
576 &iter_array, "TKIP")) ||
577 ((capa.enc & WPA_DRIVER_CAPA_ENC_WEP104) &&
578 !wpa_dbus_dict_string_array_add_element(
579 &iter_array, "WEP104")) ||
580 ((capa.enc & WPA_DRIVER_CAPA_ENC_WEP40) &&
581 !wpa_dbus_dict_string_array_add_element(
582 &iter_array, "WEP40")) ||
583 !wpa_dbus_dict_end_string_array(&iter_dict,
584 &iter_dict_entry,
585 &iter_dict_val,
586 &iter_array))
587 goto error;
588 }
589
590 /***** key management */
591 if (res < 0) {
592 if (!strict) {
593 const char *args[] = {
594 "WPA-PSK", "WPA-EAP", "IEEE8021X", "WPA-NONE",
595 "NONE"
596 };
597 if (!wpa_dbus_dict_append_string_array(
598 &iter_dict, "key_mgmt", args,
599 ARRAY_SIZE(args)))
600 goto error;
601 }
602 } else {
603 if (!wpa_dbus_dict_begin_string_array(&iter_dict, "key_mgmt",
604 &iter_dict_entry,
605 &iter_dict_val,
606 &iter_array) ||
607 !wpa_dbus_dict_string_array_add_element(&iter_array,
608 "NONE") ||
609 !wpa_dbus_dict_string_array_add_element(&iter_array,
610 "IEEE8021X") ||
611 ((capa.key_mgmt & (WPA_DRIVER_CAPA_KEY_MGMT_WPA |
612 WPA_DRIVER_CAPA_KEY_MGMT_WPA2)) &&
613 !wpa_dbus_dict_string_array_add_element(
614 &iter_array, "WPA-EAP")) ||
615 ((capa.key_mgmt & (WPA_DRIVER_CAPA_KEY_MGMT_WPA_PSK |
616 WPA_DRIVER_CAPA_KEY_MGMT_WPA2_PSK)) &&
617 !wpa_dbus_dict_string_array_add_element(
618 &iter_array, "WPA-PSK")) ||
619 ((capa.key_mgmt & WPA_DRIVER_CAPA_KEY_MGMT_WPA_NONE) &&
620 !wpa_dbus_dict_string_array_add_element(
621 &iter_array, "WPA-NONE")) ||
622 !wpa_dbus_dict_end_string_array(&iter_dict,
623 &iter_dict_entry,
624 &iter_dict_val,
625 &iter_array))
626 goto error;
627 }
628
629 /***** WPA protocol */
630 if (res < 0) {
631 if (!strict) {
632 const char *args[] = { "RSN", "WPA" };
633
634 if (!wpa_dbus_dict_append_string_array(
635 &iter_dict, "proto", args,
636 ARRAY_SIZE(args)))
637 goto error;
638 }
639 } else {
640 if (!wpa_dbus_dict_begin_string_array(&iter_dict, "proto",
641 &iter_dict_entry,
642 &iter_dict_val,
643 &iter_array) ||
644 ((capa.key_mgmt & (WPA_DRIVER_CAPA_KEY_MGMT_WPA2 |
645 WPA_DRIVER_CAPA_KEY_MGMT_WPA2_PSK)) &&
646 !wpa_dbus_dict_string_array_add_element(
647 &iter_array, "RSN")) ||
648 ((capa.key_mgmt & (WPA_DRIVER_CAPA_KEY_MGMT_WPA |
649 WPA_DRIVER_CAPA_KEY_MGMT_WPA_PSK)) &&
650 !wpa_dbus_dict_string_array_add_element(
651 &iter_array, "WPA")) ||
652 !wpa_dbus_dict_end_string_array(&iter_dict,
653 &iter_dict_entry,
654 &iter_dict_val,
655 &iter_array))
656 goto error;
657 }
658
659 /***** auth alg */
660 if (res < 0) {
661 if (!strict) {
662 const char *args[] = { "OPEN", "SHARED", "LEAP" };
663
664 if (!wpa_dbus_dict_append_string_array(
665 &iter_dict, "auth_alg", args,
666 ARRAY_SIZE(args)))
667 goto error;
668 }
669 } else {
670 if (!wpa_dbus_dict_begin_string_array(&iter_dict, "auth_alg",
671 &iter_dict_entry,
672 &iter_dict_val,
673 &iter_array) ||
674 ((capa.auth & WPA_DRIVER_AUTH_OPEN) &&
675 !wpa_dbus_dict_string_array_add_element(
676 &iter_array, "OPEN")) ||
677 ((capa.auth & WPA_DRIVER_AUTH_SHARED) &&
678 !wpa_dbus_dict_string_array_add_element(
679 &iter_array, "SHARED")) ||
680 ((capa.auth & WPA_DRIVER_AUTH_LEAP) &&
681 !wpa_dbus_dict_string_array_add_element(
682 &iter_array, "LEAP")) ||
683 !wpa_dbus_dict_end_string_array(&iter_dict,
684 &iter_dict_entry,
685 &iter_dict_val,
686 &iter_array))
687 goto error;
688 }
689
690 if (!wpa_dbus_dict_close_write(&iter, &iter_dict))
691 goto error;
692
693 return reply;
694
695 error:
696 if (reply)
697 dbus_message_unref(reply);
698 return dbus_message_new_error(
699 message, WPAS_ERROR_INTERNAL_ERROR,
700 "an internal error occurred returning interface capabilities.");
701 }
702
703
704 /**
705 * wpas_dbus_iface_add_network - Add a new configured network
706 * @message: Pointer to incoming dbus message
707 * @wpa_s: wpa_supplicant structure for a network interface
708 * Returns: A dbus message containing the object path of the new network
709 *
710 * Handler function for "addNetwork" method call of a network interface.
711 */
wpas_dbus_iface_add_network(DBusMessage * message,struct wpa_supplicant * wpa_s)712 DBusMessage * wpas_dbus_iface_add_network(DBusMessage *message,
713 struct wpa_supplicant *wpa_s)
714 {
715 DBusMessage *reply = NULL;
716 struct wpa_ssid *ssid = NULL;
717 char path_buf[WPAS_DBUS_OBJECT_PATH_MAX], *path = path_buf;
718
719 if (wpa_s->dbus_path)
720 ssid = wpa_config_add_network(wpa_s->conf);
721 if (ssid == NULL) {
722 reply = dbus_message_new_error(
723 message, WPAS_ERROR_ADD_NETWORK_ERROR,
724 "wpa_supplicant could not add a network on this interface.");
725 goto out;
726 }
727 wpas_notify_network_added(wpa_s, ssid);
728 ssid->disabled = 1;
729 wpa_config_set_network_defaults(ssid);
730
731 /* Construct the object path for this network. */
732 os_snprintf(path, WPAS_DBUS_OBJECT_PATH_MAX,
733 "%s/" WPAS_DBUS_NETWORKS_PART "/%d",
734 wpa_s->dbus_path, ssid->id);
735
736 reply = dbus_message_new_method_return(message);
737 dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH,
738 &path, DBUS_TYPE_INVALID);
739
740 out:
741 return reply;
742 }
743
744
745 /**
746 * wpas_dbus_iface_remove_network - Remove a configured network
747 * @message: Pointer to incoming dbus message
748 * @wpa_s: wpa_supplicant structure for a network interface
749 * Returns: A dbus message containing a UINT32 indicating success (1) or
750 * failure (0)
751 *
752 * Handler function for "removeNetwork" method call of a network interface.
753 */
wpas_dbus_iface_remove_network(DBusMessage * message,struct wpa_supplicant * wpa_s)754 DBusMessage * wpas_dbus_iface_remove_network(DBusMessage *message,
755 struct wpa_supplicant *wpa_s)
756 {
757 DBusMessage *reply = NULL;
758 const char *op;
759 char *iface = NULL, *net_id = NULL;
760 int id;
761 struct wpa_ssid *ssid;
762
763 if (!dbus_message_get_args(message, NULL,
764 DBUS_TYPE_OBJECT_PATH, &op,
765 DBUS_TYPE_INVALID)) {
766 reply = wpas_dbus_new_invalid_opts_error(message, NULL);
767 goto out;
768 }
769
770 /* Extract the network ID */
771 iface = wpas_dbus_decompose_object_path(op, &net_id, NULL);
772 if (iface == NULL || net_id == NULL) {
773 reply = wpas_dbus_new_invalid_network_error(message);
774 goto out;
775 }
776
777 /* Ensure the network is actually a child of this interface */
778 if (!wpa_s->dbus_path || os_strcmp(iface, wpa_s->dbus_path) != 0) {
779 reply = wpas_dbus_new_invalid_network_error(message);
780 goto out;
781 }
782
783 id = strtoul(net_id, NULL, 10);
784 ssid = wpa_config_get_network(wpa_s->conf, id);
785 if (ssid == NULL) {
786 reply = wpas_dbus_new_invalid_network_error(message);
787 goto out;
788 }
789
790 wpas_notify_network_removed(wpa_s, ssid);
791
792 if (ssid == wpa_s->current_ssid)
793 wpa_supplicant_deauthenticate(wpa_s,
794 WLAN_REASON_DEAUTH_LEAVING);
795
796 if (wpa_config_remove_network(wpa_s->conf, id) < 0) {
797 reply = dbus_message_new_error(
798 message, WPAS_ERROR_REMOVE_NETWORK_ERROR,
799 "error removing the specified on this interface.");
800 goto out;
801 }
802
803 reply = wpas_dbus_new_success_reply(message);
804
805 out:
806 os_free(iface);
807 os_free(net_id);
808 return reply;
809 }
810
811
812 static const char const *dont_quote[] = {
813 "key_mgmt", "proto", "pairwise", "auth_alg", "group", "eap",
814 "opensc_engine_path", "pkcs11_engine_path", "pkcs11_module_path",
815 "bssid", NULL
816 };
817
818
should_quote_opt(const char * key)819 static dbus_bool_t should_quote_opt(const char *key)
820 {
821 int i = 0;
822
823 while (dont_quote[i] != NULL) {
824 if (os_strcmp(key, dont_quote[i]) == 0)
825 return FALSE;
826 i++;
827 }
828 return TRUE;
829 }
830
831
832 /**
833 * wpas_dbus_iface_set_network - Set options for a configured network
834 * @message: Pointer to incoming dbus message
835 * @wpa_s: wpa_supplicant structure for a network interface
836 * @ssid: wpa_ssid structure for a configured network
837 * Returns: a dbus message containing a UINT32 indicating success (1) or
838 * failure (0)
839 *
840 * Handler function for "set" method call of a configured network.
841 */
wpas_dbus_iface_set_network(DBusMessage * message,struct wpa_supplicant * wpa_s,struct wpa_ssid * ssid)842 DBusMessage * wpas_dbus_iface_set_network(DBusMessage *message,
843 struct wpa_supplicant *wpa_s,
844 struct wpa_ssid *ssid)
845 {
846 DBusMessage *reply = NULL;
847 struct wpa_dbus_dict_entry entry = { .type = DBUS_TYPE_STRING };
848 DBusMessageIter iter, iter_dict;
849
850 dbus_message_iter_init(message, &iter);
851
852 if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL)) {
853 reply = wpas_dbus_new_invalid_opts_error(message, NULL);
854 goto out;
855 }
856
857 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
858 char *value = NULL;
859 size_t size = 50;
860 int ret;
861
862 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry)) {
863 reply = wpas_dbus_new_invalid_opts_error(message,
864 NULL);
865 goto out;
866 }
867
868 /* Type conversions, since wpa_supplicant wants strings */
869 if (entry.type == DBUS_TYPE_ARRAY &&
870 entry.array_type == DBUS_TYPE_BYTE) {
871 if (entry.array_len <= 0)
872 goto error;
873
874 size = entry.array_len * 2 + 1;
875 value = os_zalloc(size);
876 if (value == NULL)
877 goto error;
878 ret = wpa_snprintf_hex(value, size,
879 (u8 *) entry.bytearray_value,
880 entry.array_len);
881 if (ret <= 0)
882 goto error;
883 } else if (entry.type == DBUS_TYPE_STRING) {
884 if (should_quote_opt(entry.key)) {
885 size = os_strlen(entry.str_value);
886 /* Zero-length option check */
887 if (size == 0)
888 goto error;
889 size += 3; /* For quotes and terminator */
890 value = os_zalloc(size);
891 if (value == NULL)
892 goto error;
893 ret = os_snprintf(value, size, "\"%s\"",
894 entry.str_value);
895 if (os_snprintf_error(size, ret))
896 goto error;
897 } else {
898 value = os_strdup(entry.str_value);
899 if (value == NULL)
900 goto error;
901 }
902 } else if (entry.type == DBUS_TYPE_UINT32) {
903 value = os_zalloc(size);
904 if (value == NULL)
905 goto error;
906 ret = os_snprintf(value, size, "%u",
907 entry.uint32_value);
908 if (os_snprintf_error(size, ret))
909 goto error;
910 } else if (entry.type == DBUS_TYPE_INT32) {
911 value = os_zalloc(size);
912 if (value == NULL)
913 goto error;
914 ret = os_snprintf(value, size, "%d",
915 entry.int32_value);
916 if (os_snprintf_error(size, ret))
917 goto error;
918 } else
919 goto error;
920
921 if (wpa_config_set(ssid, entry.key, value, 0) < 0)
922 goto error;
923
924 if ((os_strcmp(entry.key, "psk") == 0 &&
925 value[0] == '"' && ssid->ssid_len) ||
926 (os_strcmp(entry.key, "ssid") == 0 && ssid->passphrase))
927 wpa_config_update_psk(ssid);
928 else if (os_strcmp(entry.key, "priority") == 0)
929 wpa_config_update_prio_list(wpa_s->conf);
930
931 os_free(value);
932 wpa_dbus_dict_entry_clear(&entry);
933 continue;
934
935 error:
936 os_free(value);
937 reply = wpas_dbus_new_invalid_opts_error(message, entry.key);
938 wpa_dbus_dict_entry_clear(&entry);
939 break;
940 }
941
942 if (!reply)
943 reply = wpas_dbus_new_success_reply(message);
944
945 out:
946 return reply;
947 }
948
949
950 /**
951 * wpas_dbus_iface_enable_network - Mark a configured network as enabled
952 * @message: Pointer to incoming dbus message
953 * @wpa_s: wpa_supplicant structure for a network interface
954 * @ssid: wpa_ssid structure for a configured network
955 * Returns: A dbus message containing a UINT32 indicating success (1) or
956 * failure (0)
957 *
958 * Handler function for "enable" method call of a configured network.
959 */
wpas_dbus_iface_enable_network(DBusMessage * message,struct wpa_supplicant * wpa_s,struct wpa_ssid * ssid)960 DBusMessage * wpas_dbus_iface_enable_network(DBusMessage *message,
961 struct wpa_supplicant *wpa_s,
962 struct wpa_ssid *ssid)
963 {
964 wpa_supplicant_enable_network(wpa_s, ssid);
965 return wpas_dbus_new_success_reply(message);
966 }
967
968
969 /**
970 * wpas_dbus_iface_disable_network - Mark a configured network as disabled
971 * @message: Pointer to incoming dbus message
972 * @wpa_s: wpa_supplicant structure for a network interface
973 * @ssid: wpa_ssid structure for a configured network
974 * Returns: A dbus message containing a UINT32 indicating success (1) or
975 * failure (0)
976 *
977 * Handler function for "disable" method call of a configured network.
978 */
wpas_dbus_iface_disable_network(DBusMessage * message,struct wpa_supplicant * wpa_s,struct wpa_ssid * ssid)979 DBusMessage * wpas_dbus_iface_disable_network(DBusMessage *message,
980 struct wpa_supplicant *wpa_s,
981 struct wpa_ssid *ssid)
982 {
983 wpa_supplicant_disable_network(wpa_s, ssid);
984 return wpas_dbus_new_success_reply(message);
985 }
986
987
988 /**
989 * wpas_dbus_iface_select_network - Attempt association with a configured network
990 * @message: Pointer to incoming dbus message
991 * @wpa_s: wpa_supplicant structure for a network interface
992 * Returns: A dbus message containing a UINT32 indicating success (1) or
993 * failure (0)
994 *
995 * Handler function for "selectNetwork" method call of network interface.
996 */
wpas_dbus_iface_select_network(DBusMessage * message,struct wpa_supplicant * wpa_s)997 DBusMessage * wpas_dbus_iface_select_network(DBusMessage *message,
998 struct wpa_supplicant *wpa_s)
999 {
1000 DBusMessage *reply = NULL;
1001 const char *op;
1002 struct wpa_ssid *ssid;
1003 char *iface_obj_path = NULL;
1004 char *network = NULL;
1005
1006 if (os_strlen(dbus_message_get_signature(message)) == 0) {
1007 /* Any network */
1008 ssid = NULL;
1009 } else {
1010 int nid;
1011
1012 if (!dbus_message_get_args(message, NULL,
1013 DBUS_TYPE_OBJECT_PATH, &op,
1014 DBUS_TYPE_INVALID)) {
1015 reply = wpas_dbus_new_invalid_opts_error(message,
1016 NULL);
1017 goto out;
1018 }
1019
1020 /* Extract the network number */
1021 iface_obj_path = wpas_dbus_decompose_object_path(op,
1022 &network,
1023 NULL);
1024 if (iface_obj_path == NULL) {
1025 reply = wpas_dbus_new_invalid_iface_error(message);
1026 goto out;
1027 }
1028 /* Ensure the object path really points to this interface */
1029 if (network == NULL || !wpa_s->dbus_path ||
1030 os_strcmp(iface_obj_path, wpa_s->dbus_path) != 0) {
1031 reply = wpas_dbus_new_invalid_network_error(message);
1032 goto out;
1033 }
1034
1035 nid = strtoul(network, NULL, 10);
1036 if (errno == EINVAL) {
1037 reply = wpas_dbus_new_invalid_network_error(message);
1038 goto out;
1039 }
1040
1041 ssid = wpa_config_get_network(wpa_s->conf, nid);
1042 if (ssid == NULL) {
1043 reply = wpas_dbus_new_invalid_network_error(message);
1044 goto out;
1045 }
1046 }
1047
1048 /* Finally, associate with the network */
1049 wpa_supplicant_select_network(wpa_s, ssid);
1050
1051 reply = wpas_dbus_new_success_reply(message);
1052
1053 out:
1054 os_free(iface_obj_path);
1055 os_free(network);
1056 return reply;
1057 }
1058
1059
1060 /**
1061 * wpas_dbus_iface_disconnect - Terminate the current connection
1062 * @message: Pointer to incoming dbus message
1063 * @wpa_s: wpa_supplicant structure for a network interface
1064 * Returns: A dbus message containing a UINT32 indicating success (1) or
1065 * failure (0)
1066 *
1067 * Handler function for "disconnect" method call of network interface.
1068 */
wpas_dbus_iface_disconnect(DBusMessage * message,struct wpa_supplicant * wpa_s)1069 DBusMessage * wpas_dbus_iface_disconnect(DBusMessage *message,
1070 struct wpa_supplicant *wpa_s)
1071 {
1072 wpa_s->disconnected = 1;
1073 wpa_supplicant_deauthenticate(wpa_s, WLAN_REASON_DEAUTH_LEAVING);
1074
1075 return wpas_dbus_new_success_reply(message);
1076 }
1077
1078
1079 /**
1080 * wpas_dbus_iface_set_ap_scan - Control roaming mode
1081 * @message: Pointer to incoming dbus message
1082 * @wpa_s: wpa_supplicant structure for a network interface
1083 * Returns: A dbus message containing a UINT32 indicating success (1) or
1084 * failure (0)
1085 *
1086 * Handler function for "setAPScan" method call.
1087 */
wpas_dbus_iface_set_ap_scan(DBusMessage * message,struct wpa_supplicant * wpa_s)1088 DBusMessage * wpas_dbus_iface_set_ap_scan(DBusMessage *message,
1089 struct wpa_supplicant *wpa_s)
1090 {
1091 DBusMessage *reply = NULL;
1092 dbus_uint32_t ap_scan = 1;
1093
1094 if (!dbus_message_get_args(message, NULL, DBUS_TYPE_UINT32, &ap_scan,
1095 DBUS_TYPE_INVALID)) {
1096 reply = wpas_dbus_new_invalid_opts_error(message, NULL);
1097 goto out;
1098 }
1099
1100 if (wpa_supplicant_set_ap_scan(wpa_s, ap_scan)) {
1101 reply = wpas_dbus_new_invalid_opts_error(message, NULL);
1102 goto out;
1103 }
1104
1105 reply = wpas_dbus_new_success_reply(message);
1106
1107 out:
1108 return reply;
1109 }
1110
1111
1112 /**
1113 * wpas_dbus_iface_set_smartcard_modules - Set smartcard related module paths
1114 * @message: Pointer to incoming dbus message
1115 * @wpa_s: wpa_supplicant structure for a network interface
1116 * Returns: A dbus message containing a UINT32 indicating success (1) or
1117 * failure (0)
1118 *
1119 * Handler function for "setSmartcardModules" method call.
1120 */
wpas_dbus_iface_set_smartcard_modules(DBusMessage * message,struct wpa_supplicant * wpa_s)1121 DBusMessage * wpas_dbus_iface_set_smartcard_modules(
1122 DBusMessage *message, struct wpa_supplicant *wpa_s)
1123 {
1124 DBusMessageIter iter, iter_dict;
1125 char *opensc_engine_path = NULL;
1126 char *pkcs11_engine_path = NULL;
1127 char *pkcs11_module_path = NULL;
1128 struct wpa_dbus_dict_entry entry;
1129
1130 if (!dbus_message_iter_init(message, &iter))
1131 goto error;
1132
1133 if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
1134 goto error;
1135
1136 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
1137 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
1138 goto error;
1139 if (!strcmp(entry.key, "opensc_engine_path") &&
1140 entry.type == DBUS_TYPE_STRING) {
1141 os_free(opensc_engine_path);
1142 opensc_engine_path = os_strdup(entry.str_value);
1143 wpa_dbus_dict_entry_clear(&entry);
1144 if (opensc_engine_path == NULL)
1145 goto error;
1146 } else if (!strcmp(entry.key, "pkcs11_engine_path") &&
1147 entry.type == DBUS_TYPE_STRING) {
1148 os_free(pkcs11_engine_path);
1149 pkcs11_engine_path = os_strdup(entry.str_value);
1150 wpa_dbus_dict_entry_clear(&entry);
1151 if (pkcs11_engine_path == NULL)
1152 goto error;
1153 } else if (!strcmp(entry.key, "pkcs11_module_path") &&
1154 entry.type == DBUS_TYPE_STRING) {
1155 os_free(pkcs11_module_path);
1156 pkcs11_module_path = os_strdup(entry.str_value);
1157 wpa_dbus_dict_entry_clear(&entry);
1158 if (pkcs11_module_path == NULL)
1159 goto error;
1160 } else {
1161 wpa_dbus_dict_entry_clear(&entry);
1162 goto error;
1163 }
1164 }
1165
1166 os_free(wpa_s->conf->opensc_engine_path);
1167 wpa_s->conf->opensc_engine_path = opensc_engine_path;
1168 os_free(wpa_s->conf->pkcs11_engine_path);
1169 wpa_s->conf->pkcs11_engine_path = pkcs11_engine_path;
1170 os_free(wpa_s->conf->pkcs11_module_path);
1171 wpa_s->conf->pkcs11_module_path = pkcs11_module_path;
1172
1173 wpa_sm_set_eapol(wpa_s->wpa, NULL);
1174 eapol_sm_deinit(wpa_s->eapol);
1175 wpa_s->eapol = NULL;
1176 wpa_supplicant_init_eapol(wpa_s);
1177 wpa_sm_set_eapol(wpa_s->wpa, wpa_s->eapol);
1178
1179 return wpas_dbus_new_success_reply(message);
1180
1181 error:
1182 os_free(opensc_engine_path);
1183 os_free(pkcs11_engine_path);
1184 os_free(pkcs11_module_path);
1185 return wpas_dbus_new_invalid_opts_error(message, NULL);
1186 }
1187
1188
1189 /**
1190 * wpas_dbus_iface_get_state - Get interface state
1191 * @message: Pointer to incoming dbus message
1192 * @wpa_s: wpa_supplicant structure for a network interface
1193 * Returns: A dbus message containing a STRING representing the current
1194 * interface state
1195 *
1196 * Handler function for "state" method call.
1197 */
wpas_dbus_iface_get_state(DBusMessage * message,struct wpa_supplicant * wpa_s)1198 DBusMessage * wpas_dbus_iface_get_state(DBusMessage *message,
1199 struct wpa_supplicant *wpa_s)
1200 {
1201 DBusMessage *reply = NULL;
1202 const char *str_state;
1203
1204 reply = dbus_message_new_method_return(message);
1205 if (reply != NULL) {
1206 str_state = wpa_supplicant_state_txt(wpa_s->wpa_state);
1207 dbus_message_append_args(reply, DBUS_TYPE_STRING, &str_state,
1208 DBUS_TYPE_INVALID);
1209 }
1210
1211 return reply;
1212 }
1213
1214
1215 /**
1216 * wpas_dbus_iface_get_scanning - Get interface scanning state
1217 * @message: Pointer to incoming dbus message
1218 * @wpa_s: wpa_supplicant structure for a network interface
1219 * Returns: A dbus message containing whether the interface is scanning
1220 *
1221 * Handler function for "scanning" method call.
1222 */
wpas_dbus_iface_get_scanning(DBusMessage * message,struct wpa_supplicant * wpa_s)1223 DBusMessage * wpas_dbus_iface_get_scanning(DBusMessage *message,
1224 struct wpa_supplicant *wpa_s)
1225 {
1226 DBusMessage *reply = NULL;
1227 dbus_bool_t scanning = wpa_s->scanning ? TRUE : FALSE;
1228
1229 reply = dbus_message_new_method_return(message);
1230 if (reply != NULL) {
1231 dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &scanning,
1232 DBUS_TYPE_INVALID);
1233 } else {
1234 wpa_printf(MSG_ERROR,
1235 "dbus: Not enough memory to return scanning state");
1236 }
1237
1238 return reply;
1239 }
1240
1241
1242 #ifndef CONFIG_NO_CONFIG_BLOBS
1243
1244 /**
1245 * wpas_dbus_iface_set_blobs - Store named binary blobs (ie, for certificates)
1246 * @message: Pointer to incoming dbus message
1247 * @wpa_s: %wpa_supplicant data structure
1248 * Returns: A dbus message containing a UINT32 indicating success (1) or
1249 * failure (0)
1250 *
1251 * Asks wpa_supplicant to internally store a one or more binary blobs.
1252 */
wpas_dbus_iface_set_blobs(DBusMessage * message,struct wpa_supplicant * wpa_s)1253 DBusMessage * wpas_dbus_iface_set_blobs(DBusMessage *message,
1254 struct wpa_supplicant *wpa_s)
1255 {
1256 DBusMessage *reply = NULL;
1257 struct wpa_dbus_dict_entry entry = { .type = DBUS_TYPE_STRING };
1258 DBusMessageIter iter, iter_dict;
1259
1260 dbus_message_iter_init(message, &iter);
1261
1262 if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
1263 return wpas_dbus_new_invalid_opts_error(message, NULL);
1264
1265 while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
1266 struct wpa_config_blob *blob;
1267
1268 if (!wpa_dbus_dict_get_entry(&iter_dict, &entry)) {
1269 reply = wpas_dbus_new_invalid_opts_error(message,
1270 NULL);
1271 break;
1272 }
1273
1274 if (entry.type != DBUS_TYPE_ARRAY ||
1275 entry.array_type != DBUS_TYPE_BYTE) {
1276 reply = wpas_dbus_new_invalid_opts_error(
1277 message, "Byte array expected.");
1278 break;
1279 }
1280
1281 if ((entry.array_len <= 0) || (entry.array_len > 65536) ||
1282 !strlen(entry.key)) {
1283 reply = wpas_dbus_new_invalid_opts_error(
1284 message, "Invalid array size.");
1285 break;
1286 }
1287
1288 blob = os_zalloc(sizeof(*blob));
1289 if (blob == NULL) {
1290 reply = dbus_message_new_error(
1291 message, WPAS_ERROR_ADD_ERROR,
1292 "Not enough memory to add blob.");
1293 break;
1294 }
1295 blob->data = os_zalloc(entry.array_len);
1296 if (blob->data == NULL) {
1297 reply = dbus_message_new_error(
1298 message, WPAS_ERROR_ADD_ERROR,
1299 "Not enough memory to add blob data.");
1300 os_free(blob);
1301 break;
1302 }
1303
1304 blob->name = os_strdup(entry.key);
1305 blob->len = entry.array_len;
1306 os_memcpy(blob->data, (u8 *) entry.bytearray_value,
1307 entry.array_len);
1308 if (blob->name == NULL) {
1309 wpa_config_free_blob(blob);
1310 reply = dbus_message_new_error(
1311 message, WPAS_ERROR_ADD_ERROR,
1312 "Error adding blob.");
1313 break;
1314 }
1315
1316 /* Success */
1317 if (!wpa_config_remove_blob(wpa_s->conf, blob->name))
1318 wpas_notify_blob_removed(wpa_s, blob->name);
1319 wpa_config_set_blob(wpa_s->conf, blob);
1320 wpas_notify_blob_added(wpa_s, blob->name);
1321
1322 wpa_dbus_dict_entry_clear(&entry);
1323 }
1324 wpa_dbus_dict_entry_clear(&entry);
1325
1326 return reply ? reply : wpas_dbus_new_success_reply(message);
1327 }
1328
1329
1330 /**
1331 * wpas_dbus_iface_remove_blob - Remove named binary blobs
1332 * @message: Pointer to incoming dbus message
1333 * @wpa_s: %wpa_supplicant data structure
1334 * Returns: A dbus message containing a UINT32 indicating success (1) or
1335 * failure (0)
1336 *
1337 * Asks wpa_supplicant to remove one or more previously stored binary blobs.
1338 */
wpas_dbus_iface_remove_blobs(DBusMessage * message,struct wpa_supplicant * wpa_s)1339 DBusMessage * wpas_dbus_iface_remove_blobs(DBusMessage *message,
1340 struct wpa_supplicant *wpa_s)
1341 {
1342 DBusMessageIter iter, array;
1343 char *err_msg = NULL;
1344
1345 dbus_message_iter_init(message, &iter);
1346
1347 if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
1348 dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_STRING)
1349 return wpas_dbus_new_invalid_opts_error(message, NULL);
1350
1351 dbus_message_iter_recurse(&iter, &array);
1352 while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_STRING) {
1353 const char *name;
1354
1355 dbus_message_iter_get_basic(&array, &name);
1356 if (!os_strlen(name))
1357 err_msg = "Invalid blob name.";
1358 else if (wpa_config_remove_blob(wpa_s->conf, name) != 0)
1359 err_msg = "Error removing blob.";
1360 else
1361 wpas_notify_blob_removed(wpa_s, name);
1362 dbus_message_iter_next(&array);
1363 }
1364
1365 if (err_msg)
1366 return dbus_message_new_error(message, WPAS_ERROR_REMOVE_ERROR,
1367 err_msg);
1368
1369 return wpas_dbus_new_success_reply(message);
1370 }
1371
1372 #endif /* CONFIG_NO_CONFIG_BLOBS */
1373
1374
1375 /**
1376 * wpas_dbus_iface_flush - Clear BSS of old or all inactive entries
1377 * @message: Pointer to incoming dbus message
1378 * @wpa_s: %wpa_supplicant data structure
1379 * Returns: a dbus message containing a UINT32 indicating success (1) or
1380 * failure (0), or returns a dbus error message with more information
1381 *
1382 * Handler function for "flush" method call. Handles requests for an
1383 * interface with an optional "age" parameter that specifies the minimum
1384 * age of a BSS to be flushed.
1385 */
wpas_dbus_iface_flush(DBusMessage * message,struct wpa_supplicant * wpa_s)1386 DBusMessage * wpas_dbus_iface_flush(DBusMessage *message,
1387 struct wpa_supplicant *wpa_s)
1388 {
1389 int flush_age = 0;
1390
1391 if (os_strlen(dbus_message_get_signature(message)) != 0 &&
1392 !dbus_message_get_args(message, NULL,
1393 DBUS_TYPE_INT32, &flush_age,
1394 DBUS_TYPE_INVALID)) {
1395 return wpas_dbus_new_invalid_opts_error(message, NULL);
1396 }
1397
1398 if (flush_age == 0)
1399 wpa_bss_flush(wpa_s);
1400 else
1401 wpa_bss_flush_by_age(wpa_s, flush_age);
1402
1403 return wpas_dbus_new_success_reply(message);
1404 }
1405