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 (!wpa_dbus_dict_close_write(&variant_iter, &iter_dict))
1981                 goto nomem;
1982         if (!dbus_message_iter_close_container(iter, &variant_iter))
1983                 goto nomem;
1984
1985         return TRUE;
1986
1987 nomem:
1988         dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
1989         return FALSE;
1990 }
1991
1992
1993 /**
1994  * wpas_dbus_getter_state - Get interface state
1995  * @iter: Pointer to incoming dbus message iter
1996  * @error: Location to store error on failure
1997  * @user_data: Function specific data
1998  * Returns: TRUE on success, FALSE on failure
1999  *
2000  * Getter for "State" property.
2001  */
2002 dbus_bool_t wpas_dbus_getter_state(DBusMessageIter *iter, DBusError *error,
2003                                    void *user_data)
2004 {
2005         struct wpa_supplicant *wpa_s = user_data;
2006         const char *str_state;
2007         char *state_ls, *tmp;
2008         dbus_bool_t success = FALSE;
2009
2010         str_state = wpa_supplicant_state_txt(wpa_s->wpa_state);
2011
2012         /* make state string lowercase to fit new DBus API convention
2013          */
2014         state_ls = tmp = os_strdup(str_state);
2015         if (!tmp) {
2016                 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
2017                 return FALSE;
2018         }
2019         while (*tmp) {
2020                 *tmp = tolower(*tmp);
2021                 tmp++;
2022         }
2023
2024         success = wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING,
2025                                                    &state_ls, error);
2026
2027         os_free(state_ls);
2028
2029         return success;
2030 }
2031
2032
2033 /**
2034  * wpas_dbus_new_iface_get_scanning - Get interface scanning state
2035  * @iter: Pointer to incoming dbus message iter
2036  * @error: Location to store error on failure
2037  * @user_data: Function specific data
2038  * Returns: TRUE on success, FALSE on failure
2039  *
2040  * Getter for "scanning" property.
2041  */
2042 dbus_bool_t wpas_dbus_getter_scanning(DBusMessageIter *iter, DBusError *error,
2043                                       void *user_data)
2044 {
2045         struct wpa_supplicant *wpa_s = user_data;
2046         dbus_bool_t scanning = wpa_s->scanning ? TRUE : FALSE;
2047
2048         return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_BOOLEAN,
2049                                                 &scanning, error);
2050 }
2051
2052
2053 /**
2054  * wpas_dbus_getter_ap_scan - Control roaming mode
2055  * @iter: Pointer to incoming dbus message iter
2056  * @error: Location to store error on failure
2057  * @user_data: Function specific data
2058  * Returns: TRUE on success, FALSE on failure
2059  *
2060  * Getter function for "ApScan" property.
2061  */
2062 dbus_bool_t wpas_dbus_getter_ap_scan(DBusMessageIter *iter, DBusError *error,
2063                                      void *user_data)
2064 {
2065         struct wpa_supplicant *wpa_s = user_data;
2066         dbus_uint32_t ap_scan = wpa_s->conf->ap_scan;
2067
2068         return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_UINT32,
2069                                                 &ap_scan, error);
2070 }
2071
2072
2073 /**
2074  * wpas_dbus_setter_ap_scan - Control roaming mode
2075  * @iter: Pointer to incoming dbus message iter
2076  * @error: Location to store error on failure
2077  * @user_data: Function specific data
2078  * Returns: TRUE on success, FALSE on failure
2079  *
2080  * Setter function for "ApScan" property.
2081  */
2082 dbus_bool_t wpas_dbus_setter_ap_scan(DBusMessageIter *iter, DBusError *error,
2083                                      void *user_data)
2084 {
2085         struct wpa_supplicant *wpa_s = user_data;
2086         dbus_uint32_t ap_scan;
2087
2088         if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_UINT32,
2089                                               &ap_scan))
2090                 return FALSE;
2091
2092         if (wpa_supplicant_set_ap_scan(wpa_s, ap_scan)) {
2093                 dbus_set_error_const(error, DBUS_ERROR_FAILED,
2094                                      "ap_scan must be 0, 1, or 2");
2095                 return FALSE;
2096         }
2097         return TRUE;
2098 }
2099
2100
2101 /**
2102  * wpas_dbus_getter_bss_expire_age - Get BSS entry expiration age
2103  * @iter: Pointer to incoming dbus message iter
2104  * @error: Location to store error on failure
2105  * @user_data: Function specific data
2106  * Returns: TRUE on success, FALSE on failure
2107  *
2108  * Getter function for "BSSExpireAge" property.
2109  */
2110 dbus_bool_t wpas_dbus_getter_bss_expire_age(DBusMessageIter *iter,
2111                                             DBusError *error,
2112                                             void *user_data)
2113 {
2114         struct wpa_supplicant *wpa_s = user_data;
2115         dbus_uint32_t expire_age = wpa_s->conf->bss_expiration_age;
2116
2117         return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_UINT32,
2118                                                 &expire_age, error);
2119 }
2120
2121
2122 /**
2123  * wpas_dbus_setter_bss_expire_age - Control BSS entry expiration age
2124  * @iter: Pointer to incoming dbus message iter
2125  * @error: Location to store error on failure
2126  * @user_data: Function specific data
2127  * Returns: TRUE on success, FALSE on failure
2128  *
2129  * Setter function for "BSSExpireAge" property.
2130  */
2131 dbus_bool_t wpas_dbus_setter_bss_expire_age(DBusMessageIter *iter,
2132                                             DBusError *error,
2133                                             void *user_data)
2134 {
2135         struct wpa_supplicant *wpa_s = user_data;
2136         dbus_uint32_t expire_age;
2137
2138         if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_UINT32,
2139                                               &expire_age))
2140                 return FALSE;
2141
2142         if (wpa_supplicant_set_bss_expiration_age(wpa_s, expire_age)) {
2143                 dbus_set_error_const(error, DBUS_ERROR_FAILED,
2144                                      "BSSExpireAge must be >= 10");
2145                 return FALSE;
2146         }
2147         return TRUE;
2148 }
2149
2150
2151 /**
2152  * wpas_dbus_getter_bss_expire_count - Get BSS entry expiration scan count
2153  * @iter: Pointer to incoming dbus message iter
2154  * @error: Location to store error on failure
2155  * @user_data: Function specific data
2156  * Returns: TRUE on success, FALSE on failure
2157  *
2158  * Getter function for "BSSExpireCount" property.
2159  */
2160 dbus_bool_t wpas_dbus_getter_bss_expire_count(DBusMessageIter *iter,
2161                                               DBusError *error,
2162                                               void *user_data)
2163 {
2164         struct wpa_supplicant *wpa_s = user_data;
2165         dbus_uint32_t expire_count = wpa_s->conf->bss_expiration_age;
2166
2167         return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_UINT32,
2168                                                 &expire_count, error);
2169 }
2170
2171
2172 /**
2173  * wpas_dbus_setter_bss_expire_count - Control BSS entry expiration scan count
2174  * @iter: Pointer to incoming dbus message iter
2175  * @error: Location to store error on failure
2176  * @user_data: Function specific data
2177  * Returns: TRUE on success, FALSE on failure
2178  *
2179  * Setter function for "BSSExpireCount" property.
2180  */
2181 dbus_bool_t wpas_dbus_setter_bss_expire_count(DBusMessageIter *iter,
2182                                               DBusError *error,
2183                                               void *user_data)
2184 {
2185         struct wpa_supplicant *wpa_s = user_data;
2186         dbus_uint32_t expire_count;
2187
2188         if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_UINT32,
2189                                               &expire_count))
2190                 return FALSE;
2191
2192         if (wpa_supplicant_set_bss_expiration_count(wpa_s, expire_count)) {
2193                 dbus_set_error_const(error, DBUS_ERROR_FAILED,
2194                                      "BSSExpireCount must be > 0");
2195                 return FALSE;
2196         }
2197         return TRUE;
2198 }
2199
2200
2201 /**
2202  * wpas_dbus_getter_country - Control country code
2203  * @iter: Pointer to incoming dbus message iter
2204  * @error: Location to store error on failure
2205  * @user_data: Function specific data
2206  * Returns: TRUE on success, FALSE on failure
2207  *
2208  * Getter function for "Country" property.
2209  */
2210 dbus_bool_t wpas_dbus_getter_country(DBusMessageIter *iter, DBusError *error,
2211                                      void *user_data)
2212 {
2213         struct wpa_supplicant *wpa_s = user_data;
2214         char country[3];
2215         char *str = country;
2216
2217         country[0] = wpa_s->conf->country[0];
2218         country[1] = wpa_s->conf->country[1];
2219         country[2] = '\0';
2220
2221         return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING,
2222                                                 &str, error);
2223 }
2224
2225
2226 /**
2227  * wpas_dbus_setter_country - Control country code
2228  * @iter: Pointer to incoming dbus message iter
2229  * @error: Location to store error on failure
2230  * @user_data: Function specific data
2231  * Returns: TRUE on success, FALSE on failure
2232  *
2233  * Setter function for "Country" property.
2234  */
2235 dbus_bool_t wpas_dbus_setter_country(DBusMessageIter *iter, DBusError *error,
2236                                      void *user_data)
2237 {
2238         struct wpa_supplicant *wpa_s = user_data;
2239         const char *country;
2240
2241         if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_STRING,
2242                                               &country))
2243                 return FALSE;
2244
2245         if (!country[0] || !country[1]) {
2246                 dbus_set_error_const(error, DBUS_ERROR_FAILED,
2247                                      "invalid country code");
2248                 return FALSE;
2249         }
2250
2251         if (wpa_s->drv_priv != NULL && wpa_drv_set_country(wpa_s, country)) {
2252                 wpa_printf(MSG_DEBUG, "Failed to set country");
2253                 dbus_set_error_const(error, DBUS_ERROR_FAILED,
2254                                      "failed to set country code");
2255                 return FALSE;
2256         }
2257
2258         wpa_s->conf->country[0] = country[0];
2259         wpa_s->conf->country[1] = country[1];
2260         return TRUE;
2261 }
2262
2263
2264 /**
2265  * wpas_dbus_getter_ifname - Get interface name
2266  * @iter: Pointer to incoming dbus message iter
2267  * @error: Location to store error on failure
2268  * @user_data: Function specific data
2269  * Returns: TRUE on success, FALSE on failure
2270  *
2271  * Getter for "Ifname" property.
2272  */
2273 dbus_bool_t wpas_dbus_getter_ifname(DBusMessageIter *iter, DBusError *error,
2274                                     void *user_data)
2275 {
2276         struct wpa_supplicant *wpa_s = user_data;
2277         const char *ifname = wpa_s->ifname;
2278
2279         return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING,
2280                                                 &ifname, error);
2281 }
2282
2283
2284 /**
2285  * wpas_dbus_getter_driver - Get interface name
2286  * @iter: Pointer to incoming dbus message iter
2287  * @error: Location to store error on failure
2288  * @user_data: Function specific data
2289  * Returns: TRUE on success, FALSE on failure
2290  *
2291  * Getter for "Driver" property.
2292  */
2293 dbus_bool_t wpas_dbus_getter_driver(DBusMessageIter *iter, DBusError *error,
2294                                     void *user_data)
2295 {
2296         struct wpa_supplicant *wpa_s = user_data;
2297         const char *driver;
2298
2299         if (wpa_s->driver == NULL || wpa_s->driver->name == NULL) {
2300                 wpa_printf(MSG_DEBUG, "wpas_dbus_getter_driver[dbus]: "
2301                            "wpa_s has no driver set");
2302                 dbus_set_error(error, DBUS_ERROR_FAILED, "%s: no driver set",
2303                                __func__);
2304                 return FALSE;
2305         }
2306
2307         driver = wpa_s->driver->name;
2308         return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING,
2309                                                 &driver, error);
2310 }
2311
2312
2313 /**
2314  * wpas_dbus_getter_current_bss - Get current bss object path
2315  * @iter: Pointer to incoming dbus message iter
2316  * @error: Location to store error on failure
2317  * @user_data: Function specific data
2318  * Returns: TRUE on success, FALSE on failure
2319  *
2320  * Getter for "CurrentBSS" property.
2321  */
2322 dbus_bool_t wpas_dbus_getter_current_bss(DBusMessageIter *iter,
2323                                          DBusError *error,
2324                                          void *user_data)
2325 {
2326         struct wpa_supplicant *wpa_s = user_data;
2327         char path_buf[WPAS_DBUS_OBJECT_PATH_MAX], *bss_obj_path = path_buf;
2328
2329         if (wpa_s->current_bss)
2330                 os_snprintf(bss_obj_path, WPAS_DBUS_OBJECT_PATH_MAX,
2331                             "%s/" WPAS_DBUS_NEW_BSSIDS_PART "/%u",
2332                             wpa_s->dbus_new_path, wpa_s->current_bss->id);
2333         else
2334                 os_snprintf(bss_obj_path, WPAS_DBUS_OBJECT_PATH_MAX, "/");
2335
2336         return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_OBJECT_PATH,
2337                                                 &bss_obj_path, error);
2338 }
2339
2340
2341 /**
2342  * wpas_dbus_getter_current_network - Get current network object path
2343  * @iter: Pointer to incoming dbus message iter
2344  * @error: Location to store error on failure
2345  * @user_data: Function specific data
2346  * Returns: TRUE on success, FALSE on failure
2347  *
2348  * Getter for "CurrentNetwork" property.
2349  */
2350 dbus_bool_t wpas_dbus_getter_current_network(DBusMessageIter *iter,
2351                                              DBusError *error,
2352                                              void *user_data)
2353 {
2354         struct wpa_supplicant *wpa_s = user_data;
2355         char path_buf[WPAS_DBUS_OBJECT_PATH_MAX], *net_obj_path = path_buf;
2356
2357         if (wpa_s->current_ssid)
2358                 os_snprintf(net_obj_path, WPAS_DBUS_OBJECT_PATH_MAX,
2359                             "%s/" WPAS_DBUS_NEW_NETWORKS_PART "/%u",
2360                             wpa_s->dbus_new_path, wpa_s->current_ssid->id);
2361         else
2362                 os_snprintf(net_obj_path, WPAS_DBUS_OBJECT_PATH_MAX, "/");
2363
2364         return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_OBJECT_PATH,
2365                                                 &net_obj_path, error);
2366 }
2367
2368
2369 /**
2370  * wpas_dbus_getter_current_auth_mode - Get current authentication type
2371  * @iter: Pointer to incoming dbus message iter
2372  * @error: Location to store error on failure
2373  * @user_data: Function specific data
2374  * Returns: TRUE on success, FALSE on failure
2375  *
2376  * Getter for "CurrentAuthMode" property.
2377  */
2378 dbus_bool_t wpas_dbus_getter_current_auth_mode(DBusMessageIter *iter,
2379                                                DBusError *error,
2380                                                void *user_data)
2381 {
2382         struct wpa_supplicant *wpa_s = user_data;
2383         const char *eap_mode;
2384         const char *auth_mode;
2385         char eap_mode_buf[WPAS_DBUS_AUTH_MODE_MAX];
2386
2387         if (wpa_s->wpa_state != WPA_COMPLETED) {
2388                 auth_mode = "INACTIVE";
2389         } else if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X ||
2390             wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
2391                 eap_mode = wpa_supplicant_get_eap_mode(wpa_s);
2392                 os_snprintf(eap_mode_buf, WPAS_DBUS_AUTH_MODE_MAX,
2393                             "EAP-%s", eap_mode);
2394                 auth_mode = eap_mode_buf;
2395
2396         } else {
2397                 auth_mode = wpa_key_mgmt_txt(wpa_s->key_mgmt,
2398                                              wpa_s->current_ssid->proto);
2399         }
2400
2401         return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING,
2402                                                 &auth_mode, error);
2403 }
2404
2405
2406 /**
2407  * wpas_dbus_getter_bridge_ifname - Get interface name
2408  * @iter: Pointer to incoming dbus message iter
2409  * @error: Location to store error on failure
2410  * @user_data: Function specific data
2411  * Returns: TRUE on success, FALSE on failure
2412  *
2413  * Getter for "BridgeIfname" property.
2414  */
2415 dbus_bool_t wpas_dbus_getter_bridge_ifname(DBusMessageIter *iter,
2416                                            DBusError *error,
2417                                            void *user_data)
2418 {
2419         struct wpa_supplicant *wpa_s = user_data;
2420         const char *bridge_ifname;
2421
2422         bridge_ifname = wpa_s->bridge_ifname ? wpa_s->bridge_ifname : "";
2423         return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING,
2424                                                 &bridge_ifname, error);
2425 }
2426
2427
2428 /**
2429  * wpas_dbus_getter_bsss - Get array of BSSs objects
2430  * @iter: Pointer to incoming dbus message iter
2431  * @error: Location to store error on failure
2432  * @user_data: Function specific data
2433  * Returns: TRUE on success, FALSE on failure
2434  *
2435  * Getter for "BSSs" property.
2436  */
2437 dbus_bool_t wpas_dbus_getter_bsss(DBusMessageIter *iter, DBusError *error,
2438                                   void *user_data)
2439 {
2440         struct wpa_supplicant *wpa_s = user_data;
2441         struct wpa_bss *bss;
2442         char **paths;
2443         unsigned int i = 0;
2444         dbus_bool_t success = FALSE;
2445
2446         paths = os_zalloc(wpa_s->num_bss * sizeof(char *));
2447         if (!paths) {
2448                 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
2449                 return FALSE;
2450         }
2451
2452         /* Loop through scan results and append each result's object path */
2453         dl_list_for_each(bss, &wpa_s->bss_id, struct wpa_bss, list_id) {
2454                 paths[i] = os_zalloc(WPAS_DBUS_OBJECT_PATH_MAX);
2455                 if (paths[i] == NULL) {
2456                         dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY,
2457                                              "no memory");
2458                         goto out;
2459                 }
2460                 /* Construct the object path for this BSS. */
2461                 os_snprintf(paths[i++], WPAS_DBUS_OBJECT_PATH_MAX,
2462                             "%s/" WPAS_DBUS_NEW_BSSIDS_PART "/%u",
2463                             wpa_s->dbus_new_path, bss->id);
2464         }
2465
2466         success = wpas_dbus_simple_array_property_getter(iter,
2467                                                          DBUS_TYPE_OBJECT_PATH,
2468                                                          paths, wpa_s->num_bss,
2469                                                          error);
2470
2471 out:
2472         while (i)
2473                 os_free(paths[--i]);
2474         os_free(paths);
2475         return success;
2476 }
2477
2478
2479 /**
2480  * wpas_dbus_getter_networks - Get array of networks objects
2481  * @iter: Pointer to incoming dbus message iter
2482  * @error: Location to store error on failure
2483  * @user_data: Function specific data
2484  * Returns: TRUE on success, FALSE on failure
2485  *
2486  * Getter for "Networks" property.
2487  */
2488 dbus_bool_t wpas_dbus_getter_networks(DBusMessageIter *iter, DBusError *error,
2489                                       void *user_data)
2490 {
2491         struct wpa_supplicant *wpa_s = user_data;
2492         struct wpa_ssid *ssid;
2493         char **paths;
2494         unsigned int i = 0, num = 0;
2495         dbus_bool_t success = FALSE;
2496
2497         if (wpa_s->conf == NULL) {
2498                 wpa_printf(MSG_ERROR, "%s[dbus]: An error occurred getting "
2499                            "networks list.", __func__);
2500                 dbus_set_error(error, DBUS_ERROR_FAILED, "%s: an error "
2501                                "occurred getting the networks list", __func__);
2502                 return FALSE;
2503         }
2504
2505         for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
2506                 if (!network_is_persistent_group(ssid))
2507                         num++;
2508
2509         paths = os_zalloc(num * sizeof(char *));
2510         if (!paths) {
2511                 dbus_set_error(error, DBUS_ERROR_NO_MEMORY, "no memory");
2512                 return FALSE;
2513         }
2514
2515         /* Loop through configured networks and append object path of each */
2516         for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) {
2517                 if (network_is_persistent_group(ssid))
2518                         continue;
2519                 paths[i] = os_zalloc(WPAS_DBUS_OBJECT_PATH_MAX);
2520                 if (paths[i] == NULL) {
2521                         dbus_set_error(error, DBUS_ERROR_NO_MEMORY, "no memory");
2522                         goto out;
2523                 }
2524
2525                 /* Construct the object path for this network. */
2526                 os_snprintf(paths[i++], WPAS_DBUS_OBJECT_PATH_MAX,
2527                             "%s/" WPAS_DBUS_NEW_NETWORKS_PART "/%d",
2528                             wpa_s->dbus_new_path, ssid->id);
2529         }
2530
2531         success = wpas_dbus_simple_array_property_getter(iter,
2532                                                          DBUS_TYPE_OBJECT_PATH,
2533                                                          paths, num, error);
2534
2535 out:
2536         while (i)
2537                 os_free(paths[--i]);
2538         os_free(paths);
2539         return success;
2540 }
2541
2542
2543 /**
2544  * wpas_dbus_getter_blobs - Get all blobs defined for this interface
2545  * @iter: Pointer to incoming dbus message iter
2546  * @error: Location to store error on failure
2547  * @user_data: Function specific data
2548  * Returns: TRUE on success, FALSE on failure
2549  *
2550  * Getter for "Blobs" property.
2551  */
2552 dbus_bool_t wpas_dbus_getter_blobs(DBusMessageIter *iter, DBusError *error,
2553                                    void *user_data)
2554 {
2555         struct wpa_supplicant *wpa_s = user_data;
2556         DBusMessageIter variant_iter, dict_iter, entry_iter, array_iter;
2557         struct wpa_config_blob *blob;
2558
2559         if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
2560                                               "a{say}", &variant_iter) ||
2561             !dbus_message_iter_open_container(&variant_iter, DBUS_TYPE_ARRAY,
2562                                               "{say}", &dict_iter)) {
2563                 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
2564                 return FALSE;
2565         }
2566
2567         blob = wpa_s->conf->blobs;
2568         while (blob) {
2569                 if (!dbus_message_iter_open_container(&dict_iter,
2570                                                       DBUS_TYPE_DICT_ENTRY,
2571                                                       NULL, &entry_iter) ||
2572                     !dbus_message_iter_append_basic(&entry_iter,
2573                                                     DBUS_TYPE_STRING,
2574                                                     &(blob->name)) ||
2575                     !dbus_message_iter_open_container(&entry_iter,
2576                                                       DBUS_TYPE_ARRAY,
2577                                                       DBUS_TYPE_BYTE_AS_STRING,
2578                                                       &array_iter) ||
2579                     !dbus_message_iter_append_fixed_array(&array_iter,
2580                                                           DBUS_TYPE_BYTE,
2581                                                           &(blob->data),
2582                                                           blob->len) ||
2583                     !dbus_message_iter_close_container(&entry_iter,
2584                                                        &array_iter) ||
2585                     !dbus_message_iter_close_container(&dict_iter,
2586                                                        &entry_iter)) {
2587                         dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY,
2588                                              "no memory");
2589                         return FALSE;
2590                 }
2591
2592                 blob = blob->next;
2593         }
2594
2595         if (!dbus_message_iter_close_container(&variant_iter, &dict_iter) ||
2596             !dbus_message_iter_close_container(iter, &variant_iter)) {
2597                 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
2598                 return FALSE;
2599         }
2600
2601         return TRUE;
2602 }
2603
2604
2605 static struct wpa_bss * get_bss_helper(struct bss_handler_args *args,
2606                                        DBusError *error, const char *func_name)
2607 {
2608         struct wpa_bss *res = wpa_bss_get_id(args->wpa_s, args->id);
2609
2610         if (!res) {
2611                 wpa_printf(MSG_ERROR, "%s[dbus]: no bss with id %d found",
2612                            func_name, args->id);
2613                 dbus_set_error(error, DBUS_ERROR_FAILED,
2614                                "%s: BSS %d not found",
2615                                func_name, args->id);
2616         }
2617
2618         return res;
2619 }
2620
2621
2622 /**
2623  * wpas_dbus_getter_bss_bssid - Return the BSSID of a BSS
2624  * @iter: Pointer to incoming dbus message iter
2625  * @error: Location to store error on failure
2626  * @user_data: Function specific data
2627  * Returns: TRUE on success, FALSE on failure
2628  *
2629  * Getter for "BSSID" property.
2630  */
2631 dbus_bool_t wpas_dbus_getter_bss_bssid(DBusMessageIter *iter, DBusError *error,
2632                                        void *user_data)
2633 {
2634         struct bss_handler_args *args = user_data;
2635         struct wpa_bss *res;
2636
2637         res = get_bss_helper(args, error, __func__);
2638         if (!res)
2639                 return FALSE;
2640
2641         return wpas_dbus_simple_array_property_getter(iter, DBUS_TYPE_BYTE,
2642                                                       res->bssid, ETH_ALEN,
2643                                                       error);
2644 }
2645
2646
2647 /**
2648  * wpas_dbus_getter_bss_ssid - Return the SSID of a BSS
2649  * @iter: Pointer to incoming dbus message iter
2650  * @error: Location to store error on failure
2651  * @user_data: Function specific data
2652  * Returns: TRUE on success, FALSE on failure
2653  *
2654  * Getter for "SSID" property.
2655  */
2656 dbus_bool_t wpas_dbus_getter_bss_ssid(DBusMessageIter *iter, DBusError *error,
2657                                       void *user_data)
2658 {
2659         struct bss_handler_args *args = user_data;
2660         struct wpa_bss *res;
2661
2662         res = get_bss_helper(args, error, __func__);
2663         if (!res)
2664                 return FALSE;
2665
2666         return wpas_dbus_simple_array_property_getter(iter, DBUS_TYPE_BYTE,
2667                                                       res->ssid, res->ssid_len,
2668                                                       error);
2669 }
2670
2671
2672 /**
2673  * wpas_dbus_getter_bss_privacy - Return the privacy flag of a BSS
2674  * @iter: Pointer to incoming dbus message iter
2675  * @error: Location to store error on failure
2676  * @user_data: Function specific data
2677  * Returns: TRUE on success, FALSE on failure
2678  *
2679  * Getter for "Privacy" property.
2680  */
2681 dbus_bool_t wpas_dbus_getter_bss_privacy(DBusMessageIter *iter,
2682                                          DBusError *error, void *user_data)
2683 {
2684         struct bss_handler_args *args = user_data;
2685         struct wpa_bss *res;
2686         dbus_bool_t privacy;
2687
2688         res = get_bss_helper(args, error, __func__);
2689         if (!res)
2690                 return FALSE;
2691
2692         privacy = (res->caps & IEEE80211_CAP_PRIVACY) ? TRUE : FALSE;
2693         return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_BOOLEAN,
2694                                                 &privacy, error);
2695 }
2696
2697
2698 /**
2699  * wpas_dbus_getter_bss_mode - Return the mode of a BSS
2700  * @iter: Pointer to incoming dbus message iter
2701  * @error: Location to store error on failure
2702  * @user_data: Function specific data
2703  * Returns: TRUE on success, FALSE on failure
2704  *
2705  * Getter for "Mode" property.
2706  */
2707 dbus_bool_t wpas_dbus_getter_bss_mode(DBusMessageIter *iter, DBusError *error,
2708                                       void *user_data)
2709 {
2710         struct bss_handler_args *args = user_data;
2711         struct wpa_bss *res;
2712         const char *mode;
2713
2714         res = get_bss_helper(args, error, __func__);
2715         if (!res)
2716                 return FALSE;
2717
2718         if (res->caps & IEEE80211_CAP_IBSS)
2719                 mode = "ad-hoc";
2720         else
2721                 mode = "infrastructure";
2722
2723         return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING,
2724                                                 &mode, error);
2725 }
2726
2727
2728 /**
2729  * wpas_dbus_getter_bss_level - Return the signal strength of a BSS
2730  * @iter: Pointer to incoming dbus message iter
2731  * @error: Location to store error on failure
2732  * @user_data: Function specific data
2733  * Returns: TRUE on success, FALSE on failure
2734  *
2735  * Getter for "Level" property.
2736  */
2737 dbus_bool_t wpas_dbus_getter_bss_signal(DBusMessageIter *iter,
2738                                         DBusError *error, void *user_data)
2739 {
2740         struct bss_handler_args *args = user_data;
2741         struct wpa_bss *res;
2742
2743         res = get_bss_helper(args, error, __func__);
2744         if (!res)
2745                 return FALSE;
2746
2747         return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_INT16,
2748                                                 &res->level, error);
2749 }
2750
2751
2752 /**
2753  * wpas_dbus_getter_bss_frequency - Return the frequency of a BSS
2754  * @iter: Pointer to incoming dbus message iter
2755  * @error: Location to store error on failure
2756  * @user_data: Function specific data
2757  * Returns: TRUE on success, FALSE on failure
2758  *
2759  * Getter for "Frequency" property.
2760  */
2761 dbus_bool_t wpas_dbus_getter_bss_frequency(DBusMessageIter *iter,
2762                                            DBusError *error, void *user_data)
2763 {
2764         struct bss_handler_args *args = user_data;
2765         struct wpa_bss *res;
2766
2767         res = get_bss_helper(args, error, __func__);
2768         if (!res)
2769                 return FALSE;
2770
2771         return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_UINT16,
2772                                                 &res->freq, error);
2773 }
2774
2775
2776 static int cmp_u8s_desc(const void *a, const void *b)
2777 {
2778         return (*(u8 *) b - *(u8 *) a);
2779 }
2780
2781
2782 /**
2783  * wpas_dbus_getter_bss_rates - Return available bit rates of a BSS
2784  * @iter: Pointer to incoming dbus message iter
2785  * @error: Location to store error on failure
2786  * @user_data: Function specific data
2787  * Returns: TRUE on success, FALSE on failure
2788  *
2789  * Getter for "Rates" property.
2790  */
2791 dbus_bool_t wpas_dbus_getter_bss_rates(DBusMessageIter *iter,
2792                                        DBusError *error, void *user_data)
2793 {
2794         struct bss_handler_args *args = user_data;
2795         struct wpa_bss *res;
2796         u8 *ie_rates = NULL;
2797         u32 *real_rates;
2798         int rates_num, i;
2799         dbus_bool_t success = FALSE;
2800
2801         res = get_bss_helper(args, error, __func__);
2802         if (!res)
2803                 return FALSE;
2804
2805         rates_num = wpa_bss_get_bit_rates(res, &ie_rates);
2806         if (rates_num < 0)
2807                 return FALSE;
2808
2809         qsort(ie_rates, rates_num, 1, cmp_u8s_desc);
2810
2811         real_rates = os_malloc(sizeof(u32) * rates_num);
2812         if (!real_rates) {
2813                 os_free(ie_rates);
2814                 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
2815                 return FALSE;
2816         }
2817
2818         for (i = 0; i < rates_num; i++)
2819                 real_rates[i] = ie_rates[i] * 500000;
2820
2821         success = wpas_dbus_simple_array_property_getter(iter, DBUS_TYPE_UINT32,
2822                                                          real_rates, rates_num,
2823                                                          error);
2824
2825         os_free(ie_rates);
2826         os_free(real_rates);
2827         return success;
2828 }
2829
2830
2831 static dbus_bool_t wpas_dbus_get_bss_security_prop(DBusMessageIter *iter,
2832                                                    struct wpa_ie_data *ie_data,
2833                                                    DBusError *error)
2834 {
2835         DBusMessageIter iter_dict, variant_iter;
2836         const char *group;
2837         const char *pairwise[2]; /* max 2 pairwise ciphers is supported */
2838         const char *key_mgmt[7]; /* max 7 key managements may be supported */
2839         int n;
2840
2841         if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
2842                                               "a{sv}", &variant_iter))
2843                 goto nomem;
2844
2845         if (!wpa_dbus_dict_open_write(&variant_iter, &iter_dict))
2846                 goto nomem;
2847
2848         /* KeyMgmt */
2849         n = 0;
2850         if (ie_data->key_mgmt & WPA_KEY_MGMT_PSK)
2851                 key_mgmt[n++] = "wpa-psk";
2852         if (ie_data->key_mgmt & WPA_KEY_MGMT_FT_PSK)
2853                 key_mgmt[n++] = "wpa-ft-psk";
2854         if (ie_data->key_mgmt & WPA_KEY_MGMT_PSK_SHA256)
2855                 key_mgmt[n++] = "wpa-psk-sha256";
2856         if (ie_data->key_mgmt & WPA_KEY_MGMT_IEEE8021X)
2857                 key_mgmt[n++] = "wpa-eap";
2858         if (ie_data->key_mgmt & WPA_KEY_MGMT_FT_IEEE8021X)
2859                 key_mgmt[n++] = "wpa-ft-eap";
2860         if (ie_data->key_mgmt & WPA_KEY_MGMT_IEEE8021X_SHA256)
2861                 key_mgmt[n++] = "wpa-eap-sha256";
2862         if (ie_data->key_mgmt & WPA_KEY_MGMT_NONE)
2863                 key_mgmt[n++] = "wpa-none";
2864
2865         if (!wpa_dbus_dict_append_string_array(&iter_dict, "KeyMgmt",
2866                                                key_mgmt, n))
2867                 goto nomem;
2868
2869         /* Group */
2870         switch (ie_data->group_cipher) {
2871         case WPA_CIPHER_WEP40:
2872                 group = "wep40";
2873                 break;
2874         case WPA_CIPHER_TKIP:
2875                 group = "tkip";
2876                 break;
2877         case WPA_CIPHER_CCMP:
2878                 group = "ccmp";
2879                 break;
2880         case WPA_CIPHER_WEP104:
2881                 group = "wep104";
2882                 break;
2883         default:
2884                 group = "";
2885                 break;
2886         }
2887
2888         if (!wpa_dbus_dict_append_string(&iter_dict, "Group", group))
2889                 goto nomem;
2890
2891         /* Pairwise */
2892         n = 0;
2893         if (ie_data->pairwise_cipher & WPA_CIPHER_TKIP)
2894                 pairwise[n++] = "tkip";
2895         if (ie_data->pairwise_cipher & WPA_CIPHER_CCMP)
2896                 pairwise[n++] = "ccmp";
2897
2898         if (!wpa_dbus_dict_append_string_array(&iter_dict, "Pairwise",
2899                                                pairwise, n))
2900                 goto nomem;
2901
2902         /* Management group (RSN only) */
2903         if (ie_data->proto == WPA_PROTO_RSN) {
2904                 switch (ie_data->mgmt_group_cipher) {
2905 #ifdef CONFIG_IEEE80211W
2906                 case WPA_CIPHER_AES_128_CMAC:
2907                         group = "aes128cmac";
2908                         break;
2909 #endif /* CONFIG_IEEE80211W */
2910                 default:
2911                         group = "";
2912                         break;
2913                 }
2914
2915                 if (!wpa_dbus_dict_append_string(&iter_dict, "MgmtGroup",
2916                                                  group))
2917                         goto nomem;
2918         }
2919
2920         if (!wpa_dbus_dict_close_write(&variant_iter, &iter_dict))
2921                 goto nomem;
2922         if (!dbus_message_iter_close_container(iter, &variant_iter))
2923                 goto nomem;
2924
2925         return TRUE;
2926
2927 nomem:
2928         dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
2929         return FALSE;
2930 }
2931
2932
2933 /**
2934  * wpas_dbus_getter_bss_wpa - Return the WPA options of a BSS
2935  * @iter: Pointer to incoming dbus message iter
2936  * @error: Location to store error on failure
2937  * @user_data: Function specific data
2938  * Returns: TRUE on success, FALSE on failure
2939  *
2940  * Getter for "WPA" property.
2941  */
2942 dbus_bool_t wpas_dbus_getter_bss_wpa(DBusMessageIter *iter, DBusError *error,
2943                                      void *user_data)
2944 {
2945         struct bss_handler_args *args = user_data;
2946         struct wpa_bss *res;
2947         struct wpa_ie_data wpa_data;
2948         const u8 *ie;
2949
2950         res = get_bss_helper(args, error, __func__);
2951         if (!res)
2952                 return FALSE;
2953
2954         os_memset(&wpa_data, 0, sizeof(wpa_data));
2955         ie = wpa_bss_get_vendor_ie(res, WPA_IE_VENDOR_TYPE);
2956         if (ie) {
2957                 if (wpa_parse_wpa_ie(ie, 2 + ie[1], &wpa_data) < 0) {
2958                         dbus_set_error_const(error, DBUS_ERROR_FAILED,
2959                                              "failed to parse WPA IE");
2960                         return FALSE;
2961                 }
2962         }
2963
2964         return wpas_dbus_get_bss_security_prop(iter, &wpa_data, error);
2965 }
2966
2967
2968 /**
2969  * wpas_dbus_getter_bss_rsn - Return the RSN options of a BSS
2970  * @iter: Pointer to incoming dbus message iter
2971  * @error: Location to store error on failure
2972  * @user_data: Function specific data
2973  * Returns: TRUE on success, FALSE on failure
2974  *
2975  * Getter for "RSN" property.
2976  */
2977 dbus_bool_t wpas_dbus_getter_bss_rsn(DBusMessageIter *iter, DBusError *error,
2978                                      void *user_data)
2979 {
2980         struct bss_handler_args *args = user_data;
2981         struct wpa_bss *res;
2982         struct wpa_ie_data wpa_data;
2983         const u8 *ie;
2984
2985         res = get_bss_helper(args, error, __func__);
2986         if (!res)
2987                 return FALSE;
2988
2989         os_memset(&wpa_data, 0, sizeof(wpa_data));
2990         ie = wpa_bss_get_ie(res, WLAN_EID_RSN);
2991         if (ie) {
2992                 if (wpa_parse_wpa_ie(ie, 2 + ie[1], &wpa_data) < 0) {
2993                         dbus_set_error_const(error, DBUS_ERROR_FAILED,
2994                                              "failed to parse RSN IE");
2995                         return FALSE;
2996                 }
2997         }
2998
2999         return wpas_dbus_get_bss_security_prop(iter, &wpa_data, error);
3000 }
3001
3002
3003 /**
3004  * wpas_dbus_getter_bss_ies - Return all IEs of a BSS
3005  * @iter: Pointer to incoming dbus message iter
3006  * @error: Location to store error on failure
3007  * @user_data: Function specific data
3008  * Returns: TRUE on success, FALSE on failure
3009  *
3010  * Getter for "IEs" property.
3011  */
3012 dbus_bool_t wpas_dbus_getter_bss_ies(DBusMessageIter *iter, DBusError *error,
3013                                      void *user_data)
3014 {
3015         struct bss_handler_args *args = user_data;
3016         struct wpa_bss *res;
3017
3018         res = get_bss_helper(args, error, __func__);
3019         if (!res)
3020                 return FALSE;
3021
3022         return wpas_dbus_simple_array_property_getter(iter, DBUS_TYPE_BYTE,
3023                                                       res + 1, res->ie_len,
3024                                                       error);
3025 }
3026
3027
3028 /**
3029  * wpas_dbus_getter_enabled - Check whether network is enabled or disabled
3030  * @iter: Pointer to incoming dbus message iter
3031  * @error: Location to store error on failure
3032  * @user_data: Function specific data
3033  * Returns: TRUE on success, FALSE on failure
3034  *
3035  * Getter for "enabled" property of a configured network.
3036  */
3037 dbus_bool_t wpas_dbus_getter_enabled(DBusMessageIter *iter, DBusError *error,
3038                                      void *user_data)
3039 {
3040         struct network_handler_args *net = user_data;
3041         dbus_bool_t enabled = net->ssid->disabled ? FALSE : TRUE;
3042
3043         return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_BOOLEAN,
3044                                                 &enabled, error);
3045 }
3046
3047
3048 /**
3049  * wpas_dbus_setter_enabled - Mark a configured network as enabled or disabled
3050  * @iter: Pointer to incoming dbus message iter
3051  * @error: Location to store error on failure
3052  * @user_data: Function specific data
3053  * Returns: TRUE on success, FALSE on failure
3054  *
3055  * Setter for "Enabled" property of a configured network.
3056  */
3057 dbus_bool_t wpas_dbus_setter_enabled(DBusMessageIter *iter, DBusError *error,
3058                                      void *user_data)
3059 {
3060         struct network_handler_args *net = user_data;
3061         struct wpa_supplicant *wpa_s;
3062         struct wpa_ssid *ssid;
3063         dbus_bool_t enable;
3064
3065         if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_BOOLEAN,
3066                                               &enable))
3067                 return FALSE;
3068
3069         wpa_s = net->wpa_s;
3070         ssid = net->ssid;
3071
3072         if (enable)
3073                 wpa_supplicant_enable_network(wpa_s, ssid);
3074         else
3075                 wpa_supplicant_disable_network(wpa_s, ssid);
3076
3077         return TRUE;
3078 }
3079
3080
3081 /**
3082  * wpas_dbus_getter_network_properties - Get options for a configured network
3083  * @iter: Pointer to incoming dbus message iter
3084  * @error: Location to store error on failure
3085  * @user_data: Function specific data
3086  * Returns: TRUE on success, FALSE on failure
3087  *
3088  * Getter for "Properties" property of a configured network.
3089  */
3090 dbus_bool_t wpas_dbus_getter_network_properties(DBusMessageIter *iter,
3091                                                 DBusError *error,
3092                                                 void *user_data)
3093 {
3094         struct network_handler_args *net = user_data;
3095         DBusMessageIter variant_iter, dict_iter;
3096         char **iterator;
3097         char **props = wpa_config_get_all(net->ssid, 1);
3098         dbus_bool_t success = FALSE;
3099
3100         if (!props) {
3101                 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
3102                 return FALSE;
3103         }
3104
3105         if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT, "a{sv}",
3106                                               &variant_iter) ||
3107             !wpa_dbus_dict_open_write(&variant_iter, &dict_iter)) {
3108                 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
3109                 goto out;
3110         }
3111
3112         iterator = props;
3113         while (*iterator) {
3114                 if (!wpa_dbus_dict_append_string(&dict_iter, *iterator,
3115                                                  *(iterator + 1))) {
3116                         dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY,
3117                                              "no memory");
3118                         goto out;
3119                 }
3120                 iterator += 2;
3121         }
3122
3123
3124         if (!wpa_dbus_dict_close_write(&variant_iter, &dict_iter) ||
3125             !dbus_message_iter_close_container(iter, &variant_iter)) {
3126                 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
3127                 goto out;
3128         }
3129
3130         success = TRUE;
3131
3132 out:
3133         iterator = props;
3134         while (*iterator) {
3135                 os_free(*iterator);
3136                 iterator++;
3137         }
3138         os_free(props);
3139         return success;
3140 }
3141
3142
3143 /**
3144  * wpas_dbus_setter_network_properties - Set options for a configured network
3145  * @iter: Pointer to incoming dbus message iter
3146  * @error: Location to store error on failure
3147  * @user_data: Function specific data
3148  * Returns: TRUE on success, FALSE on failure
3149  *
3150  * Setter for "Properties" property of a configured network.
3151  */
3152 dbus_bool_t wpas_dbus_setter_network_properties(DBusMessageIter *iter,
3153                                                 DBusError *error,
3154                                                 void *user_data)
3155 {
3156         struct network_handler_args *net = user_data;
3157         struct wpa_ssid *ssid = net->ssid;
3158         DBusMessageIter variant_iter;
3159
3160         dbus_message_iter_recurse(iter, &variant_iter);
3161         return set_network_properties(net->wpa_s, ssid, &variant_iter, error);
3162 }