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