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 /**
1815  * wpas_dbus_getter_capabilities - Return interface capabilities
1816  * @iter: Pointer to incoming dbus message iter
1817  * @error: Location to store error on failure
1818  * @user_data: Function specific data
1819  * Returns: TRUE on success, FALSE on failure
1820  *
1821  * Getter for "Capabilities" property of an interface.
1822  */
1823 dbus_bool_t wpas_dbus_getter_capabilities(DBusMessageIter *iter,
1824                                           DBusError *error, void *user_data)
1825 {
1826         struct wpa_supplicant *wpa_s = user_data;
1827         struct wpa_driver_capa capa;
1828         int res;
1829         DBusMessageIter iter_dict, iter_dict_entry, iter_dict_val, iter_array,
1830                 variant_iter;
1831         const char *scans[] = { "active", "passive", "ssid" };
1832
1833         if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
1834                                               "a{sv}", &variant_iter))
1835                 goto nomem;
1836
1837         if (!wpa_dbus_dict_open_write(&variant_iter, &iter_dict))
1838                 goto nomem;
1839
1840         res = wpa_drv_get_capa(wpa_s, &capa);
1841
1842         /***** pairwise cipher */
1843         if (res < 0) {
1844                 const char *args[] = {"ccmp", "tkip", "none"};
1845                 if (!wpa_dbus_dict_append_string_array(
1846                             &iter_dict, "Pairwise", args,
1847                             sizeof(args) / sizeof(char*)))
1848                         goto nomem;
1849         } else {
1850                 if (!wpa_dbus_dict_begin_string_array(&iter_dict, "Pairwise",
1851                                                       &iter_dict_entry,
1852                                                       &iter_dict_val,
1853                                                       &iter_array))
1854                         goto nomem;
1855
1856                 if (capa.enc & WPA_DRIVER_CAPA_ENC_CCMP) {
1857                         if (!wpa_dbus_dict_string_array_add_element(
1858                                     &iter_array, "ccmp"))
1859                                 goto nomem;
1860                 }
1861
1862                 if (capa.enc & WPA_DRIVER_CAPA_ENC_TKIP) {
1863                         if (!wpa_dbus_dict_string_array_add_element(
1864                                     &iter_array, "tkip"))
1865                                 goto nomem;
1866                 }
1867
1868                 if (capa.key_mgmt & WPA_DRIVER_CAPA_KEY_MGMT_WPA_NONE) {
1869                         if (!wpa_dbus_dict_string_array_add_element(
1870                                     &iter_array, "none"))
1871                                 goto nomem;
1872                 }
1873
1874                 if (!wpa_dbus_dict_end_string_array(&iter_dict,
1875                                                     &iter_dict_entry,
1876                                                     &iter_dict_val,
1877                                                     &iter_array))
1878                         goto nomem;
1879         }
1880
1881         /***** group cipher */
1882         if (res < 0) {
1883                 const char *args[] = {
1884                         "ccmp", "tkip", "wep104", "wep40"
1885                 };
1886                 if (!wpa_dbus_dict_append_string_array(
1887                             &iter_dict, "Group", args,
1888                             sizeof(args) / sizeof(char*)))
1889                         goto nomem;
1890         } else {
1891                 if (!wpa_dbus_dict_begin_string_array(&iter_dict, "Group",
1892                                                       &iter_dict_entry,
1893                                                       &iter_dict_val,
1894                                                       &iter_array))
1895                         goto nomem;
1896
1897                 if (capa.enc & WPA_DRIVER_CAPA_ENC_CCMP) {
1898                         if (!wpa_dbus_dict_string_array_add_element(
1899                                     &iter_array, "ccmp"))
1900                                 goto nomem;
1901                 }
1902
1903                 if (capa.enc & WPA_DRIVER_CAPA_ENC_TKIP) {
1904                         if (!wpa_dbus_dict_string_array_add_element(
1905                                     &iter_array, "tkip"))
1906                                 goto nomem;
1907                 }
1908
1909                 if (capa.enc & WPA_DRIVER_CAPA_ENC_WEP104) {
1910                         if (!wpa_dbus_dict_string_array_add_element(
1911                                     &iter_array, "wep104"))
1912                                 goto nomem;
1913                 }
1914
1915                 if (capa.enc & WPA_DRIVER_CAPA_ENC_WEP40) {
1916                         if (!wpa_dbus_dict_string_array_add_element(
1917                                     &iter_array, "wep40"))
1918                                 goto nomem;
1919                 }
1920
1921                 if (!wpa_dbus_dict_end_string_array(&iter_dict,
1922                                                     &iter_dict_entry,
1923                                                     &iter_dict_val,
1924                                                     &iter_array))
1925                         goto nomem;
1926         }
1927
1928         /***** key management */
1929         if (res < 0) {
1930                 const char *args[] = {
1931                         "wpa-psk", "wpa-eap", "ieee8021x", "wpa-none",
1932 #ifdef CONFIG_WPS
1933                         "wps",
1934 #endif /* CONFIG_WPS */
1935                         "none"
1936                 };
1937                 if (!wpa_dbus_dict_append_string_array(
1938                             &iter_dict, "KeyMgmt", args,
1939                             sizeof(args) / sizeof(char*)))
1940                         goto nomem;
1941         } else {
1942                 if (!wpa_dbus_dict_begin_string_array(&iter_dict, "KeyMgmt",
1943                                                       &iter_dict_entry,
1944                                                       &iter_dict_val,
1945                                                       &iter_array))
1946                         goto nomem;
1947
1948                 if (!wpa_dbus_dict_string_array_add_element(&iter_array,
1949                                                             "none"))
1950                         goto nomem;
1951
1952                 if (!wpa_dbus_dict_string_array_add_element(&iter_array,
1953                                                             "ieee8021x"))
1954                         goto nomem;
1955
1956                 if (capa.key_mgmt & (WPA_DRIVER_CAPA_KEY_MGMT_WPA |
1957                                      WPA_DRIVER_CAPA_KEY_MGMT_WPA2)) {
1958                         if (!wpa_dbus_dict_string_array_add_element(
1959                                     &iter_array, "wpa-eap"))
1960                                 goto nomem;
1961
1962                         if (capa.key_mgmt & WPA_DRIVER_CAPA_KEY_MGMT_FT)
1963                                 if (!wpa_dbus_dict_string_array_add_element(
1964                                             &iter_array, "wpa-ft-eap"))
1965                                         goto nomem;
1966
1967 /* TODO: Ensure that driver actually supports sha256 encryption. */
1968 #ifdef CONFIG_IEEE80211W
1969                         if (!wpa_dbus_dict_string_array_add_element(
1970                                     &iter_array, "wpa-eap-sha256"))
1971                                 goto nomem;
1972 #endif /* CONFIG_IEEE80211W */
1973                 }
1974
1975                 if (capa.key_mgmt & (WPA_DRIVER_CAPA_KEY_MGMT_WPA_PSK |
1976                                      WPA_DRIVER_CAPA_KEY_MGMT_WPA2_PSK)) {
1977                         if (!wpa_dbus_dict_string_array_add_element(
1978                                     &iter_array, "wpa-psk"))
1979                                 goto nomem;
1980
1981                         if (capa.key_mgmt & WPA_DRIVER_CAPA_KEY_MGMT_FT_PSK)
1982                                 if (!wpa_dbus_dict_string_array_add_element(
1983                                             &iter_array, "wpa-ft-psk"))
1984                                         goto nomem;
1985
1986 /* TODO: Ensure that driver actually supports sha256 encryption. */
1987 #ifdef CONFIG_IEEE80211W
1988                         if (!wpa_dbus_dict_string_array_add_element(
1989                                     &iter_array, "wpa-psk-sha256"))
1990                                 goto nomem;
1991 #endif /* CONFIG_IEEE80211W */
1992                 }
1993
1994                 if (capa.key_mgmt & WPA_DRIVER_CAPA_KEY_MGMT_WPA_NONE) {
1995                         if (!wpa_dbus_dict_string_array_add_element(
1996                                     &iter_array, "wpa-none"))
1997                                 goto nomem;
1998                 }
1999
2000
2001 #ifdef CONFIG_WPS
2002                 if (!wpa_dbus_dict_string_array_add_element(&iter_array,
2003                                                             "wps"))
2004                         goto nomem;
2005 #endif /* CONFIG_WPS */
2006
2007                 if (!wpa_dbus_dict_end_string_array(&iter_dict,
2008                                                     &iter_dict_entry,
2009                                                     &iter_dict_val,
2010                                                     &iter_array))
2011                         goto nomem;
2012         }
2013
2014         /***** WPA protocol */
2015         if (res < 0) {
2016                 const char *args[] = { "rsn", "wpa" };
2017                 if (!wpa_dbus_dict_append_string_array(
2018                             &iter_dict, "Protocol", args,
2019                             sizeof(args) / sizeof(char*)))
2020                         goto nomem;
2021         } else {
2022                 if (!wpa_dbus_dict_begin_string_array(&iter_dict, "Protocol",
2023                                                       &iter_dict_entry,
2024                                                       &iter_dict_val,
2025                                                       &iter_array))
2026                         goto nomem;
2027
2028                 if (capa.key_mgmt & (WPA_DRIVER_CAPA_KEY_MGMT_WPA2 |
2029                                      WPA_DRIVER_CAPA_KEY_MGMT_WPA2_PSK)) {
2030                         if (!wpa_dbus_dict_string_array_add_element(
2031                                     &iter_array, "rsn"))
2032                                 goto nomem;
2033                 }
2034
2035                 if (capa.key_mgmt & (WPA_DRIVER_CAPA_KEY_MGMT_WPA |
2036                                      WPA_DRIVER_CAPA_KEY_MGMT_WPA_PSK)) {
2037                         if (!wpa_dbus_dict_string_array_add_element(
2038                                     &iter_array, "wpa"))
2039                                 goto nomem;
2040                 }
2041
2042                 if (!wpa_dbus_dict_end_string_array(&iter_dict,
2043                                                     &iter_dict_entry,
2044                                                     &iter_dict_val,
2045                                                     &iter_array))
2046                         goto nomem;
2047         }
2048
2049         /***** auth alg */
2050         if (res < 0) {
2051                 const char *args[] = { "open", "shared", "leap" };
2052                 if (!wpa_dbus_dict_append_string_array(
2053                             &iter_dict, "AuthAlg", args,
2054                             sizeof(args) / sizeof(char*)))
2055                         goto nomem;
2056         } else {
2057                 if (!wpa_dbus_dict_begin_string_array(&iter_dict, "AuthAlg",
2058                                                       &iter_dict_entry,
2059                                                       &iter_dict_val,
2060                                                       &iter_array))
2061                         goto nomem;
2062
2063                 if (capa.auth & (WPA_DRIVER_AUTH_OPEN)) {
2064                         if (!wpa_dbus_dict_string_array_add_element(
2065                                     &iter_array, "open"))
2066                                 goto nomem;
2067                 }
2068
2069                 if (capa.auth & (WPA_DRIVER_AUTH_SHARED)) {
2070                         if (!wpa_dbus_dict_string_array_add_element(
2071                                     &iter_array, "shared"))
2072                                 goto nomem;
2073                 }
2074
2075                 if (capa.auth & (WPA_DRIVER_AUTH_LEAP)) {
2076                         if (!wpa_dbus_dict_string_array_add_element(
2077                                     &iter_array, "leap"))
2078                                 goto nomem;
2079                 }
2080
2081                 if (!wpa_dbus_dict_end_string_array(&iter_dict,
2082                                                     &iter_dict_entry,
2083                                                     &iter_dict_val,
2084                                                     &iter_array))
2085                         goto nomem;
2086         }
2087
2088         /***** Scan */
2089         if (!wpa_dbus_dict_append_string_array(&iter_dict, "Scan", scans,
2090                                                sizeof(scans) / sizeof(char *)))
2091                 goto nomem;
2092
2093         /***** Modes */
2094         if (!wpa_dbus_dict_begin_string_array(&iter_dict, "Modes",
2095                                               &iter_dict_entry,
2096                                               &iter_dict_val,
2097                                               &iter_array))
2098                 goto nomem;
2099
2100         if (!wpa_dbus_dict_string_array_add_element(
2101                             &iter_array, "infrastructure"))
2102                 goto nomem;
2103
2104         if (!wpa_dbus_dict_string_array_add_element(
2105                             &iter_array, "ad-hoc"))
2106                 goto nomem;
2107
2108         if (res >= 0) {
2109                 if (capa.flags & (WPA_DRIVER_FLAGS_AP)) {
2110                         if (!wpa_dbus_dict_string_array_add_element(
2111                                     &iter_array, "ap"))
2112                                 goto nomem;
2113                 }
2114
2115                 if (capa.flags & (WPA_DRIVER_FLAGS_P2P_CAPABLE)) {
2116                         if (!wpa_dbus_dict_string_array_add_element(
2117                                     &iter_array, "p2p"))
2118                                 goto nomem;
2119                 }
2120         }
2121
2122         if (!wpa_dbus_dict_end_string_array(&iter_dict,
2123                                             &iter_dict_entry,
2124                                             &iter_dict_val,
2125                                             &iter_array))
2126                 goto nomem;
2127         /***** Modes end */
2128
2129         if (res >= 0) {
2130                 dbus_int32_t max_scan_ssid = capa.max_scan_ssids;
2131
2132                 if (!wpa_dbus_dict_append_int32(&iter_dict, "MaxScanSSID",
2133                                                 max_scan_ssid))
2134                         goto nomem;
2135         }
2136
2137         if (!wpa_dbus_dict_close_write(&variant_iter, &iter_dict))
2138                 goto nomem;
2139         if (!dbus_message_iter_close_container(iter, &variant_iter))
2140                 goto nomem;
2141
2142         return TRUE;
2143
2144 nomem:
2145         dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
2146         return FALSE;
2147 }
2148
2149
2150 /**
2151  * wpas_dbus_getter_state - Get interface state
2152  * @iter: Pointer to incoming dbus message iter
2153  * @error: Location to store error on failure
2154  * @user_data: Function specific data
2155  * Returns: TRUE on success, FALSE on failure
2156  *
2157  * Getter for "State" property.
2158  */
2159 dbus_bool_t wpas_dbus_getter_state(DBusMessageIter *iter, DBusError *error,
2160                                    void *user_data)
2161 {
2162         struct wpa_supplicant *wpa_s = user_data;
2163         const char *str_state;
2164         char *state_ls, *tmp;
2165         dbus_bool_t success = FALSE;
2166
2167         str_state = wpa_supplicant_state_txt(wpa_s->wpa_state);
2168
2169         /* make state string lowercase to fit new DBus API convention
2170          */
2171         state_ls = tmp = os_strdup(str_state);
2172         if (!tmp) {
2173                 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
2174                 return FALSE;
2175         }
2176         while (*tmp) {
2177                 *tmp = tolower(*tmp);
2178                 tmp++;
2179         }
2180
2181         success = wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING,
2182                                                    &state_ls, error);
2183
2184         os_free(state_ls);
2185
2186         return success;
2187 }
2188
2189
2190 /**
2191  * wpas_dbus_new_iface_get_scanning - Get interface scanning state
2192  * @iter: Pointer to incoming dbus message iter
2193  * @error: Location to store error on failure
2194  * @user_data: Function specific data
2195  * Returns: TRUE on success, FALSE on failure
2196  *
2197  * Getter for "scanning" property.
2198  */
2199 dbus_bool_t wpas_dbus_getter_scanning(DBusMessageIter *iter, DBusError *error,
2200                                       void *user_data)
2201 {
2202         struct wpa_supplicant *wpa_s = user_data;
2203         dbus_bool_t scanning = wpa_s->scanning ? TRUE : FALSE;
2204
2205         return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_BOOLEAN,
2206                                                 &scanning, error);
2207 }
2208
2209
2210 /**
2211  * wpas_dbus_getter_ap_scan - Control roaming mode
2212  * @iter: Pointer to incoming dbus message iter
2213  * @error: Location to store error on failure
2214  * @user_data: Function specific data
2215  * Returns: TRUE on success, FALSE on failure
2216  *
2217  * Getter function for "ApScan" property.
2218  */
2219 dbus_bool_t wpas_dbus_getter_ap_scan(DBusMessageIter *iter, DBusError *error,
2220                                      void *user_data)
2221 {
2222         struct wpa_supplicant *wpa_s = user_data;
2223         dbus_uint32_t ap_scan = wpa_s->conf->ap_scan;
2224
2225         return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_UINT32,
2226                                                 &ap_scan, error);
2227 }
2228
2229
2230 /**
2231  * wpas_dbus_setter_ap_scan - Control roaming mode
2232  * @iter: Pointer to incoming dbus message iter
2233  * @error: Location to store error on failure
2234  * @user_data: Function specific data
2235  * Returns: TRUE on success, FALSE on failure
2236  *
2237  * Setter function for "ApScan" property.
2238  */
2239 dbus_bool_t wpas_dbus_setter_ap_scan(DBusMessageIter *iter, DBusError *error,
2240                                      void *user_data)
2241 {
2242         struct wpa_supplicant *wpa_s = user_data;
2243         dbus_uint32_t ap_scan;
2244
2245         if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_UINT32,
2246                                               &ap_scan))
2247                 return FALSE;
2248
2249         if (wpa_supplicant_set_ap_scan(wpa_s, ap_scan)) {
2250                 dbus_set_error_const(error, DBUS_ERROR_FAILED,
2251                                      "ap_scan must be 0, 1, or 2");
2252                 return FALSE;
2253         }
2254         return TRUE;
2255 }
2256
2257
2258 /**
2259  * wpas_dbus_getter_fast_reauth - Control fast
2260  * reauthentication (TLS session resumption)
2261  * @iter: Pointer to incoming dbus message iter
2262  * @error: Location to store error on failure
2263  * @user_data: Function specific data
2264  * Returns: TRUE on success, FALSE on failure
2265  *
2266  * Getter function for "FastReauth" property.
2267  */
2268 dbus_bool_t wpas_dbus_getter_fast_reauth(DBusMessageIter *iter,
2269                                          DBusError *error,
2270                                          void *user_data)
2271 {
2272         struct wpa_supplicant *wpa_s = user_data;
2273         dbus_bool_t fast_reauth = wpa_s->conf->fast_reauth ? TRUE : FALSE;
2274
2275         return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_BOOLEAN,
2276                                                 &fast_reauth, error);
2277 }
2278
2279
2280 /**
2281  * wpas_dbus_setter_fast_reauth - Control fast
2282  * reauthentication (TLS session resumption)
2283  * @iter: Pointer to incoming dbus message iter
2284  * @error: Location to store error on failure
2285  * @user_data: Function specific data
2286  * Returns: TRUE on success, FALSE on failure
2287  *
2288  * Setter function for "FastReauth" property.
2289  */
2290 dbus_bool_t wpas_dbus_setter_fast_reauth(DBusMessageIter *iter,
2291                                      DBusError *error,
2292                                      void *user_data)
2293 {
2294         struct wpa_supplicant *wpa_s = user_data;
2295         dbus_bool_t fast_reauth;
2296
2297         if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_BOOLEAN,
2298                                               &fast_reauth))
2299                 return FALSE;
2300
2301         wpa_s->conf->fast_reauth = fast_reauth;
2302         return TRUE;
2303 }
2304
2305
2306 /**
2307  * wpas_dbus_getter_bss_expire_age - Get BSS entry expiration age
2308  * @iter: Pointer to incoming dbus message iter
2309  * @error: Location to store error on failure
2310  * @user_data: Function specific data
2311  * Returns: TRUE on success, FALSE on failure
2312  *
2313  * Getter function for "BSSExpireAge" property.
2314  */
2315 dbus_bool_t wpas_dbus_getter_bss_expire_age(DBusMessageIter *iter,
2316                                             DBusError *error,
2317                                             void *user_data)
2318 {
2319         struct wpa_supplicant *wpa_s = user_data;
2320         dbus_uint32_t expire_age = wpa_s->conf->bss_expiration_age;
2321
2322         return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_UINT32,
2323                                                 &expire_age, error);
2324 }
2325
2326
2327 /**
2328  * wpas_dbus_setter_bss_expire_age - Control BSS entry expiration age
2329  * @iter: Pointer to incoming dbus message iter
2330  * @error: Location to store error on failure
2331  * @user_data: Function specific data
2332  * Returns: TRUE on success, FALSE on failure
2333  *
2334  * Setter function for "BSSExpireAge" property.
2335  */
2336 dbus_bool_t wpas_dbus_setter_bss_expire_age(DBusMessageIter *iter,
2337                                             DBusError *error,
2338                                             void *user_data)
2339 {
2340         struct wpa_supplicant *wpa_s = user_data;
2341         dbus_uint32_t expire_age;
2342
2343         if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_UINT32,
2344                                               &expire_age))
2345                 return FALSE;
2346
2347         if (wpa_supplicant_set_bss_expiration_age(wpa_s, expire_age)) {
2348                 dbus_set_error_const(error, DBUS_ERROR_FAILED,
2349                                      "BSSExpireAge must be >= 10");
2350                 return FALSE;
2351         }
2352         return TRUE;
2353 }
2354
2355
2356 /**
2357  * wpas_dbus_getter_bss_expire_count - Get BSS entry expiration scan count
2358  * @iter: Pointer to incoming dbus message iter
2359  * @error: Location to store error on failure
2360  * @user_data: Function specific data
2361  * Returns: TRUE on success, FALSE on failure
2362  *
2363  * Getter function for "BSSExpireCount" property.
2364  */
2365 dbus_bool_t wpas_dbus_getter_bss_expire_count(DBusMessageIter *iter,
2366                                               DBusError *error,
2367                                               void *user_data)
2368 {
2369         struct wpa_supplicant *wpa_s = user_data;
2370         dbus_uint32_t expire_count = wpa_s->conf->bss_expiration_age;
2371
2372         return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_UINT32,
2373                                                 &expire_count, error);
2374 }
2375
2376
2377 /**
2378  * wpas_dbus_setter_bss_expire_count - Control BSS entry expiration scan count
2379  * @iter: Pointer to incoming dbus message iter
2380  * @error: Location to store error on failure
2381  * @user_data: Function specific data
2382  * Returns: TRUE on success, FALSE on failure
2383  *
2384  * Setter function for "BSSExpireCount" property.
2385  */
2386 dbus_bool_t wpas_dbus_setter_bss_expire_count(DBusMessageIter *iter,
2387                                               DBusError *error,
2388                                               void *user_data)
2389 {
2390         struct wpa_supplicant *wpa_s = user_data;
2391         dbus_uint32_t expire_count;
2392
2393         if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_UINT32,
2394                                               &expire_count))
2395                 return FALSE;
2396
2397         if (wpa_supplicant_set_bss_expiration_count(wpa_s, expire_count)) {
2398                 dbus_set_error_const(error, DBUS_ERROR_FAILED,
2399                                      "BSSExpireCount must be > 0");
2400                 return FALSE;
2401         }
2402         return TRUE;
2403 }
2404
2405
2406 /**
2407  * wpas_dbus_getter_country - Control country code
2408  * @iter: Pointer to incoming dbus message iter
2409  * @error: Location to store error on failure
2410  * @user_data: Function specific data
2411  * Returns: TRUE on success, FALSE on failure
2412  *
2413  * Getter function for "Country" property.
2414  */
2415 dbus_bool_t wpas_dbus_getter_country(DBusMessageIter *iter, DBusError *error,
2416                                      void *user_data)
2417 {
2418         struct wpa_supplicant *wpa_s = user_data;
2419         char country[3];
2420         char *str = country;
2421
2422         country[0] = wpa_s->conf->country[0];
2423         country[1] = wpa_s->conf->country[1];
2424         country[2] = '\0';
2425
2426         return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING,
2427                                                 &str, error);
2428 }
2429
2430
2431 /**
2432  * wpas_dbus_setter_country - Control country code
2433  * @iter: Pointer to incoming dbus message iter
2434  * @error: Location to store error on failure
2435  * @user_data: Function specific data
2436  * Returns: TRUE on success, FALSE on failure
2437  *
2438  * Setter function for "Country" property.
2439  */
2440 dbus_bool_t wpas_dbus_setter_country(DBusMessageIter *iter, DBusError *error,
2441                                      void *user_data)
2442 {
2443         struct wpa_supplicant *wpa_s = user_data;
2444         const char *country;
2445
2446         if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_STRING,
2447                                               &country))
2448                 return FALSE;
2449
2450         if (!country[0] || !country[1]) {
2451                 dbus_set_error_const(error, DBUS_ERROR_FAILED,
2452                                      "invalid country code");
2453                 return FALSE;
2454         }
2455
2456         if (wpa_s->drv_priv != NULL && wpa_drv_set_country(wpa_s, country)) {
2457                 wpa_printf(MSG_DEBUG, "Failed to set country");
2458                 dbus_set_error_const(error, DBUS_ERROR_FAILED,
2459                                      "failed to set country code");
2460                 return FALSE;
2461         }
2462
2463         wpa_s->conf->country[0] = country[0];
2464         wpa_s->conf->country[1] = country[1];
2465         return TRUE;
2466 }
2467
2468
2469 /**
2470  * wpas_dbus_getter_scan_interval - Get scan interval
2471  * @iter: Pointer to incoming dbus message iter
2472  * @error: Location to store error on failure
2473  * @user_data: Function specific data
2474  * Returns: TRUE on success, FALSE on failure
2475  *
2476  * Getter function for "ScanInterval" property.
2477  */
2478 dbus_bool_t wpas_dbus_getter_scan_interval(DBusMessageIter *iter,
2479                                            DBusError *error,
2480                                            void *user_data)
2481 {
2482         struct wpa_supplicant *wpa_s = user_data;
2483         dbus_int32_t scan_interval = wpa_s->scan_interval;
2484
2485         return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_INT32,
2486                                                 &scan_interval, error);
2487 }
2488
2489
2490 /**
2491  * wpas_dbus_setter_scan_interval - Control scan interval
2492  * @iter: Pointer to incoming dbus message iter
2493  * @error: Location to store error on failure
2494  * @user_data: Function specific data
2495  * Returns: TRUE on success, FALSE on failure
2496  *
2497  * Setter function for "ScanInterval" property.
2498  */
2499 dbus_bool_t wpas_dbus_setter_scan_interval(DBusMessageIter *iter,
2500                                            DBusError *error,
2501                                            void *user_data)
2502 {
2503         struct wpa_supplicant *wpa_s = user_data;
2504         dbus_int32_t scan_interval;
2505
2506         if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_INT32,
2507                                               &scan_interval))
2508                 return FALSE;
2509
2510         if (wpa_supplicant_set_scan_interval(wpa_s, scan_interval)) {
2511                 dbus_set_error_const(error, DBUS_ERROR_FAILED,
2512                                      "scan_interval must be >= 0");
2513                 return FALSE;
2514         }
2515         return TRUE;
2516 }
2517
2518
2519 /**
2520  * wpas_dbus_getter_ifname - Get interface name
2521  * @iter: Pointer to incoming dbus message iter
2522  * @error: Location to store error on failure
2523  * @user_data: Function specific data
2524  * Returns: TRUE on success, FALSE on failure
2525  *
2526  * Getter for "Ifname" property.
2527  */
2528 dbus_bool_t wpas_dbus_getter_ifname(DBusMessageIter *iter, DBusError *error,
2529                                     void *user_data)
2530 {
2531         struct wpa_supplicant *wpa_s = user_data;
2532         const char *ifname = wpa_s->ifname;
2533
2534         return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING,
2535                                                 &ifname, error);
2536 }
2537
2538
2539 /**
2540  * wpas_dbus_getter_driver - Get interface name
2541  * @iter: Pointer to incoming dbus message iter
2542  * @error: Location to store error on failure
2543  * @user_data: Function specific data
2544  * Returns: TRUE on success, FALSE on failure
2545  *
2546  * Getter for "Driver" property.
2547  */
2548 dbus_bool_t wpas_dbus_getter_driver(DBusMessageIter *iter, DBusError *error,
2549                                     void *user_data)
2550 {
2551         struct wpa_supplicant *wpa_s = user_data;
2552         const char *driver;
2553
2554         if (wpa_s->driver == NULL || wpa_s->driver->name == NULL) {
2555                 wpa_printf(MSG_DEBUG, "wpas_dbus_getter_driver[dbus]: "
2556                            "wpa_s has no driver set");
2557                 dbus_set_error(error, DBUS_ERROR_FAILED, "%s: no driver set",
2558                                __func__);
2559                 return FALSE;
2560         }
2561
2562         driver = wpa_s->driver->name;
2563         return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING,
2564                                                 &driver, error);
2565 }
2566
2567
2568 /**
2569  * wpas_dbus_getter_current_bss - Get current bss object path
2570  * @iter: Pointer to incoming dbus message iter
2571  * @error: Location to store error on failure
2572  * @user_data: Function specific data
2573  * Returns: TRUE on success, FALSE on failure
2574  *
2575  * Getter for "CurrentBSS" property.
2576  */
2577 dbus_bool_t wpas_dbus_getter_current_bss(DBusMessageIter *iter,
2578                                          DBusError *error,
2579                                          void *user_data)
2580 {
2581         struct wpa_supplicant *wpa_s = user_data;
2582         char path_buf[WPAS_DBUS_OBJECT_PATH_MAX], *bss_obj_path = path_buf;
2583
2584         if (wpa_s->current_bss)
2585                 os_snprintf(bss_obj_path, WPAS_DBUS_OBJECT_PATH_MAX,
2586                             "%s/" WPAS_DBUS_NEW_BSSIDS_PART "/%u",
2587                             wpa_s->dbus_new_path, wpa_s->current_bss->id);
2588         else
2589                 os_snprintf(bss_obj_path, WPAS_DBUS_OBJECT_PATH_MAX, "/");
2590
2591         return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_OBJECT_PATH,
2592                                                 &bss_obj_path, error);
2593 }
2594
2595
2596 /**
2597  * wpas_dbus_getter_current_network - Get current network object path
2598  * @iter: Pointer to incoming dbus message iter
2599  * @error: Location to store error on failure
2600  * @user_data: Function specific data
2601  * Returns: TRUE on success, FALSE on failure
2602  *
2603  * Getter for "CurrentNetwork" property.
2604  */
2605 dbus_bool_t wpas_dbus_getter_current_network(DBusMessageIter *iter,
2606                                              DBusError *error,
2607                                              void *user_data)
2608 {
2609         struct wpa_supplicant *wpa_s = user_data;
2610         char path_buf[WPAS_DBUS_OBJECT_PATH_MAX], *net_obj_path = path_buf;
2611
2612         if (wpa_s->current_ssid)
2613                 os_snprintf(net_obj_path, WPAS_DBUS_OBJECT_PATH_MAX,
2614                             "%s/" WPAS_DBUS_NEW_NETWORKS_PART "/%u",
2615                             wpa_s->dbus_new_path, wpa_s->current_ssid->id);
2616         else
2617                 os_snprintf(net_obj_path, WPAS_DBUS_OBJECT_PATH_MAX, "/");
2618
2619         return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_OBJECT_PATH,
2620                                                 &net_obj_path, error);
2621 }
2622
2623
2624 /**
2625  * wpas_dbus_getter_current_auth_mode - Get current authentication type
2626  * @iter: Pointer to incoming dbus message iter
2627  * @error: Location to store error on failure
2628  * @user_data: Function specific data
2629  * Returns: TRUE on success, FALSE on failure
2630  *
2631  * Getter for "CurrentAuthMode" property.
2632  */
2633 dbus_bool_t wpas_dbus_getter_current_auth_mode(DBusMessageIter *iter,
2634                                                DBusError *error,
2635                                                void *user_data)
2636 {
2637         struct wpa_supplicant *wpa_s = user_data;
2638         const char *eap_mode;
2639         const char *auth_mode;
2640         char eap_mode_buf[WPAS_DBUS_AUTH_MODE_MAX];
2641
2642         if (wpa_s->wpa_state != WPA_COMPLETED) {
2643                 auth_mode = "INACTIVE";
2644         } else if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X ||
2645             wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
2646                 eap_mode = wpa_supplicant_get_eap_mode(wpa_s);
2647                 os_snprintf(eap_mode_buf, WPAS_DBUS_AUTH_MODE_MAX,
2648                             "EAP-%s", eap_mode);
2649                 auth_mode = eap_mode_buf;
2650
2651         } else {
2652                 auth_mode = wpa_key_mgmt_txt(wpa_s->key_mgmt,
2653                                              wpa_s->current_ssid->proto);
2654         }
2655
2656         return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING,
2657                                                 &auth_mode, error);
2658 }
2659
2660
2661 /**
2662  * wpas_dbus_getter_bridge_ifname - Get interface name
2663  * @iter: Pointer to incoming dbus message iter
2664  * @error: Location to store error on failure
2665  * @user_data: Function specific data
2666  * Returns: TRUE on success, FALSE on failure
2667  *
2668  * Getter for "BridgeIfname" property.
2669  */
2670 dbus_bool_t wpas_dbus_getter_bridge_ifname(DBusMessageIter *iter,
2671                                            DBusError *error,
2672                                            void *user_data)
2673 {
2674         struct wpa_supplicant *wpa_s = user_data;
2675         const char *bridge_ifname = wpa_s->bridge_ifname;
2676         return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING,
2677                                                 &bridge_ifname, error);
2678 }
2679
2680
2681 /**
2682  * wpas_dbus_getter_bsss - Get array of BSSs objects
2683  * @iter: Pointer to incoming dbus message iter
2684  * @error: Location to store error on failure
2685  * @user_data: Function specific data
2686  * Returns: TRUE on success, FALSE on failure
2687  *
2688  * Getter for "BSSs" property.
2689  */
2690 dbus_bool_t wpas_dbus_getter_bsss(DBusMessageIter *iter, DBusError *error,
2691                                   void *user_data)
2692 {
2693         struct wpa_supplicant *wpa_s = user_data;
2694         struct wpa_bss *bss;
2695         char **paths;
2696         unsigned int i = 0;
2697         dbus_bool_t success = FALSE;
2698
2699         paths = os_zalloc(wpa_s->num_bss * sizeof(char *));
2700         if (!paths) {
2701                 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
2702                 return FALSE;
2703         }
2704
2705         /* Loop through scan results and append each result's object path */
2706         dl_list_for_each(bss, &wpa_s->bss_id, struct wpa_bss, list_id) {
2707                 paths[i] = os_zalloc(WPAS_DBUS_OBJECT_PATH_MAX);
2708                 if (paths[i] == NULL) {
2709                         dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY,
2710                                              "no memory");
2711                         goto out;
2712                 }
2713                 /* Construct the object path for this BSS. */
2714                 os_snprintf(paths[i++], WPAS_DBUS_OBJECT_PATH_MAX,
2715                             "%s/" WPAS_DBUS_NEW_BSSIDS_PART "/%u",
2716                             wpa_s->dbus_new_path, bss->id);
2717         }
2718
2719         success = wpas_dbus_simple_array_property_getter(iter,
2720                                                          DBUS_TYPE_OBJECT_PATH,
2721                                                          paths, wpa_s->num_bss,
2722                                                          error);
2723
2724 out:
2725         while (i)
2726                 os_free(paths[--i]);
2727         os_free(paths);
2728         return success;
2729 }
2730
2731
2732 /**
2733  * wpas_dbus_getter_networks - Get array of networks objects
2734  * @iter: Pointer to incoming dbus message iter
2735  * @error: Location to store error on failure
2736  * @user_data: Function specific data
2737  * Returns: TRUE on success, FALSE on failure
2738  *
2739  * Getter for "Networks" property.
2740  */
2741 dbus_bool_t wpas_dbus_getter_networks(DBusMessageIter *iter, DBusError *error,
2742                                       void *user_data)
2743 {
2744         struct wpa_supplicant *wpa_s = user_data;
2745         struct wpa_ssid *ssid;
2746         char **paths;
2747         unsigned int i = 0, num = 0;
2748         dbus_bool_t success = FALSE;
2749
2750         if (wpa_s->conf == NULL) {
2751                 wpa_printf(MSG_ERROR, "%s[dbus]: An error occurred getting "
2752                            "networks list.", __func__);
2753                 dbus_set_error(error, DBUS_ERROR_FAILED, "%s: an error "
2754                                "occurred getting the networks list", __func__);
2755                 return FALSE;
2756         }
2757
2758         for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
2759                 if (!network_is_persistent_group(ssid))
2760                         num++;
2761
2762         paths = os_zalloc(num * sizeof(char *));
2763         if (!paths) {
2764                 dbus_set_error(error, DBUS_ERROR_NO_MEMORY, "no memory");
2765                 return FALSE;
2766         }
2767
2768         /* Loop through configured networks and append object path of each */
2769         for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) {
2770                 if (network_is_persistent_group(ssid))
2771                         continue;
2772                 paths[i] = os_zalloc(WPAS_DBUS_OBJECT_PATH_MAX);
2773                 if (paths[i] == NULL) {
2774                         dbus_set_error(error, DBUS_ERROR_NO_MEMORY, "no memory");
2775                         goto out;
2776                 }
2777
2778                 /* Construct the object path for this network. */
2779                 os_snprintf(paths[i++], WPAS_DBUS_OBJECT_PATH_MAX,
2780                             "%s/" WPAS_DBUS_NEW_NETWORKS_PART "/%d",
2781                             wpa_s->dbus_new_path, ssid->id);
2782         }
2783
2784         success = wpas_dbus_simple_array_property_getter(iter,
2785                                                          DBUS_TYPE_OBJECT_PATH,
2786                                                          paths, num, error);
2787
2788 out:
2789         while (i)
2790                 os_free(paths[--i]);
2791         os_free(paths);
2792         return success;
2793 }
2794
2795
2796 /**
2797  * wpas_dbus_getter_blobs - Get all blobs defined for this interface
2798  * @iter: Pointer to incoming dbus message iter
2799  * @error: Location to store error on failure
2800  * @user_data: Function specific data
2801  * Returns: TRUE on success, FALSE on failure
2802  *
2803  * Getter for "Blobs" property.
2804  */
2805 dbus_bool_t wpas_dbus_getter_blobs(DBusMessageIter *iter, DBusError *error,
2806                                    void *user_data)
2807 {
2808         struct wpa_supplicant *wpa_s = user_data;
2809         DBusMessageIter variant_iter, dict_iter, entry_iter, array_iter;
2810         struct wpa_config_blob *blob;
2811
2812         if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
2813                                               "a{say}", &variant_iter) ||
2814             !dbus_message_iter_open_container(&variant_iter, DBUS_TYPE_ARRAY,
2815                                               "{say}", &dict_iter)) {
2816                 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
2817                 return FALSE;
2818         }
2819
2820         blob = wpa_s->conf->blobs;
2821         while (blob) {
2822                 if (!dbus_message_iter_open_container(&dict_iter,
2823                                                       DBUS_TYPE_DICT_ENTRY,
2824                                                       NULL, &entry_iter) ||
2825                     !dbus_message_iter_append_basic(&entry_iter,
2826                                                     DBUS_TYPE_STRING,
2827                                                     &(blob->name)) ||
2828                     !dbus_message_iter_open_container(&entry_iter,
2829                                                       DBUS_TYPE_ARRAY,
2830                                                       DBUS_TYPE_BYTE_AS_STRING,
2831                                                       &array_iter) ||
2832                     !dbus_message_iter_append_fixed_array(&array_iter,
2833                                                           DBUS_TYPE_BYTE,
2834                                                           &(blob->data),
2835                                                           blob->len) ||
2836                     !dbus_message_iter_close_container(&entry_iter,
2837                                                        &array_iter) ||
2838                     !dbus_message_iter_close_container(&dict_iter,
2839                                                        &entry_iter)) {
2840                         dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY,
2841                                              "no memory");
2842                         return FALSE;
2843                 }
2844
2845                 blob = blob->next;
2846         }
2847
2848         if (!dbus_message_iter_close_container(&variant_iter, &dict_iter) ||
2849             !dbus_message_iter_close_container(iter, &variant_iter)) {
2850                 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
2851                 return FALSE;
2852         }
2853
2854         return TRUE;
2855 }
2856
2857
2858 static struct wpa_bss * get_bss_helper(struct bss_handler_args *args,
2859                                        DBusError *error, const char *func_name)
2860 {
2861         struct wpa_bss *res = wpa_bss_get_id(args->wpa_s, args->id);
2862
2863         if (!res) {
2864                 wpa_printf(MSG_ERROR, "%s[dbus]: no bss with id %d found",
2865                            func_name, args->id);
2866                 dbus_set_error(error, DBUS_ERROR_FAILED,
2867                                "%s: BSS %d not found",
2868                                func_name, args->id);
2869         }
2870
2871         return res;
2872 }
2873
2874
2875 /**
2876  * wpas_dbus_getter_bss_bssid - Return the BSSID of a BSS
2877  * @iter: Pointer to incoming dbus message iter
2878  * @error: Location to store error on failure
2879  * @user_data: Function specific data
2880  * Returns: TRUE on success, FALSE on failure
2881  *
2882  * Getter for "BSSID" property.
2883  */
2884 dbus_bool_t wpas_dbus_getter_bss_bssid(DBusMessageIter *iter, DBusError *error,
2885                                        void *user_data)
2886 {
2887         struct bss_handler_args *args = user_data;
2888         struct wpa_bss *res;
2889
2890         res = get_bss_helper(args, error, __func__);
2891         if (!res)
2892                 return FALSE;
2893
2894         return wpas_dbus_simple_array_property_getter(iter, DBUS_TYPE_BYTE,
2895                                                       res->bssid, ETH_ALEN,
2896                                                       error);
2897 }
2898
2899
2900 /**
2901  * wpas_dbus_getter_bss_ssid - Return the SSID of a BSS
2902  * @iter: Pointer to incoming dbus message iter
2903  * @error: Location to store error on failure
2904  * @user_data: Function specific data
2905  * Returns: TRUE on success, FALSE on failure
2906  *
2907  * Getter for "SSID" property.
2908  */
2909 dbus_bool_t wpas_dbus_getter_bss_ssid(DBusMessageIter *iter, DBusError *error,
2910                                       void *user_data)
2911 {
2912         struct bss_handler_args *args = user_data;
2913         struct wpa_bss *res;
2914
2915         res = get_bss_helper(args, error, __func__);
2916         if (!res)
2917                 return FALSE;
2918
2919         return wpas_dbus_simple_array_property_getter(iter, DBUS_TYPE_BYTE,
2920                                                       res->ssid, res->ssid_len,
2921                                                       error);
2922 }
2923
2924
2925 /**
2926  * wpas_dbus_getter_bss_privacy - Return the privacy flag of a BSS
2927  * @iter: Pointer to incoming dbus message iter
2928  * @error: Location to store error on failure
2929  * @user_data: Function specific data
2930  * Returns: TRUE on success, FALSE on failure
2931  *
2932  * Getter for "Privacy" property.
2933  */
2934 dbus_bool_t wpas_dbus_getter_bss_privacy(DBusMessageIter *iter,
2935                                          DBusError *error, void *user_data)
2936 {
2937         struct bss_handler_args *args = user_data;
2938         struct wpa_bss *res;
2939         dbus_bool_t privacy;
2940
2941         res = get_bss_helper(args, error, __func__);
2942         if (!res)
2943                 return FALSE;
2944
2945         privacy = (res->caps & IEEE80211_CAP_PRIVACY) ? TRUE : FALSE;
2946         return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_BOOLEAN,
2947                                                 &privacy, error);
2948 }
2949
2950
2951 /**
2952  * wpas_dbus_getter_bss_mode - Return the mode of a BSS
2953  * @iter: Pointer to incoming dbus message iter
2954  * @error: Location to store error on failure
2955  * @user_data: Function specific data
2956  * Returns: TRUE on success, FALSE on failure
2957  *
2958  * Getter for "Mode" property.
2959  */
2960 dbus_bool_t wpas_dbus_getter_bss_mode(DBusMessageIter *iter, DBusError *error,
2961                                       void *user_data)
2962 {
2963         struct bss_handler_args *args = user_data;
2964         struct wpa_bss *res;
2965         const char *mode;
2966
2967         res = get_bss_helper(args, error, __func__);
2968         if (!res)
2969                 return FALSE;
2970
2971         if (res->caps & IEEE80211_CAP_IBSS)
2972                 mode = "ad-hoc";
2973         else
2974                 mode = "infrastructure";
2975
2976         return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING,
2977                                                 &mode, error);
2978 }
2979
2980
2981 /**
2982  * wpas_dbus_getter_bss_level - Return the signal strength of a BSS
2983  * @iter: Pointer to incoming dbus message iter
2984  * @error: Location to store error on failure
2985  * @user_data: Function specific data
2986  * Returns: TRUE on success, FALSE on failure
2987  *
2988  * Getter for "Level" property.
2989  */
2990 dbus_bool_t wpas_dbus_getter_bss_signal(DBusMessageIter *iter,
2991                                         DBusError *error, void *user_data)
2992 {
2993         struct bss_handler_args *args = user_data;
2994         struct wpa_bss *res;
2995         s16 level;
2996
2997         res = get_bss_helper(args, error, __func__);
2998         if (!res)
2999                 return FALSE;
3000
3001         level = (s16) res->level;
3002         return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_INT16,
3003                                                 &level, error);
3004 }
3005
3006
3007 /**
3008  * wpas_dbus_getter_bss_frequency - Return the frequency of a BSS
3009  * @iter: Pointer to incoming dbus message iter
3010  * @error: Location to store error on failure
3011  * @user_data: Function specific data
3012  * Returns: TRUE on success, FALSE on failure
3013  *
3014  * Getter for "Frequency" property.
3015  */
3016 dbus_bool_t wpas_dbus_getter_bss_frequency(DBusMessageIter *iter,
3017                                            DBusError *error, void *user_data)
3018 {
3019         struct bss_handler_args *args = user_data;
3020         struct wpa_bss *res;
3021         u16 freq;
3022
3023         res = get_bss_helper(args, error, __func__);
3024         if (!res)
3025                 return FALSE;
3026
3027         freq = (u16) res->freq;
3028         return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_UINT16,
3029                                                 &freq, error);
3030 }
3031
3032
3033 static int cmp_u8s_desc(const void *a, const void *b)
3034 {
3035         return (*(u8 *) b - *(u8 *) a);
3036 }
3037
3038
3039 /**
3040  * wpas_dbus_getter_bss_rates - Return available bit rates of a BSS
3041  * @iter: Pointer to incoming dbus message iter
3042  * @error: Location to store error on failure
3043  * @user_data: Function specific data
3044  * Returns: TRUE on success, FALSE on failure
3045  *
3046  * Getter for "Rates" property.
3047  */
3048 dbus_bool_t wpas_dbus_getter_bss_rates(DBusMessageIter *iter,
3049                                        DBusError *error, void *user_data)
3050 {
3051         struct bss_handler_args *args = user_data;
3052         struct wpa_bss *res;
3053         u8 *ie_rates = NULL;
3054         u32 *real_rates;
3055         int rates_num, i;
3056         dbus_bool_t success = FALSE;
3057
3058         res = get_bss_helper(args, error, __func__);
3059         if (!res)
3060                 return FALSE;
3061
3062         rates_num = wpa_bss_get_bit_rates(res, &ie_rates);
3063         if (rates_num < 0)
3064                 return FALSE;
3065
3066         qsort(ie_rates, rates_num, 1, cmp_u8s_desc);
3067
3068         real_rates = os_malloc(sizeof(u32) * rates_num);
3069         if (!real_rates) {
3070                 os_free(ie_rates);
3071                 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
3072                 return FALSE;
3073         }
3074
3075         for (i = 0; i < rates_num; i++)
3076                 real_rates[i] = ie_rates[i] * 500000;
3077
3078         success = wpas_dbus_simple_array_property_getter(iter, DBUS_TYPE_UINT32,
3079                                                          real_rates, rates_num,
3080                                                          error);
3081
3082         os_free(ie_rates);
3083         os_free(real_rates);
3084         return success;
3085 }
3086
3087
3088 static dbus_bool_t wpas_dbus_get_bss_security_prop(DBusMessageIter *iter,
3089                                                    struct wpa_ie_data *ie_data,
3090                                                    DBusError *error)
3091 {
3092         DBusMessageIter iter_dict, variant_iter;
3093         const char *group;
3094         const char *pairwise[2]; /* max 2 pairwise ciphers is supported */
3095         const char *key_mgmt[7]; /* max 7 key managements may be supported */
3096         int n;
3097
3098         if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
3099                                               "a{sv}", &variant_iter))
3100                 goto nomem;
3101
3102         if (!wpa_dbus_dict_open_write(&variant_iter, &iter_dict))
3103                 goto nomem;
3104
3105         /* KeyMgmt */
3106         n = 0;
3107         if (ie_data->key_mgmt & WPA_KEY_MGMT_PSK)
3108                 key_mgmt[n++] = "wpa-psk";
3109         if (ie_data->key_mgmt & WPA_KEY_MGMT_FT_PSK)
3110                 key_mgmt[n++] = "wpa-ft-psk";
3111         if (ie_data->key_mgmt & WPA_KEY_MGMT_PSK_SHA256)
3112                 key_mgmt[n++] = "wpa-psk-sha256";
3113         if (ie_data->key_mgmt & WPA_KEY_MGMT_IEEE8021X)
3114                 key_mgmt[n++] = "wpa-eap";
3115         if (ie_data->key_mgmt & WPA_KEY_MGMT_FT_IEEE8021X)
3116                 key_mgmt[n++] = "wpa-ft-eap";
3117         if (ie_data->key_mgmt & WPA_KEY_MGMT_IEEE8021X_SHA256)
3118                 key_mgmt[n++] = "wpa-eap-sha256";
3119         if (ie_data->key_mgmt & WPA_KEY_MGMT_NONE)
3120                 key_mgmt[n++] = "wpa-none";
3121
3122         if (!wpa_dbus_dict_append_string_array(&iter_dict, "KeyMgmt",
3123                                                key_mgmt, n))
3124                 goto nomem;
3125
3126         /* Group */
3127         switch (ie_data->group_cipher) {
3128         case WPA_CIPHER_WEP40:
3129                 group = "wep40";
3130                 break;
3131         case WPA_CIPHER_TKIP:
3132                 group = "tkip";
3133                 break;
3134         case WPA_CIPHER_CCMP:
3135                 group = "ccmp";
3136                 break;
3137         case WPA_CIPHER_WEP104:
3138                 group = "wep104";
3139                 break;
3140         default:
3141                 group = "";
3142                 break;
3143         }
3144
3145         if (!wpa_dbus_dict_append_string(&iter_dict, "Group", group))
3146                 goto nomem;
3147
3148         /* Pairwise */
3149         n = 0;
3150         if (ie_data->pairwise_cipher & WPA_CIPHER_TKIP)
3151                 pairwise[n++] = "tkip";
3152         if (ie_data->pairwise_cipher & WPA_CIPHER_CCMP)
3153                 pairwise[n++] = "ccmp";
3154
3155         if (!wpa_dbus_dict_append_string_array(&iter_dict, "Pairwise",
3156                                                pairwise, n))
3157                 goto nomem;
3158
3159         /* Management group (RSN only) */
3160         if (ie_data->proto == WPA_PROTO_RSN) {
3161                 switch (ie_data->mgmt_group_cipher) {
3162 #ifdef CONFIG_IEEE80211W
3163                 case WPA_CIPHER_AES_128_CMAC:
3164                         group = "aes128cmac";
3165                         break;
3166 #endif /* CONFIG_IEEE80211W */
3167                 default:
3168                         group = "";
3169                         break;
3170                 }
3171
3172                 if (!wpa_dbus_dict_append_string(&iter_dict, "MgmtGroup",
3173                                                  group))
3174                         goto nomem;
3175         }
3176
3177         if (!wpa_dbus_dict_close_write(&variant_iter, &iter_dict))
3178                 goto nomem;
3179         if (!dbus_message_iter_close_container(iter, &variant_iter))
3180                 goto nomem;
3181
3182         return TRUE;
3183
3184 nomem:
3185         dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
3186         return FALSE;
3187 }
3188
3189
3190 /**
3191  * wpas_dbus_getter_bss_wpa - Return the WPA options of a BSS
3192  * @iter: Pointer to incoming dbus message iter
3193  * @error: Location to store error on failure
3194  * @user_data: Function specific data
3195  * Returns: TRUE on success, FALSE on failure
3196  *
3197  * Getter for "WPA" property.
3198  */
3199 dbus_bool_t wpas_dbus_getter_bss_wpa(DBusMessageIter *iter, DBusError *error,
3200                                      void *user_data)
3201 {
3202         struct bss_handler_args *args = user_data;
3203         struct wpa_bss *res;
3204         struct wpa_ie_data wpa_data;
3205         const u8 *ie;
3206
3207         res = get_bss_helper(args, error, __func__);
3208         if (!res)
3209                 return FALSE;
3210
3211         os_memset(&wpa_data, 0, sizeof(wpa_data));
3212         ie = wpa_bss_get_vendor_ie(res, WPA_IE_VENDOR_TYPE);
3213         if (ie) {
3214                 if (wpa_parse_wpa_ie(ie, 2 + ie[1], &wpa_data) < 0) {
3215                         dbus_set_error_const(error, DBUS_ERROR_FAILED,
3216                                              "failed to parse WPA IE");
3217                         return FALSE;
3218                 }
3219         }
3220
3221         return wpas_dbus_get_bss_security_prop(iter, &wpa_data, error);
3222 }
3223
3224
3225 /**
3226  * wpas_dbus_getter_bss_rsn - Return the RSN options of a BSS
3227  * @iter: Pointer to incoming dbus message iter
3228  * @error: Location to store error on failure
3229  * @user_data: Function specific data
3230  * Returns: TRUE on success, FALSE on failure
3231  *
3232  * Getter for "RSN" property.
3233  */
3234 dbus_bool_t wpas_dbus_getter_bss_rsn(DBusMessageIter *iter, DBusError *error,
3235                                      void *user_data)
3236 {
3237         struct bss_handler_args *args = user_data;
3238         struct wpa_bss *res;
3239         struct wpa_ie_data wpa_data;
3240         const u8 *ie;
3241
3242         res = get_bss_helper(args, error, __func__);
3243         if (!res)
3244                 return FALSE;
3245
3246         os_memset(&wpa_data, 0, sizeof(wpa_data));
3247         ie = wpa_bss_get_ie(res, WLAN_EID_RSN);
3248         if (ie) {
3249                 if (wpa_parse_wpa_ie(ie, 2 + ie[1], &wpa_data) < 0) {
3250                         dbus_set_error_const(error, DBUS_ERROR_FAILED,
3251                                              "failed to parse RSN IE");
3252                         return FALSE;
3253                 }
3254         }
3255
3256         return wpas_dbus_get_bss_security_prop(iter, &wpa_data, error);
3257 }
3258
3259
3260 /**
3261  * wpas_dbus_getter_bss_ies - Return all IEs of a BSS
3262  * @iter: Pointer to incoming dbus message iter
3263  * @error: Location to store error on failure
3264  * @user_data: Function specific data
3265  * Returns: TRUE on success, FALSE on failure
3266  *
3267  * Getter for "IEs" property.
3268  */
3269 dbus_bool_t wpas_dbus_getter_bss_ies(DBusMessageIter *iter, DBusError *error,
3270                                      void *user_data)
3271 {
3272         struct bss_handler_args *args = user_data;
3273         struct wpa_bss *res;
3274
3275         res = get_bss_helper(args, error, __func__);
3276         if (!res)
3277                 return FALSE;
3278
3279         return wpas_dbus_simple_array_property_getter(iter, DBUS_TYPE_BYTE,
3280                                                       res + 1, res->ie_len,
3281                                                       error);
3282 }
3283
3284
3285 /**
3286  * wpas_dbus_getter_enabled - Check whether network is enabled or disabled
3287  * @iter: Pointer to incoming dbus message iter
3288  * @error: Location to store error on failure
3289  * @user_data: Function specific data
3290  * Returns: TRUE on success, FALSE on failure
3291  *
3292  * Getter for "enabled" property of a configured network.
3293  */
3294 dbus_bool_t wpas_dbus_getter_enabled(DBusMessageIter *iter, DBusError *error,
3295                                      void *user_data)
3296 {
3297         struct network_handler_args *net = user_data;
3298         dbus_bool_t enabled = net->ssid->disabled ? FALSE : TRUE;
3299
3300         return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_BOOLEAN,
3301                                                 &enabled, error);
3302 }
3303
3304
3305 /**
3306  * wpas_dbus_setter_enabled - Mark a configured network as enabled or disabled
3307  * @iter: Pointer to incoming dbus message iter
3308  * @error: Location to store error on failure
3309  * @user_data: Function specific data
3310  * Returns: TRUE on success, FALSE on failure
3311  *
3312  * Setter for "Enabled" property of a configured network.
3313  */
3314 dbus_bool_t wpas_dbus_setter_enabled(DBusMessageIter *iter, DBusError *error,
3315                                      void *user_data)
3316 {
3317         struct network_handler_args *net = user_data;
3318         struct wpa_supplicant *wpa_s;
3319         struct wpa_ssid *ssid;
3320         dbus_bool_t enable;
3321
3322         if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_BOOLEAN,
3323                                               &enable))
3324                 return FALSE;
3325
3326         wpa_s = net->wpa_s;
3327         ssid = net->ssid;
3328
3329         if (enable)
3330                 wpa_supplicant_enable_network(wpa_s, ssid);
3331         else
3332                 wpa_supplicant_disable_network(wpa_s, ssid);
3333
3334         return TRUE;
3335 }
3336
3337
3338 /**
3339  * wpas_dbus_getter_network_properties - Get options for a configured network
3340  * @iter: Pointer to incoming dbus message iter
3341  * @error: Location to store error on failure
3342  * @user_data: Function specific data
3343  * Returns: TRUE on success, FALSE on failure
3344  *
3345  * Getter for "Properties" property of a configured network.
3346  */
3347 dbus_bool_t wpas_dbus_getter_network_properties(DBusMessageIter *iter,
3348                                                 DBusError *error,
3349                                                 void *user_data)
3350 {
3351         struct network_handler_args *net = user_data;
3352         DBusMessageIter variant_iter, dict_iter;
3353         char **iterator;
3354         char **props = wpa_config_get_all(net->ssid, 1);
3355         dbus_bool_t success = FALSE;
3356
3357         if (!props) {
3358                 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
3359                 return FALSE;
3360         }
3361
3362         if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT, "a{sv}",
3363                                               &variant_iter) ||
3364             !wpa_dbus_dict_open_write(&variant_iter, &dict_iter)) {
3365                 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
3366                 goto out;
3367         }
3368
3369         iterator = props;
3370         while (*iterator) {
3371                 if (!wpa_dbus_dict_append_string(&dict_iter, *iterator,
3372                                                  *(iterator + 1))) {
3373                         dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY,
3374                                              "no memory");
3375                         goto out;
3376                 }
3377                 iterator += 2;
3378         }
3379
3380
3381         if (!wpa_dbus_dict_close_write(&variant_iter, &dict_iter) ||
3382             !dbus_message_iter_close_container(iter, &variant_iter)) {
3383                 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
3384                 goto out;
3385         }
3386
3387         success = TRUE;
3388
3389 out:
3390         iterator = props;
3391         while (*iterator) {
3392                 os_free(*iterator);
3393                 iterator++;
3394         }
3395         os_free(props);
3396         return success;
3397 }
3398
3399
3400 /**
3401  * wpas_dbus_setter_network_properties - Set options for a configured network
3402  * @iter: Pointer to incoming dbus message iter
3403  * @error: Location to store error on failure
3404  * @user_data: Function specific data
3405  * Returns: TRUE on success, FALSE on failure
3406  *
3407  * Setter for "Properties" property of a configured network.
3408  */
3409 dbus_bool_t wpas_dbus_setter_network_properties(DBusMessageIter *iter,
3410                                                 DBusError *error,
3411                                                 void *user_data)
3412 {
3413         struct network_handler_args *net = user_data;
3414         struct wpa_ssid *ssid = net->ssid;
3415         DBusMessageIter variant_iter;
3416
3417         dbus_message_iter_recurse(iter, &variant_iter);
3418         return set_network_properties(net->wpa_s, ssid, &variant_iter, error);
3419 }
3420
3421
3422 #ifdef CONFIG_AP
3423
3424 DBusMessage * wpas_dbus_handler_subscribe_preq(
3425         DBusMessage *message, struct wpa_supplicant *wpa_s)
3426 {
3427         struct wpas_dbus_priv *priv = wpa_s->global->dbus;
3428         char *name;
3429
3430         if (wpa_s->preq_notify_peer != NULL) {
3431                 if (os_strcmp(dbus_message_get_sender(message),
3432                               wpa_s->preq_notify_peer) == 0)
3433                         return NULL;
3434
3435                 return dbus_message_new_error(message,
3436                         WPAS_DBUS_ERROR_SUBSCRIPTION_IN_USE,
3437                         "Another application is already subscribed");
3438         }
3439
3440         name = os_strdup(dbus_message_get_sender(message));
3441         if (!name)
3442                 return dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
3443                                               "out of memory");
3444
3445         wpa_s->preq_notify_peer = name;
3446
3447         /* Subscribe to clean up if application closes socket */
3448         wpas_dbus_subscribe_noc(priv);
3449
3450         /*
3451          * Double-check it's still alive to make sure that we didn't
3452          * miss the NameOwnerChanged signal, e.g. while strdup'ing.
3453          */
3454         if (!dbus_bus_name_has_owner(priv->con, name, NULL)) {
3455                 /*
3456                  * Application no longer exists, clean up.
3457                  * The return value is irrelevant now.
3458                  *
3459                  * Need to check if the NameOwnerChanged handling
3460                  * already cleaned up because we have processed
3461                  * DBus messages while checking if the name still
3462                  * has an owner.
3463                  */
3464                 if (!wpa_s->preq_notify_peer)
3465                         return NULL;
3466                 os_free(wpa_s->preq_notify_peer);
3467                 wpa_s->preq_notify_peer = NULL;
3468                 wpas_dbus_unsubscribe_noc(priv);
3469         }
3470
3471         return NULL;
3472 }
3473
3474
3475 DBusMessage * wpas_dbus_handler_unsubscribe_preq(
3476         DBusMessage *message, struct wpa_supplicant *wpa_s)
3477 {
3478         struct wpas_dbus_priv *priv = wpa_s->global->dbus;
3479
3480         if (!wpa_s->preq_notify_peer)
3481                 return dbus_message_new_error(message,
3482                         WPAS_DBUS_ERROR_NO_SUBSCRIPTION,
3483                         "Not subscribed");
3484
3485         if (os_strcmp(wpa_s->preq_notify_peer,
3486                       dbus_message_get_sender(message)))
3487                 return dbus_message_new_error(message,
3488                         WPAS_DBUS_ERROR_SUBSCRIPTION_EPERM,
3489                         "Can't unsubscribe others");
3490
3491         os_free(wpa_s->preq_notify_peer);
3492         wpa_s->preq_notify_peer = NULL;
3493         wpas_dbus_unsubscribe_noc(priv);
3494         return NULL;
3495 }
3496
3497
3498 void wpas_dbus_signal_preq(struct wpa_supplicant *wpa_s,
3499                            const u8 *addr, const u8 *dst, const u8 *bssid,
3500                            const u8 *ie, size_t ie_len, u32 ssi_signal)
3501 {
3502         DBusMessage *msg;
3503         DBusMessageIter iter, dict_iter;
3504         struct wpas_dbus_priv *priv = wpa_s->global->dbus;
3505
3506         /* Do nothing if the control interface is not turned on */
3507         if (priv == NULL)
3508                 return;
3509
3510         if (wpa_s->preq_notify_peer == NULL)
3511                 return;
3512
3513         msg = dbus_message_new_signal(wpa_s->dbus_new_path,
3514                                       WPAS_DBUS_NEW_IFACE_INTERFACE,
3515                                       "ProbeRequest");
3516         if (msg == NULL)
3517                 return;
3518
3519         dbus_message_set_destination(msg, wpa_s->preq_notify_peer);
3520
3521         dbus_message_iter_init_append(msg, &iter);
3522
3523         if (!wpa_dbus_dict_open_write(&iter, &dict_iter))
3524                 goto fail;
3525         if (addr && !wpa_dbus_dict_append_byte_array(&dict_iter, "addr",
3526                                                      (const char *) addr,
3527                                                      ETH_ALEN))
3528                 goto fail;
3529         if (dst && !wpa_dbus_dict_append_byte_array(&dict_iter, "dst",
3530                                                     (const char *) dst,
3531                                                     ETH_ALEN))
3532                 goto fail;
3533         if (bssid && !wpa_dbus_dict_append_byte_array(&dict_iter, "bssid",
3534                                                       (const char *) bssid,
3535                                                       ETH_ALEN))
3536                 goto fail;
3537         if (ie && ie_len && !wpa_dbus_dict_append_byte_array(&dict_iter, "ies",
3538                                                              (const char *) ie,
3539                                                              ie_len))
3540                 goto fail;
3541         if (ssi_signal && !wpa_dbus_dict_append_int32(&dict_iter, "signal",
3542                                                       ssi_signal))
3543                 goto fail;
3544         if (!wpa_dbus_dict_close_write(&iter, &dict_iter))
3545                 goto fail;
3546
3547         dbus_connection_send(priv->con, msg, NULL);
3548         goto out;
3549 fail:
3550         wpa_printf(MSG_ERROR, "dbus: Failed to construct signal");
3551 out:
3552         dbus_message_unref(msg);
3553 }
3554
3555 #endif /* CONFIG_AP */