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;
2494
2495         bridge_ifname = wpa_s->bridge_ifname ? wpa_s->bridge_ifname : "";
2496         return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING,
2497                                                 &bridge_ifname, error);
2498 }
2499
2500
2501 /**
2502  * wpas_dbus_getter_bsss - Get array of BSSs objects
2503  * @iter: Pointer to incoming dbus message iter
2504  * @error: Location to store error on failure
2505  * @user_data: Function specific data
2506  * Returns: TRUE on success, FALSE on failure
2507  *
2508  * Getter for "BSSs" property.
2509  */
2510 dbus_bool_t wpas_dbus_getter_bsss(DBusMessageIter *iter, DBusError *error,
2511                                   void *user_data)
2512 {
2513         struct wpa_supplicant *wpa_s = user_data;
2514         struct wpa_bss *bss;
2515         char **paths;
2516         unsigned int i = 0;
2517         dbus_bool_t success = FALSE;
2518
2519         paths = os_zalloc(wpa_s->num_bss * sizeof(char *));
2520         if (!paths) {
2521                 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
2522                 return FALSE;
2523         }
2524
2525         /* Loop through scan results and append each result's object path */
2526         dl_list_for_each(bss, &wpa_s->bss_id, struct wpa_bss, list_id) {
2527                 paths[i] = os_zalloc(WPAS_DBUS_OBJECT_PATH_MAX);
2528                 if (paths[i] == NULL) {
2529                         dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY,
2530                                              "no memory");
2531                         goto out;
2532                 }
2533                 /* Construct the object path for this BSS. */
2534                 os_snprintf(paths[i++], WPAS_DBUS_OBJECT_PATH_MAX,
2535                             "%s/" WPAS_DBUS_NEW_BSSIDS_PART "/%u",
2536                             wpa_s->dbus_new_path, bss->id);
2537         }
2538
2539         success = wpas_dbus_simple_array_property_getter(iter,
2540                                                          DBUS_TYPE_OBJECT_PATH,
2541                                                          paths, wpa_s->num_bss,
2542                                                          error);
2543
2544 out:
2545         while (i)
2546                 os_free(paths[--i]);
2547         os_free(paths);
2548         return success;
2549 }
2550
2551
2552 /**
2553  * wpas_dbus_getter_networks - Get array of networks objects
2554  * @iter: Pointer to incoming dbus message iter
2555  * @error: Location to store error on failure
2556  * @user_data: Function specific data
2557  * Returns: TRUE on success, FALSE on failure
2558  *
2559  * Getter for "Networks" property.
2560  */
2561 dbus_bool_t wpas_dbus_getter_networks(DBusMessageIter *iter, DBusError *error,
2562                                       void *user_data)
2563 {
2564         struct wpa_supplicant *wpa_s = user_data;
2565         struct wpa_ssid *ssid;
2566         char **paths;
2567         unsigned int i = 0, num = 0;
2568         dbus_bool_t success = FALSE;
2569
2570         if (wpa_s->conf == NULL) {
2571                 wpa_printf(MSG_ERROR, "%s[dbus]: An error occurred getting "
2572                            "networks list.", __func__);
2573                 dbus_set_error(error, DBUS_ERROR_FAILED, "%s: an error "
2574                                "occurred getting the networks list", __func__);
2575                 return FALSE;
2576         }
2577
2578         for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
2579                 if (!network_is_persistent_group(ssid))
2580                         num++;
2581
2582         paths = os_zalloc(num * sizeof(char *));
2583         if (!paths) {
2584                 dbus_set_error(error, DBUS_ERROR_NO_MEMORY, "no memory");
2585                 return FALSE;
2586         }
2587
2588         /* Loop through configured networks and append object path of each */
2589         for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) {
2590                 if (network_is_persistent_group(ssid))
2591                         continue;
2592                 paths[i] = os_zalloc(WPAS_DBUS_OBJECT_PATH_MAX);
2593                 if (paths[i] == NULL) {
2594                         dbus_set_error(error, DBUS_ERROR_NO_MEMORY, "no memory");
2595                         goto out;
2596                 }
2597
2598                 /* Construct the object path for this network. */
2599                 os_snprintf(paths[i++], WPAS_DBUS_OBJECT_PATH_MAX,
2600                             "%s/" WPAS_DBUS_NEW_NETWORKS_PART "/%d",
2601                             wpa_s->dbus_new_path, ssid->id);
2602         }
2603
2604         success = wpas_dbus_simple_array_property_getter(iter,
2605                                                          DBUS_TYPE_OBJECT_PATH,
2606                                                          paths, num, error);
2607
2608 out:
2609         while (i)
2610                 os_free(paths[--i]);
2611         os_free(paths);
2612         return success;
2613 }
2614
2615
2616 /**
2617  * wpas_dbus_getter_blobs - Get all blobs defined for this interface
2618  * @iter: Pointer to incoming dbus message iter
2619  * @error: Location to store error on failure
2620  * @user_data: Function specific data
2621  * Returns: TRUE on success, FALSE on failure
2622  *
2623  * Getter for "Blobs" property.
2624  */
2625 dbus_bool_t wpas_dbus_getter_blobs(DBusMessageIter *iter, DBusError *error,
2626                                    void *user_data)
2627 {
2628         struct wpa_supplicant *wpa_s = user_data;
2629         DBusMessageIter variant_iter, dict_iter, entry_iter, array_iter;
2630         struct wpa_config_blob *blob;
2631
2632         if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
2633                                               "a{say}", &variant_iter) ||
2634             !dbus_message_iter_open_container(&variant_iter, DBUS_TYPE_ARRAY,
2635                                               "{say}", &dict_iter)) {
2636                 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
2637                 return FALSE;
2638         }
2639
2640         blob = wpa_s->conf->blobs;
2641         while (blob) {
2642                 if (!dbus_message_iter_open_container(&dict_iter,
2643                                                       DBUS_TYPE_DICT_ENTRY,
2644                                                       NULL, &entry_iter) ||
2645                     !dbus_message_iter_append_basic(&entry_iter,
2646                                                     DBUS_TYPE_STRING,
2647                                                     &(blob->name)) ||
2648                     !dbus_message_iter_open_container(&entry_iter,
2649                                                       DBUS_TYPE_ARRAY,
2650                                                       DBUS_TYPE_BYTE_AS_STRING,
2651                                                       &array_iter) ||
2652                     !dbus_message_iter_append_fixed_array(&array_iter,
2653                                                           DBUS_TYPE_BYTE,
2654                                                           &(blob->data),
2655                                                           blob->len) ||
2656                     !dbus_message_iter_close_container(&entry_iter,
2657                                                        &array_iter) ||
2658                     !dbus_message_iter_close_container(&dict_iter,
2659                                                        &entry_iter)) {
2660                         dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY,
2661                                              "no memory");
2662                         return FALSE;
2663                 }
2664
2665                 blob = blob->next;
2666         }
2667
2668         if (!dbus_message_iter_close_container(&variant_iter, &dict_iter) ||
2669             !dbus_message_iter_close_container(iter, &variant_iter)) {
2670                 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
2671                 return FALSE;
2672         }
2673
2674         return TRUE;
2675 }
2676
2677
2678 static struct wpa_bss * get_bss_helper(struct bss_handler_args *args,
2679                                        DBusError *error, const char *func_name)
2680 {
2681         struct wpa_bss *res = wpa_bss_get_id(args->wpa_s, args->id);
2682
2683         if (!res) {
2684                 wpa_printf(MSG_ERROR, "%s[dbus]: no bss with id %d found",
2685                            func_name, args->id);
2686                 dbus_set_error(error, DBUS_ERROR_FAILED,
2687                                "%s: BSS %d not found",
2688                                func_name, args->id);
2689         }
2690
2691         return res;
2692 }
2693
2694
2695 /**
2696  * wpas_dbus_getter_bss_bssid - Return the BSSID of a BSS
2697  * @iter: Pointer to incoming dbus message iter
2698  * @error: Location to store error on failure
2699  * @user_data: Function specific data
2700  * Returns: TRUE on success, FALSE on failure
2701  *
2702  * Getter for "BSSID" property.
2703  */
2704 dbus_bool_t wpas_dbus_getter_bss_bssid(DBusMessageIter *iter, DBusError *error,
2705                                        void *user_data)
2706 {
2707         struct bss_handler_args *args = user_data;
2708         struct wpa_bss *res;
2709
2710         res = get_bss_helper(args, error, __func__);
2711         if (!res)
2712                 return FALSE;
2713
2714         return wpas_dbus_simple_array_property_getter(iter, DBUS_TYPE_BYTE,
2715                                                       res->bssid, ETH_ALEN,
2716                                                       error);
2717 }
2718
2719
2720 /**
2721  * wpas_dbus_getter_bss_ssid - Return the SSID of a BSS
2722  * @iter: Pointer to incoming dbus message iter
2723  * @error: Location to store error on failure
2724  * @user_data: Function specific data
2725  * Returns: TRUE on success, FALSE on failure
2726  *
2727  * Getter for "SSID" property.
2728  */
2729 dbus_bool_t wpas_dbus_getter_bss_ssid(DBusMessageIter *iter, DBusError *error,
2730                                       void *user_data)
2731 {
2732         struct bss_handler_args *args = user_data;
2733         struct wpa_bss *res;
2734
2735         res = get_bss_helper(args, error, __func__);
2736         if (!res)
2737                 return FALSE;
2738
2739         return wpas_dbus_simple_array_property_getter(iter, DBUS_TYPE_BYTE,
2740                                                       res->ssid, res->ssid_len,
2741                                                       error);
2742 }
2743
2744
2745 /**
2746  * wpas_dbus_getter_bss_privacy - Return the privacy flag of a BSS
2747  * @iter: Pointer to incoming dbus message iter
2748  * @error: Location to store error on failure
2749  * @user_data: Function specific data
2750  * Returns: TRUE on success, FALSE on failure
2751  *
2752  * Getter for "Privacy" property.
2753  */
2754 dbus_bool_t wpas_dbus_getter_bss_privacy(DBusMessageIter *iter,
2755                                          DBusError *error, void *user_data)
2756 {
2757         struct bss_handler_args *args = user_data;
2758         struct wpa_bss *res;
2759         dbus_bool_t privacy;
2760
2761         res = get_bss_helper(args, error, __func__);
2762         if (!res)
2763                 return FALSE;
2764
2765         privacy = (res->caps & IEEE80211_CAP_PRIVACY) ? TRUE : FALSE;
2766         return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_BOOLEAN,
2767                                                 &privacy, error);
2768 }
2769
2770
2771 /**
2772  * wpas_dbus_getter_bss_mode - Return the mode of a BSS
2773  * @iter: Pointer to incoming dbus message iter
2774  * @error: Location to store error on failure
2775  * @user_data: Function specific data
2776  * Returns: TRUE on success, FALSE on failure
2777  *
2778  * Getter for "Mode" property.
2779  */
2780 dbus_bool_t wpas_dbus_getter_bss_mode(DBusMessageIter *iter, DBusError *error,
2781                                       void *user_data)
2782 {
2783         struct bss_handler_args *args = user_data;
2784         struct wpa_bss *res;
2785         const char *mode;
2786
2787         res = get_bss_helper(args, error, __func__);
2788         if (!res)
2789                 return FALSE;
2790
2791         if (res->caps & IEEE80211_CAP_IBSS)
2792                 mode = "ad-hoc";
2793         else
2794                 mode = "infrastructure";
2795
2796         return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING,
2797                                                 &mode, error);
2798 }
2799
2800
2801 /**
2802  * wpas_dbus_getter_bss_level - Return the signal strength of a BSS
2803  * @iter: Pointer to incoming dbus message iter
2804  * @error: Location to store error on failure
2805  * @user_data: Function specific data
2806  * Returns: TRUE on success, FALSE on failure
2807  *
2808  * Getter for "Level" property.
2809  */
2810 dbus_bool_t wpas_dbus_getter_bss_signal(DBusMessageIter *iter,
2811                                         DBusError *error, void *user_data)
2812 {
2813         struct bss_handler_args *args = user_data;
2814         struct wpa_bss *res;
2815
2816         res = get_bss_helper(args, error, __func__);
2817         if (!res)
2818                 return FALSE;
2819
2820         return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_INT16,
2821                                                 &res->level, error);
2822 }
2823
2824
2825 /**
2826  * wpas_dbus_getter_bss_frequency - Return the frequency of a BSS
2827  * @iter: Pointer to incoming dbus message iter
2828  * @error: Location to store error on failure
2829  * @user_data: Function specific data
2830  * Returns: TRUE on success, FALSE on failure
2831  *
2832  * Getter for "Frequency" property.
2833  */
2834 dbus_bool_t wpas_dbus_getter_bss_frequency(DBusMessageIter *iter,
2835                                            DBusError *error, void *user_data)
2836 {
2837         struct bss_handler_args *args = user_data;
2838         struct wpa_bss *res;
2839
2840         res = get_bss_helper(args, error, __func__);
2841         if (!res)
2842                 return FALSE;
2843
2844         return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_UINT16,
2845                                                 &res->freq, error);
2846 }
2847
2848
2849 static int cmp_u8s_desc(const void *a, const void *b)
2850 {
2851         return (*(u8 *) b - *(u8 *) a);
2852 }
2853
2854
2855 /**
2856  * wpas_dbus_getter_bss_rates - Return available bit rates of a BSS
2857  * @iter: Pointer to incoming dbus message iter
2858  * @error: Location to store error on failure
2859  * @user_data: Function specific data
2860  * Returns: TRUE on success, FALSE on failure
2861  *
2862  * Getter for "Rates" property.
2863  */
2864 dbus_bool_t wpas_dbus_getter_bss_rates(DBusMessageIter *iter,
2865                                        DBusError *error, void *user_data)
2866 {
2867         struct bss_handler_args *args = user_data;
2868         struct wpa_bss *res;
2869         u8 *ie_rates = NULL;
2870         u32 *real_rates;
2871         int rates_num, i;
2872         dbus_bool_t success = FALSE;
2873
2874         res = get_bss_helper(args, error, __func__);
2875         if (!res)
2876                 return FALSE;
2877
2878         rates_num = wpa_bss_get_bit_rates(res, &ie_rates);
2879         if (rates_num < 0)
2880                 return FALSE;
2881
2882         qsort(ie_rates, rates_num, 1, cmp_u8s_desc);
2883
2884         real_rates = os_malloc(sizeof(u32) * rates_num);
2885         if (!real_rates) {
2886                 os_free(ie_rates);
2887                 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
2888                 return FALSE;
2889         }
2890
2891         for (i = 0; i < rates_num; i++)
2892                 real_rates[i] = ie_rates[i] * 500000;
2893
2894         success = wpas_dbus_simple_array_property_getter(iter, DBUS_TYPE_UINT32,
2895                                                          real_rates, rates_num,
2896                                                          error);
2897
2898         os_free(ie_rates);
2899         os_free(real_rates);
2900         return success;
2901 }
2902
2903
2904 static dbus_bool_t wpas_dbus_get_bss_security_prop(DBusMessageIter *iter,
2905                                                    struct wpa_ie_data *ie_data,
2906                                                    DBusError *error)
2907 {
2908         DBusMessageIter iter_dict, variant_iter;
2909         const char *group;
2910         const char *pairwise[2]; /* max 2 pairwise ciphers is supported */
2911         const char *key_mgmt[7]; /* max 7 key managements may be supported */
2912         int n;
2913
2914         if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
2915                                               "a{sv}", &variant_iter))
2916                 goto nomem;
2917
2918         if (!wpa_dbus_dict_open_write(&variant_iter, &iter_dict))
2919                 goto nomem;
2920
2921         /* KeyMgmt */
2922         n = 0;
2923         if (ie_data->key_mgmt & WPA_KEY_MGMT_PSK)
2924                 key_mgmt[n++] = "wpa-psk";
2925         if (ie_data->key_mgmt & WPA_KEY_MGMT_FT_PSK)
2926                 key_mgmt[n++] = "wpa-ft-psk";
2927         if (ie_data->key_mgmt & WPA_KEY_MGMT_PSK_SHA256)
2928                 key_mgmt[n++] = "wpa-psk-sha256";
2929         if (ie_data->key_mgmt & WPA_KEY_MGMT_IEEE8021X)
2930                 key_mgmt[n++] = "wpa-eap";
2931         if (ie_data->key_mgmt & WPA_KEY_MGMT_FT_IEEE8021X)
2932                 key_mgmt[n++] = "wpa-ft-eap";
2933         if (ie_data->key_mgmt & WPA_KEY_MGMT_IEEE8021X_SHA256)
2934                 key_mgmt[n++] = "wpa-eap-sha256";
2935         if (ie_data->key_mgmt & WPA_KEY_MGMT_NONE)
2936                 key_mgmt[n++] = "wpa-none";
2937
2938         if (!wpa_dbus_dict_append_string_array(&iter_dict, "KeyMgmt",
2939                                                key_mgmt, n))
2940                 goto nomem;
2941
2942         /* Group */
2943         switch (ie_data->group_cipher) {
2944         case WPA_CIPHER_WEP40:
2945                 group = "wep40";
2946                 break;
2947         case WPA_CIPHER_TKIP:
2948                 group = "tkip";
2949                 break;
2950         case WPA_CIPHER_CCMP:
2951                 group = "ccmp";
2952                 break;
2953         case WPA_CIPHER_WEP104:
2954                 group = "wep104";
2955                 break;
2956         default:
2957                 group = "";
2958                 break;
2959         }
2960
2961         if (!wpa_dbus_dict_append_string(&iter_dict, "Group", group))
2962                 goto nomem;
2963
2964         /* Pairwise */
2965         n = 0;
2966         if (ie_data->pairwise_cipher & WPA_CIPHER_TKIP)
2967                 pairwise[n++] = "tkip";
2968         if (ie_data->pairwise_cipher & WPA_CIPHER_CCMP)
2969                 pairwise[n++] = "ccmp";
2970
2971         if (!wpa_dbus_dict_append_string_array(&iter_dict, "Pairwise",
2972                                                pairwise, n))
2973                 goto nomem;
2974
2975         /* Management group (RSN only) */
2976         if (ie_data->proto == WPA_PROTO_RSN) {
2977                 switch (ie_data->mgmt_group_cipher) {
2978 #ifdef CONFIG_IEEE80211W
2979                 case WPA_CIPHER_AES_128_CMAC:
2980                         group = "aes128cmac";
2981                         break;
2982 #endif /* CONFIG_IEEE80211W */
2983                 default:
2984                         group = "";
2985                         break;
2986                 }
2987
2988                 if (!wpa_dbus_dict_append_string(&iter_dict, "MgmtGroup",
2989                                                  group))
2990                         goto nomem;
2991         }
2992
2993         if (!wpa_dbus_dict_close_write(&variant_iter, &iter_dict))
2994                 goto nomem;
2995         if (!dbus_message_iter_close_container(iter, &variant_iter))
2996                 goto nomem;
2997
2998         return TRUE;
2999
3000 nomem:
3001         dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
3002         return FALSE;
3003 }
3004
3005
3006 /**
3007  * wpas_dbus_getter_bss_wpa - Return the WPA options of a BSS
3008  * @iter: Pointer to incoming dbus message iter
3009  * @error: Location to store error on failure
3010  * @user_data: Function specific data
3011  * Returns: TRUE on success, FALSE on failure
3012  *
3013  * Getter for "WPA" property.
3014  */
3015 dbus_bool_t wpas_dbus_getter_bss_wpa(DBusMessageIter *iter, DBusError *error,
3016                                      void *user_data)
3017 {
3018         struct bss_handler_args *args = user_data;
3019         struct wpa_bss *res;
3020         struct wpa_ie_data wpa_data;
3021         const u8 *ie;
3022
3023         res = get_bss_helper(args, error, __func__);
3024         if (!res)
3025                 return FALSE;
3026
3027         os_memset(&wpa_data, 0, sizeof(wpa_data));
3028         ie = wpa_bss_get_vendor_ie(res, WPA_IE_VENDOR_TYPE);
3029         if (ie) {
3030                 if (wpa_parse_wpa_ie(ie, 2 + ie[1], &wpa_data) < 0) {
3031                         dbus_set_error_const(error, DBUS_ERROR_FAILED,
3032                                              "failed to parse WPA IE");
3033                         return FALSE;
3034                 }
3035         }
3036
3037         return wpas_dbus_get_bss_security_prop(iter, &wpa_data, error);
3038 }
3039
3040
3041 /**
3042  * wpas_dbus_getter_bss_rsn - Return the RSN options of a BSS
3043  * @iter: Pointer to incoming dbus message iter
3044  * @error: Location to store error on failure
3045  * @user_data: Function specific data
3046  * Returns: TRUE on success, FALSE on failure
3047  *
3048  * Getter for "RSN" property.
3049  */
3050 dbus_bool_t wpas_dbus_getter_bss_rsn(DBusMessageIter *iter, DBusError *error,
3051                                      void *user_data)
3052 {
3053         struct bss_handler_args *args = user_data;
3054         struct wpa_bss *res;
3055         struct wpa_ie_data wpa_data;
3056         const u8 *ie;
3057
3058         res = get_bss_helper(args, error, __func__);
3059         if (!res)
3060                 return FALSE;
3061
3062         os_memset(&wpa_data, 0, sizeof(wpa_data));
3063         ie = wpa_bss_get_ie(res, WLAN_EID_RSN);
3064         if (ie) {
3065                 if (wpa_parse_wpa_ie(ie, 2 + ie[1], &wpa_data) < 0) {
3066                         dbus_set_error_const(error, DBUS_ERROR_FAILED,
3067                                              "failed to parse RSN IE");
3068                         return FALSE;
3069                 }
3070         }
3071
3072         return wpas_dbus_get_bss_security_prop(iter, &wpa_data, error);
3073 }
3074
3075
3076 /**
3077  * wpas_dbus_getter_bss_ies - Return all IEs of a BSS
3078  * @iter: Pointer to incoming dbus message iter
3079  * @error: Location to store error on failure
3080  * @user_data: Function specific data
3081  * Returns: TRUE on success, FALSE on failure
3082  *
3083  * Getter for "IEs" property.
3084  */
3085 dbus_bool_t wpas_dbus_getter_bss_ies(DBusMessageIter *iter, DBusError *error,
3086                                      void *user_data)
3087 {
3088         struct bss_handler_args *args = user_data;
3089         struct wpa_bss *res;
3090
3091         res = get_bss_helper(args, error, __func__);
3092         if (!res)
3093                 return FALSE;
3094
3095         return wpas_dbus_simple_array_property_getter(iter, DBUS_TYPE_BYTE,
3096                                                       res + 1, res->ie_len,
3097                                                       error);
3098 }
3099
3100
3101 /**
3102  * wpas_dbus_getter_enabled - Check whether network is enabled or disabled
3103  * @iter: Pointer to incoming dbus message iter
3104  * @error: Location to store error on failure
3105  * @user_data: Function specific data
3106  * Returns: TRUE on success, FALSE on failure
3107  *
3108  * Getter for "enabled" property of a configured network.
3109  */
3110 dbus_bool_t wpas_dbus_getter_enabled(DBusMessageIter *iter, DBusError *error,
3111                                      void *user_data)
3112 {
3113         struct network_handler_args *net = user_data;
3114         dbus_bool_t enabled = net->ssid->disabled ? FALSE : TRUE;
3115
3116         return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_BOOLEAN,
3117                                                 &enabled, error);
3118 }
3119
3120
3121 /**
3122  * wpas_dbus_setter_enabled - Mark a configured network as enabled or disabled
3123  * @iter: Pointer to incoming dbus message iter
3124  * @error: Location to store error on failure
3125  * @user_data: Function specific data
3126  * Returns: TRUE on success, FALSE on failure
3127  *
3128  * Setter for "Enabled" property of a configured network.
3129  */
3130 dbus_bool_t wpas_dbus_setter_enabled(DBusMessageIter *iter, DBusError *error,
3131                                      void *user_data)
3132 {
3133         struct network_handler_args *net = user_data;
3134         struct wpa_supplicant *wpa_s;
3135         struct wpa_ssid *ssid;
3136         dbus_bool_t enable;
3137
3138         if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_BOOLEAN,
3139                                               &enable))
3140                 return FALSE;
3141
3142         wpa_s = net->wpa_s;
3143         ssid = net->ssid;
3144
3145         if (enable)
3146                 wpa_supplicant_enable_network(wpa_s, ssid);
3147         else
3148                 wpa_supplicant_disable_network(wpa_s, ssid);
3149
3150         return TRUE;
3151 }
3152
3153
3154 /**
3155  * wpas_dbus_getter_network_properties - Get options for a configured network
3156  * @iter: Pointer to incoming dbus message iter
3157  * @error: Location to store error on failure
3158  * @user_data: Function specific data
3159  * Returns: TRUE on success, FALSE on failure
3160  *
3161  * Getter for "Properties" property of a configured network.
3162  */
3163 dbus_bool_t wpas_dbus_getter_network_properties(DBusMessageIter *iter,
3164                                                 DBusError *error,
3165                                                 void *user_data)
3166 {
3167         struct network_handler_args *net = user_data;
3168         DBusMessageIter variant_iter, dict_iter;
3169         char **iterator;
3170         char **props = wpa_config_get_all(net->ssid, 1);
3171         dbus_bool_t success = FALSE;
3172
3173         if (!props) {
3174                 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
3175                 return FALSE;
3176         }
3177
3178         if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT, "a{sv}",
3179                                               &variant_iter) ||
3180             !wpa_dbus_dict_open_write(&variant_iter, &dict_iter)) {
3181                 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
3182                 goto out;
3183         }
3184
3185         iterator = props;
3186         while (*iterator) {
3187                 if (!wpa_dbus_dict_append_string(&dict_iter, *iterator,
3188                                                  *(iterator + 1))) {
3189                         dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY,
3190                                              "no memory");
3191                         goto out;
3192                 }
3193                 iterator += 2;
3194         }
3195
3196
3197         if (!wpa_dbus_dict_close_write(&variant_iter, &dict_iter) ||
3198             !dbus_message_iter_close_container(iter, &variant_iter)) {
3199                 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
3200                 goto out;
3201         }
3202
3203         success = TRUE;
3204
3205 out:
3206         iterator = props;
3207         while (*iterator) {
3208                 os_free(*iterator);
3209                 iterator++;
3210         }
3211         os_free(props);
3212         return success;
3213 }
3214
3215
3216 /**
3217  * wpas_dbus_setter_network_properties - Set options for a configured network
3218  * @iter: Pointer to incoming dbus message iter
3219  * @error: Location to store error on failure
3220  * @user_data: Function specific data
3221  * Returns: TRUE on success, FALSE on failure
3222  *
3223  * Setter for "Properties" property of a configured network.
3224  */
3225 dbus_bool_t wpas_dbus_setter_network_properties(DBusMessageIter *iter,
3226                                                 DBusError *error,
3227                                                 void *user_data)
3228 {
3229         struct network_handler_args *net = user_data;
3230         struct wpa_ssid *ssid = net->ssid;
3231         DBusMessageIter variant_iter;
3232
3233         dbus_message_iter_recurse(iter, &variant_iter);
3234         return set_network_properties(net->wpa_s, ssid, &variant_iter, error);
3235 }