contrib/wpa_supplicant/wpa_supplicant/ctrl_iface_dbus_handlers.c

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