wpa_supplicant/dbus/dbus_new_handlers.c

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