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