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