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