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