wpa_supplicant/dbus/dbus_new.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 software may be distributed under the terms of the BSD license.
   8  * See README for more details.
   9  */
  10
  11 #include "includes.h"
  12
  13 #include "common.h"
  14 #include "common/ieee802_11_defs.h"
  15 #include "wps/wps.h"
  16 #include "../config.h"
  17 #include "../wpa_supplicant_i.h"
  18 #include "../bss.h"
  19 #include "../wpas_glue.h"
  20 #include "dbus_new_helpers.h"
  21 #include "dbus_dict_helpers.h"
  22 #include "dbus_new.h"
  23 #include "dbus_new_handlers.h"
  24 #include "dbus_common_i.h"
  25 #include "dbus_new_handlers_p2p.h"
  26 #include "p2p/p2p.h"
  27 #include "../p2p_supplicant.h"
  28
  29 #ifdef CONFIG_AP /* until needed by something else */
  30
  31 /*
  32  * NameOwnerChanged handling
  33  *
  34  * Some services we provide allow an application to register for
  35  * a signal that it needs. While it can also unregister, we must
  36  * be prepared for the case where the application simply crashes
  37  * and thus doesn't clean up properly. The way to handle this in
  38  * DBus is to register for the NameOwnerChanged signal which will
  39  * signal an owner change to NULL if the peer closes the socket
  40  * for whatever reason.
  41  *
  42  * Handle this signal via a filter function whenever necessary.
  43  * The code below also handles refcounting in case in the future
  44  * there will be multiple instances of this subscription scheme.
  45  */
  46 static const char wpas_dbus_noc_filter_str[] =
  47         "interface=org.freedesktop.DBus,member=NameOwnerChanged";
  48
  49
  50 static DBusHandlerResult noc_filter(DBusConnection *conn,
  51                                     DBusMessage *message, void *data)
  52 {
  53         struct wpas_dbus_priv *priv = data;
  54
  55         if (dbus_message_get_type(message) != DBUS_MESSAGE_TYPE_SIGNAL)
  56                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
  57
  58         if (dbus_message_is_signal(message, DBUS_INTERFACE_DBUS,
  59                                    "NameOwnerChanged")) {
  60                 const char *name;
  61                 const char *prev_owner;
  62                 const char *new_owner;
  63                 DBusError derr;
  64                 struct wpa_supplicant *wpa_s;
  65
  66                 dbus_error_init(&derr);
  67
  68                 if (!dbus_message_get_args(message, &derr,
  69                                            DBUS_TYPE_STRING, &name,
  70                                            DBUS_TYPE_STRING, &prev_owner,
  71                                            DBUS_TYPE_STRING, &new_owner,
  72                                            DBUS_TYPE_INVALID)) {
  73                         /* Ignore this error */
  74                         dbus_error_free(&derr);
  75                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
  76                 }
  77
  78                 for (wpa_s = priv->global->ifaces; wpa_s; wpa_s = wpa_s->next) {
  79                         if (wpa_s->preq_notify_peer != NULL &&
  80                             os_strcmp(name, wpa_s->preq_notify_peer) == 0 &&
  81                             (new_owner == NULL || os_strlen(new_owner) == 0)) {
  82                                 /* probe request owner disconnected */
  83                                 os_free(wpa_s->preq_notify_peer);
  84                                 wpa_s->preq_notify_peer = NULL;
  85                                 wpas_dbus_unsubscribe_noc(priv);
  86                         }
  87                 }
  88         }
  89
  90         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
  91 }
  92
  93
  94 void wpas_dbus_subscribe_noc(struct wpas_dbus_priv *priv)
  95 {
  96         priv->dbus_noc_refcnt++;
  97         if (priv->dbus_noc_refcnt > 1)
  98                 return;
  99
 100         if (!dbus_connection_add_filter(priv->con, noc_filter, priv, NULL)) {
 101                 wpa_printf(MSG_ERROR, "dbus: failed to add filter");
 102                 return;
 103         }
 104
 105         dbus_bus_add_match(priv->con, wpas_dbus_noc_filter_str, NULL);
 106 }
 107
 108
 109 void wpas_dbus_unsubscribe_noc(struct wpas_dbus_priv *priv)
 110 {
 111         priv->dbus_noc_refcnt--;
 112         if (priv->dbus_noc_refcnt > 0)
 113                 return;
 114
 115         dbus_bus_remove_match(priv->con, wpas_dbus_noc_filter_str, NULL);
 116         dbus_connection_remove_filter(priv->con, noc_filter, priv);
 117 }
 118
 119 #endif /* CONFIG_AP */
 120
 121
 122 /**
 123  * wpas_dbus_signal_interface - Send a interface related event signal
 124  * @wpa_s: %wpa_supplicant network interface data
 125  * @sig_name: signal name - InterfaceAdded or InterfaceRemoved
 126  * @properties: Whether to add second argument with object properties
 127  *
 128  * Notify listeners about event related with interface
 129  */
 130 static void wpas_dbus_signal_interface(struct wpa_supplicant *wpa_s,
 131                                        const char *sig_name, int properties)
 132 {
 133         struct wpas_dbus_priv *iface;
 134         DBusMessage *msg;
 135         DBusMessageIter iter;
 136
 137         iface = wpa_s->global->dbus;
 138
 139         /* Do nothing if the control interface is not turned on */
 140         if (iface == NULL || !wpa_s->dbus_new_path)
 141                 return;
 142
 143         msg = dbus_message_new_signal(WPAS_DBUS_NEW_PATH,
 144                                       WPAS_DBUS_NEW_INTERFACE, sig_name);
 145         if (msg == NULL)
 146                 return;
 147
 148         dbus_message_iter_init_append(msg, &iter);
 149         if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_OBJECT_PATH,
 150                                             &wpa_s->dbus_new_path) ||
 151             (properties &&
 152              !wpa_dbus_get_object_properties(
 153                      iface, wpa_s->dbus_new_path,
 154                      WPAS_DBUS_NEW_IFACE_INTERFACE, &iter)))
 155                 wpa_printf(MSG_ERROR, "dbus: Failed to construct signal");
 156         else
 157                 dbus_connection_send(iface->con, msg, NULL);
 158         dbus_message_unref(msg);
 159 }
 160
 161
 162 /**
 163  * wpas_dbus_signal_interface_added - Send a interface created signal
 164  * @wpa_s: %wpa_supplicant network interface data
 165  *
 166  * Notify listeners about creating new interface
 167  */
 168 static void wpas_dbus_signal_interface_added(struct wpa_supplicant *wpa_s)
 169 {
 170         wpas_dbus_signal_interface(wpa_s, "InterfaceAdded", TRUE);
 171 }
 172
 173
 174 /**
 175  * wpas_dbus_signal_interface_removed - Send a interface removed signal
 176  * @wpa_s: %wpa_supplicant network interface data
 177  *
 178  * Notify listeners about removing interface
 179  */
 180 static void wpas_dbus_signal_interface_removed(struct wpa_supplicant *wpa_s)
 181 {
 182         wpas_dbus_signal_interface(wpa_s, "InterfaceRemoved", FALSE);
 183
 184 }
 185
 186
 187 /**
 188  * wpas_dbus_signal_scan_done - send scan done signal
 189  * @wpa_s: %wpa_supplicant network interface data
 190  * @success: indicates if scanning succeed or failed
 191  *
 192  * Notify listeners about finishing a scan
 193  */
 194 void wpas_dbus_signal_scan_done(struct wpa_supplicant *wpa_s, int success)
 195 {
 196         struct wpas_dbus_priv *iface;
 197         DBusMessage *msg;
 198         dbus_bool_t succ;
 199
 200         iface = wpa_s->global->dbus;
 201
 202         /* Do nothing if the control interface is not turned on */
 203         if (iface == NULL || !wpa_s->dbus_new_path)
 204                 return;
 205
 206         msg = dbus_message_new_signal(wpa_s->dbus_new_path,
 207                                       WPAS_DBUS_NEW_IFACE_INTERFACE,
 208                                       "ScanDone");
 209         if (msg == NULL)
 210                 return;
 211
 212         succ = success ? TRUE : FALSE;
 213         if (dbus_message_append_args(msg, DBUS_TYPE_BOOLEAN, &succ,
 214                                      DBUS_TYPE_INVALID))
 215                 dbus_connection_send(iface->con, msg, NULL);
 216         else
 217                 wpa_printf(MSG_ERROR, "dbus: Failed to construct signal");
 218         dbus_message_unref(msg);
 219 }
 220
 221
 222 /**
 223  * wpas_dbus_signal_bss - Send a BSS related event signal
 224  * @wpa_s: %wpa_supplicant network interface data
 225  * @bss_obj_path: BSS object path
 226  * @sig_name: signal name - BSSAdded or BSSRemoved
 227  * @properties: Whether to add second argument with object properties
 228  *
 229  * Notify listeners about event related with BSS
 230  */
 231 static void wpas_dbus_signal_bss(struct wpa_supplicant *wpa_s,
 232                                  const char *bss_obj_path,
 233                                  const char *sig_name, int properties)
 234 {
 235         struct wpas_dbus_priv *iface;
 236         DBusMessage *msg;
 237         DBusMessageIter iter;
 238
 239         iface = wpa_s->global->dbus;
 240
 241         /* Do nothing if the control interface is not turned on */
 242         if (iface == NULL || !wpa_s->dbus_new_path)
 243                 return;
 244
 245         msg = dbus_message_new_signal(wpa_s->dbus_new_path,
 246                                       WPAS_DBUS_NEW_IFACE_INTERFACE,
 247                                       sig_name);
 248         if (msg == NULL)
 249                 return;
 250
 251         dbus_message_iter_init_append(msg, &iter);
 252         if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_OBJECT_PATH,
 253                                             &bss_obj_path) ||
 254             (properties &&
 255              !wpa_dbus_get_object_properties(iface, bss_obj_path,
 256                                              WPAS_DBUS_NEW_IFACE_BSS,
 257                                              &iter)))
 258                 wpa_printf(MSG_ERROR, "dbus: Failed to construct signal");
 259         else
 260                 dbus_connection_send(iface->con, msg, NULL);
 261         dbus_message_unref(msg);
 262 }
 263
 264
 265 /**
 266  * wpas_dbus_signal_bss_added - Send a BSS added signal
 267  * @wpa_s: %wpa_supplicant network interface data
 268  * @bss_obj_path: new BSS object path
 269  *
 270  * Notify listeners about adding new BSS
 271  */
 272 static void wpas_dbus_signal_bss_added(struct wpa_supplicant *wpa_s,
 273                                        const char *bss_obj_path)
 274 {
 275         wpas_dbus_signal_bss(wpa_s, bss_obj_path, "BSSAdded", TRUE);
 276 }
 277
 278
 279 /**
 280  * wpas_dbus_signal_bss_removed - Send a BSS removed signal
 281  * @wpa_s: %wpa_supplicant network interface data
 282  * @bss_obj_path: BSS object path
 283  *
 284  * Notify listeners about removing BSS
 285  */
 286 static void wpas_dbus_signal_bss_removed(struct wpa_supplicant *wpa_s,
 287                                          const char *bss_obj_path)
 288 {
 289         wpas_dbus_signal_bss(wpa_s, bss_obj_path, "BSSRemoved", FALSE);
 290 }
 291
 292
 293 /**
 294  * wpas_dbus_signal_blob - Send a blob related event signal
 295  * @wpa_s: %wpa_supplicant network interface data
 296  * @name: blob name
 297  * @sig_name: signal name - BlobAdded or BlobRemoved
 298  *
 299  * Notify listeners about event related with blob
 300  */
 301 static void wpas_dbus_signal_blob(struct wpa_supplicant *wpa_s,
 302                                   const char *name, const char *sig_name)
 303 {
 304         struct wpas_dbus_priv *iface;
 305         DBusMessage *msg;
 306
 307         iface = wpa_s->global->dbus;
 308
 309         /* Do nothing if the control interface is not turned on */
 310         if (iface == NULL || !wpa_s->dbus_new_path)
 311                 return;
 312
 313         msg = dbus_message_new_signal(wpa_s->dbus_new_path,
 314                                       WPAS_DBUS_NEW_IFACE_INTERFACE,
 315                                       sig_name);
 316         if (msg == NULL)
 317                 return;
 318
 319         if (dbus_message_append_args(msg, DBUS_TYPE_STRING, &name,
 320                                      DBUS_TYPE_INVALID))
 321                 dbus_connection_send(iface->con, msg, NULL);
 322         else
 323                 wpa_printf(MSG_ERROR, "dbus: Failed to construct signal");
 324         dbus_message_unref(msg);
 325 }
 326
 327
 328 /**
 329  * wpas_dbus_signal_blob_added - Send a blob added signal
 330  * @wpa_s: %wpa_supplicant network interface data
 331  * @name: blob name
 332  *
 333  * Notify listeners about adding a new blob
 334  */
 335 void wpas_dbus_signal_blob_added(struct wpa_supplicant *wpa_s,
 336                                  const char *name)
 337 {
 338         wpas_dbus_signal_blob(wpa_s, name, "BlobAdded");
 339 }
 340
 341
 342 /**
 343  * wpas_dbus_signal_blob_removed - Send a blob removed signal
 344  * @wpa_s: %wpa_supplicant network interface data
 345  * @name: blob name
 346  *
 347  * Notify listeners about removing blob
 348  */
 349 void wpas_dbus_signal_blob_removed(struct wpa_supplicant *wpa_s,
 350                                    const char *name)
 351 {
 352         wpas_dbus_signal_blob(wpa_s, name, "BlobRemoved");
 353 }
 354
 355
 356 /**
 357  * wpas_dbus_signal_network - Send a network related event signal
 358  * @wpa_s: %wpa_supplicant network interface data
 359  * @id: new network id
 360  * @sig_name: signal name - NetworkAdded, NetworkRemoved or NetworkSelected
 361  * @properties: determines if add second argument with object properties
 362  *
 363  * Notify listeners about event related with configured network
 364  */
 365 static void wpas_dbus_signal_network(struct wpa_supplicant *wpa_s,
 366                                      int id, const char *sig_name,
 367                                      int properties)
 368 {
 369         struct wpas_dbus_priv *iface;
 370         DBusMessage *msg;
 371         DBusMessageIter iter;
 372         char net_obj_path[WPAS_DBUS_OBJECT_PATH_MAX], *path;
 373
 374         iface = wpa_s->global->dbus;
 375
 376         /* Do nothing if the control interface is not turned on */
 377         if (iface == NULL || !wpa_s->dbus_new_path)
 378                 return;
 379
 380         os_snprintf(net_obj_path, WPAS_DBUS_OBJECT_PATH_MAX,
 381                     "%s/" WPAS_DBUS_NEW_NETWORKS_PART "/%u",
 382                     wpa_s->dbus_new_path, id);
 383
 384         msg = dbus_message_new_signal(wpa_s->dbus_new_path,
 385                                       WPAS_DBUS_NEW_IFACE_INTERFACE,
 386                                       sig_name);
 387         if (msg == NULL)
 388                 return;
 389
 390         dbus_message_iter_init_append(msg, &iter);
 391         path = net_obj_path;
 392         if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_OBJECT_PATH,
 393                                             &path) ||
 394             (properties &&
 395              !wpa_dbus_get_object_properties(
 396                      iface, net_obj_path, WPAS_DBUS_NEW_IFACE_NETWORK,
 397                      &iter)))
 398                 wpa_printf(MSG_ERROR, "dbus: Failed to construct signal");
 399         else
 400                 dbus_connection_send(iface->con, msg, NULL);
 401         dbus_message_unref(msg);
 402 }
 403
 404
 405 /**
 406  * wpas_dbus_signal_network_added - Send a network added signal
 407  * @wpa_s: %wpa_supplicant network interface data
 408  * @id: new network id
 409  *
 410  * Notify listeners about adding new network
 411  */
 412 static void wpas_dbus_signal_network_added(struct wpa_supplicant *wpa_s,
 413                                            int id)
 414 {
 415         wpas_dbus_signal_network(wpa_s, id, "NetworkAdded", TRUE);
 416 }
 417
 418
 419 /**
 420  * wpas_dbus_signal_network_removed - Send a network removed signal
 421  * @wpa_s: %wpa_supplicant network interface data
 422  * @id: network id
 423  *
 424  * Notify listeners about removing a network
 425  */
 426 static void wpas_dbus_signal_network_removed(struct wpa_supplicant *wpa_s,
 427                                              int id)
 428 {
 429         wpas_dbus_signal_network(wpa_s, id, "NetworkRemoved", FALSE);
 430 }
 431
 432
 433 /**
 434  * wpas_dbus_signal_network_selected - Send a network selected signal
 435  * @wpa_s: %wpa_supplicant network interface data
 436  * @id: network id
 437  *
 438  * Notify listeners about selecting a network
 439  */
 440 void wpas_dbus_signal_network_selected(struct wpa_supplicant *wpa_s, int id)
 441 {
 442         wpas_dbus_signal_network(wpa_s, id, "NetworkSelected", FALSE);
 443 }
 444
 445
 446 /**
 447  * wpas_dbus_signal_network_request - Indicate that additional information
 448  * (EAP password, etc.) is required to complete the association to this SSID
 449  * @wpa_s: %wpa_supplicant network interface data
 450  * @rtype: The specific additional information required
 451  * @default_text: Optional description of required information
 452  *
 453  * Request additional information or passwords to complete an association
 454  * request.
 455  */
 456 void wpas_dbus_signal_network_request(struct wpa_supplicant *wpa_s,
 457                                       struct wpa_ssid *ssid,
 458                                       enum wpa_ctrl_req_type rtype,
 459                                       const char *default_txt)
 460 {
 461         struct wpas_dbus_priv *iface;
 462         DBusMessage *msg;
 463         DBusMessageIter iter;
 464         char net_obj_path[WPAS_DBUS_OBJECT_PATH_MAX];
 465         const char *field, *txt = NULL, *net_ptr;
 466
 467         iface = wpa_s->global->dbus;
 468
 469         /* Do nothing if the control interface is not turned on */
 470         if (iface == NULL || !wpa_s->dbus_new_path)
 471                 return;
 472
 473         field = wpa_supplicant_ctrl_req_to_string(rtype, default_txt, &txt);
 474         if (field == NULL)
 475                 return;
 476
 477         msg = dbus_message_new_signal(wpa_s->dbus_new_path,
 478                                       WPAS_DBUS_NEW_IFACE_INTERFACE,
 479                                       "NetworkRequest");
 480         if (msg == NULL)
 481                 return;
 482
 483         os_snprintf(net_obj_path, WPAS_DBUS_OBJECT_PATH_MAX,
 484                     "%s/" WPAS_DBUS_NEW_NETWORKS_PART "/%u",
 485                     wpa_s->dbus_new_path, ssid->id);
 486         net_ptr = &net_obj_path[0];
 487
 488         dbus_message_iter_init_append(msg, &iter);
 489         if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_OBJECT_PATH,
 490                                             &net_ptr) ||
 491             !dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &field) ||
 492             !dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &txt))
 493                 wpa_printf(MSG_ERROR, "dbus: Failed to construct signal");
 494         else
 495                 dbus_connection_send(iface->con, msg, NULL);
 496         dbus_message_unref(msg);
 497 }
 498
 499
 500 /**
 501  * wpas_dbus_signal_network_enabled_changed - Signals Enabled property changes
 502  * @wpa_s: %wpa_supplicant network interface data
 503  * @ssid: configured network which Enabled property has changed
 504  *
 505  * Sends PropertyChanged signals containing new value of Enabled property
 506  * for specified network
 507  */
 508 void wpas_dbus_signal_network_enabled_changed(struct wpa_supplicant *wpa_s,
 509                                               struct wpa_ssid *ssid)
 510 {
 511
 512         char path[WPAS_DBUS_OBJECT_PATH_MAX];
 513
 514         if (!wpa_s->dbus_new_path)
 515                 return;
 516         os_snprintf(path, WPAS_DBUS_OBJECT_PATH_MAX,
 517                     "%s/" WPAS_DBUS_NEW_NETWORKS_PART "/%d",
 518                     wpa_s->dbus_new_path, ssid->id);
 519
 520         wpa_dbus_mark_property_changed(wpa_s->global->dbus, path,
 521                                        WPAS_DBUS_NEW_IFACE_NETWORK, "Enabled");
 522 }
 523
 524
 525 #ifdef CONFIG_WPS
 526
 527 /**
 528  * wpas_dbus_signal_wps_event_pbc_overlap - Signals PBC overlap WPS event
 529  * @wpa_s: %wpa_supplicant network interface data
 530  *
 531  * Sends Event dbus signal with name "pbc-overlap" and empty dict as arguments
 532  */
 533 void wpas_dbus_signal_wps_event_pbc_overlap(struct wpa_supplicant *wpa_s)
 534 {
 535
 536         DBusMessage *msg;
 537         DBusMessageIter iter, dict_iter;
 538         struct wpas_dbus_priv *iface;
 539         char *key = "pbc-overlap";
 540
 541         iface = wpa_s->global->dbus;
 542
 543         /* Do nothing if the control interface is not turned on */
 544         if (iface == NULL || !wpa_s->dbus_new_path)
 545                 return;
 546
 547         msg = dbus_message_new_signal(wpa_s->dbus_new_path,
 548                                       WPAS_DBUS_NEW_IFACE_WPS, "Event");
 549         if (msg == NULL)
 550                 return;
 551
 552         dbus_message_iter_init_append(msg, &iter);
 553
 554         if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &key) ||
 555             !wpa_dbus_dict_open_write(&iter, &dict_iter) ||
 556             !wpa_dbus_dict_close_write(&iter, &dict_iter))
 557                 wpa_printf(MSG_ERROR, "dbus: Failed to construct signal");
 558         else
 559                 dbus_connection_send(iface->con, msg, NULL);
 560
 561         dbus_message_unref(msg);
 562 }
 563
 564
 565 /**
 566  * wpas_dbus_signal_wps_event_success - Signals Success WPS event
 567  * @wpa_s: %wpa_supplicant network interface data
 568  *
 569  * Sends Event dbus signal with name "success" and empty dict as arguments
 570  */
 571 void wpas_dbus_signal_wps_event_success(struct wpa_supplicant *wpa_s)
 572 {
 573
 574         DBusMessage *msg;
 575         DBusMessageIter iter, dict_iter;
 576         struct wpas_dbus_priv *iface;
 577         char *key = "success";
 578
 579         iface = wpa_s->global->dbus;
 580
 581         /* Do nothing if the control interface is not turned on */
 582         if (iface == NULL || !wpa_s->dbus_new_path)
 583                 return;
 584
 585         msg = dbus_message_new_signal(wpa_s->dbus_new_path,
 586                                       WPAS_DBUS_NEW_IFACE_WPS, "Event");
 587         if (msg == NULL)
 588                 return;
 589
 590         dbus_message_iter_init_append(msg, &iter);
 591
 592         if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &key) ||
 593             !wpa_dbus_dict_open_write(&iter, &dict_iter) ||
 594             !wpa_dbus_dict_close_write(&iter, &dict_iter))
 595                 wpa_printf(MSG_ERROR, "dbus: Failed to construct signal");
 596         else
 597                 dbus_connection_send(iface->con, msg, NULL);
 598
 599         dbus_message_unref(msg);
 600 }
 601
 602
 603 /**
 604  * wpas_dbus_signal_wps_event_fail - Signals Fail WPS event
 605  * @wpa_s: %wpa_supplicant network interface data
 606  * @fail: WPS failure information
 607  *
 608  * Sends Event dbus signal with name "fail" and dictionary containing
 609  * "msg field with fail message number (int32) as arguments
 610  */
 611 void wpas_dbus_signal_wps_event_fail(struct wpa_supplicant *wpa_s,
 612                                      struct wps_event_fail *fail)
 613 {
 614
 615         DBusMessage *msg;
 616         DBusMessageIter iter, dict_iter;
 617         struct wpas_dbus_priv *iface;
 618         char *key = "fail";
 619
 620         iface = wpa_s->global->dbus;
 621
 622         /* Do nothing if the control interface is not turned on */
 623         if (iface == NULL || !wpa_s->dbus_new_path)
 624                 return;
 625
 626         msg = dbus_message_new_signal(wpa_s->dbus_new_path,
 627                                       WPAS_DBUS_NEW_IFACE_WPS, "Event");
 628         if (msg == NULL)
 629                 return;
 630
 631         dbus_message_iter_init_append(msg, &iter);
 632
 633         if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &key) ||
 634             !wpa_dbus_dict_open_write(&iter, &dict_iter) ||
 635             !wpa_dbus_dict_append_int32(&dict_iter, "msg", fail->msg) ||
 636             !wpa_dbus_dict_close_write(&iter, &dict_iter))
 637                 wpa_printf(MSG_ERROR, "dbus: Failed to construct signal");
 638         else
 639                 dbus_connection_send(iface->con, msg, NULL);
 640
 641         dbus_message_unref(msg);
 642 }
 643
 644
 645 /**
 646  * wpas_dbus_signal_wps_event_m2d - Signals M2D WPS event
 647  * @wpa_s: %wpa_supplicant network interface data
 648  * @m2d: M2D event data information
 649  *
 650  * Sends Event dbus signal with name "m2d" and dictionary containing
 651  * fields of wps_event_m2d structure.
 652  */
 653 void wpas_dbus_signal_wps_event_m2d(struct wpa_supplicant *wpa_s,
 654                                     struct wps_event_m2d *m2d)
 655 {
 656
 657         DBusMessage *msg;
 658         DBusMessageIter iter, dict_iter;
 659         struct wpas_dbus_priv *iface;
 660         char *key = "m2d";
 661
 662         iface = wpa_s->global->dbus;
 663
 664         /* Do nothing if the control interface is not turned on */
 665         if (iface == NULL || !wpa_s->dbus_new_path)
 666                 return;
 667
 668         msg = dbus_message_new_signal(wpa_s->dbus_new_path,
 669                                       WPAS_DBUS_NEW_IFACE_WPS, "Event");
 670         if (msg == NULL)
 671                 return;
 672
 673         dbus_message_iter_init_append(msg, &iter);
 674
 675         if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &key) ||
 676             !wpa_dbus_dict_open_write(&iter, &dict_iter) ||
 677             !wpa_dbus_dict_append_uint16(&dict_iter, "config_methods",
 678                                          m2d->config_methods) ||
 679             !wpa_dbus_dict_append_byte_array(&dict_iter, "manufacturer",
 680                                              (const char *) m2d->manufacturer,
 681                                              m2d->manufacturer_len) ||
 682             !wpa_dbus_dict_append_byte_array(&dict_iter, "model_name",
 683                                              (const char *) m2d->model_name,
 684                                              m2d->model_name_len) ||
 685             !wpa_dbus_dict_append_byte_array(&dict_iter, "model_number",
 686                                              (const char *) m2d->model_number,
 687                                              m2d->model_number_len) ||
 688             !wpa_dbus_dict_append_byte_array(&dict_iter, "serial_number",
 689                                              (const char *)
 690                                              m2d->serial_number,
 691                                              m2d->serial_number_len) ||
 692             !wpa_dbus_dict_append_byte_array(&dict_iter, "dev_name",
 693                                              (const char *) m2d->dev_name,
 694                                              m2d->dev_name_len) ||
 695             !wpa_dbus_dict_append_byte_array(&dict_iter, "primary_dev_type",
 696                                              (const char *)
 697                                              m2d->primary_dev_type, 8) ||
 698             !wpa_dbus_dict_append_uint16(&dict_iter, "config_error",
 699                                          m2d->config_error) ||
 700             !wpa_dbus_dict_append_uint16(&dict_iter, "dev_password_id",
 701                                          m2d->dev_password_id) ||
 702             !wpa_dbus_dict_close_write(&iter, &dict_iter))
 703                 wpa_printf(MSG_ERROR, "dbus: Failed to construct signal");
 704         else
 705                 dbus_connection_send(iface->con, msg, NULL);
 706
 707         dbus_message_unref(msg);
 708 }
 709
 710
 711 /**
 712  * wpas_dbus_signal_wps_cred - Signals new credentials
 713  * @wpa_s: %wpa_supplicant network interface data
 714  * @cred: WPS Credential information
 715  *
 716  * Sends signal with credentials in directory argument
 717  */
 718 void wpas_dbus_signal_wps_cred(struct wpa_supplicant *wpa_s,
 719                                const struct wps_credential *cred)
 720 {
 721         DBusMessage *msg;
 722         DBusMessageIter iter, dict_iter;
 723         struct wpas_dbus_priv *iface;
 724         char *auth_type[5]; /* we have five possible authentication types */
 725         int at_num = 0;
 726         char *encr_type[3]; /* we have three possible encryption types */
 727         int et_num = 0;
 728
 729         iface = wpa_s->global->dbus;
 730
 731         /* Do nothing if the control interface is not turned on */
 732         if (iface == NULL || !wpa_s->dbus_new_path)
 733                 return;
 734
 735         msg = dbus_message_new_signal(wpa_s->dbus_new_path,
 736                                       WPAS_DBUS_NEW_IFACE_WPS,
 737                                       "Credentials");
 738         if (msg == NULL)
 739                 return;
 740
 741         dbus_message_iter_init_append(msg, &iter);
 742         if (!wpa_dbus_dict_open_write(&iter, &dict_iter))
 743                 goto nomem;
 744
 745         if (cred->auth_type & WPS_AUTH_OPEN)
 746                 auth_type[at_num++] = "open";
 747         if (cred->auth_type & WPS_AUTH_WPAPSK)
 748                 auth_type[at_num++] = "wpa-psk";
 749         if (cred->auth_type & WPS_AUTH_WPA)
 750                 auth_type[at_num++] = "wpa-eap";
 751         if (cred->auth_type & WPS_AUTH_WPA2)
 752                 auth_type[at_num++] = "wpa2-eap";
 753         if (cred->auth_type & WPS_AUTH_WPA2PSK)
 754                 auth_type[at_num++] = "wpa2-psk";
 755
 756         if (cred->encr_type & WPS_ENCR_NONE)
 757                 encr_type[et_num++] = "none";
 758         if (cred->encr_type & WPS_ENCR_TKIP)
 759                 encr_type[et_num++] = "tkip";
 760         if (cred->encr_type & WPS_ENCR_AES)
 761                 encr_type[et_num++] = "aes";
 762
 763         if ((wpa_s->current_ssid &&
 764              !wpa_dbus_dict_append_byte_array(
 765                      &dict_iter, "BSSID",
 766                      (const char *) wpa_s->current_ssid->bssid, ETH_ALEN)) ||
 767             !wpa_dbus_dict_append_byte_array(&dict_iter, "SSID",
 768                                              (const char *) cred->ssid,
 769                                              cred->ssid_len) ||
 770             !wpa_dbus_dict_append_string_array(&dict_iter, "AuthType",
 771                                                (const char **) auth_type,
 772                                                at_num) ||
 773             !wpa_dbus_dict_append_string_array(&dict_iter, "EncrType",
 774                                                (const char **) encr_type,
 775                                                et_num) ||
 776             !wpa_dbus_dict_append_byte_array(&dict_iter, "Key",
 777                                              (const char *) cred->key,
 778                                              cred->key_len) ||
 779             !wpa_dbus_dict_append_uint32(&dict_iter, "KeyIndex",
 780                                          cred->key_idx) ||
 781             !wpa_dbus_dict_close_write(&iter, &dict_iter))
 782                 goto nomem;
 783
 784         dbus_connection_send(iface->con, msg, NULL);
 785
 786 nomem:
 787         dbus_message_unref(msg);
 788 }
 789
 790 #endif /* CONFIG_WPS */
 791
 792 void wpas_dbus_signal_certification(struct wpa_supplicant *wpa_s,
 793                                     int depth, const char *subject,
 794                                     const char *altsubject[],
 795                                     int num_altsubject,
 796                                     const char *cert_hash,
 797                                     const struct wpabuf *cert)
 798 {
 799         struct wpas_dbus_priv *iface;
 800         DBusMessage *msg;
 801         DBusMessageIter iter, dict_iter;
 802
 803         iface = wpa_s->global->dbus;
 804
 805         /* Do nothing if the control interface is not turned on */
 806         if (iface == NULL || !wpa_s->dbus_new_path)
 807                 return;
 808
 809         msg = dbus_message_new_signal(wpa_s->dbus_new_path,
 810                                       WPAS_DBUS_NEW_IFACE_INTERFACE,
 811                                       "Certification");
 812         if (msg == NULL)
 813                 return;
 814
 815         dbus_message_iter_init_append(msg, &iter);
 816         if (!wpa_dbus_dict_open_write(&iter, &dict_iter) ||
 817             !wpa_dbus_dict_append_uint32(&dict_iter, "depth", depth) ||
 818             !wpa_dbus_dict_append_string(&dict_iter, "subject", subject) ||
 819             (altsubject && num_altsubject &&
 820              !wpa_dbus_dict_append_string_array(&dict_iter, "altsubject",
 821                                                 altsubject, num_altsubject)) ||
 822             (cert_hash &&
 823              !wpa_dbus_dict_append_string(&dict_iter, "cert_hash",
 824                                           cert_hash)) ||
 825             (cert &&
 826              !wpa_dbus_dict_append_byte_array(&dict_iter, "cert",
 827                                               wpabuf_head(cert),
 828                                               wpabuf_len(cert))) ||
 829             !wpa_dbus_dict_close_write(&iter, &dict_iter))
 830                 wpa_printf(MSG_ERROR, "dbus: Failed to construct signal");
 831         else
 832                 dbus_connection_send(iface->con, msg, NULL);
 833         dbus_message_unref(msg);
 834 }
 835
 836
 837 void wpas_dbus_signal_eap_status(struct wpa_supplicant *wpa_s,
 838                                  const char *status, const char *parameter)
 839 {
 840         struct wpas_dbus_priv *iface;
 841         DBusMessage *msg;
 842         DBusMessageIter iter;
 843
 844         iface = wpa_s->global->dbus;
 845
 846         /* Do nothing if the control interface is not turned on */
 847         if (iface == NULL || !wpa_s->dbus_new_path)
 848                 return;
 849
 850         msg = dbus_message_new_signal(wpa_s->dbus_new_path,
 851                                       WPAS_DBUS_NEW_IFACE_INTERFACE,
 852                                       "EAP");
 853         if (msg == NULL)
 854                 return;
 855
 856         dbus_message_iter_init_append(msg, &iter);
 857
 858         if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &status) ||
 859             !dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING,
 860                                             &parameter))
 861                 wpa_printf(MSG_ERROR, "dbus: Failed to construct signal");
 862         else
 863                 dbus_connection_send(iface->con, msg, NULL);
 864         dbus_message_unref(msg);
 865 }
 866
 867
 868 /**
 869  * wpas_dbus_signal_sta - Send a station related event signal
 870  * @wpa_s: %wpa_supplicant network interface data
 871  * @sta: station mac address
 872  * @sig_name: signal name - StaAuthorized or StaDeauthorized
 873  *
 874  * Notify listeners about event related with station
 875  */
 876 static void wpas_dbus_signal_sta(struct wpa_supplicant *wpa_s,
 877                                  const u8 *sta, const char *sig_name)
 878 {
 879         struct wpas_dbus_priv *iface;
 880         DBusMessage *msg;
 881         char sta_mac[WPAS_DBUS_OBJECT_PATH_MAX];
 882         char *dev_mac;
 883
 884         os_snprintf(sta_mac, WPAS_DBUS_OBJECT_PATH_MAX, MACSTR, MAC2STR(sta));
 885         dev_mac = sta_mac;
 886
 887         iface = wpa_s->global->dbus;
 888
 889         /* Do nothing if the control interface is not turned on */
 890         if (iface == NULL || !wpa_s->dbus_new_path)
 891                 return;
 892
 893         msg = dbus_message_new_signal(wpa_s->dbus_new_path,
 894                                       WPAS_DBUS_NEW_IFACE_INTERFACE, sig_name);
 895         if (msg == NULL)
 896                 return;
 897
 898         if (dbus_message_append_args(msg, DBUS_TYPE_STRING, &dev_mac,
 899                                      DBUS_TYPE_INVALID))
 900                 dbus_connection_send(iface->con, msg, NULL);
 901         else
 902                 wpa_printf(MSG_ERROR, "dbus: Failed to construct signal");
 903         dbus_message_unref(msg);
 904
 905         wpa_printf(MSG_DEBUG, "dbus: Station MAC address '%s' '%s'",
 906                    sta_mac, sig_name);
 907 }
 908
 909
 910 /**
 911  * wpas_dbus_signal_sta_authorized - Send a STA authorized signal
 912  * @wpa_s: %wpa_supplicant network interface data
 913  * @sta: station mac address
 914  *
 915  * Notify listeners a new station has been authorized
 916  */
 917 void wpas_dbus_signal_sta_authorized(struct wpa_supplicant *wpa_s,
 918                                      const u8 *sta)
 919 {
 920         wpas_dbus_signal_sta(wpa_s, sta, "StaAuthorized");
 921 }
 922
 923
 924 /**
 925  * wpas_dbus_signal_sta_deauthorized - Send a STA deauthorized signal
 926  * @wpa_s: %wpa_supplicant network interface data
 927  * @sta: station mac address
 928  *
 929  * Notify listeners a station has been deauthorized
 930  */
 931 void wpas_dbus_signal_sta_deauthorized(struct wpa_supplicant *wpa_s,
 932                                        const u8 *sta)
 933 {
 934         wpas_dbus_signal_sta(wpa_s, sta, "StaDeauthorized");
 935 }
 936
 937
 938 #ifdef CONFIG_P2P
 939
 940 /**
 941  * wpas_dbus_signal_p2p_group_removed - Signals P2P group was removed
 942  * @wpa_s: %wpa_supplicant network interface data
 943  * @role: role of this device (client or GO)
 944  * Sends signal with i/f name and role as string arguments
 945  */
 946 void wpas_dbus_signal_p2p_group_removed(struct wpa_supplicant *wpa_s,
 947                                         const char *role)
 948 {
 949         DBusMessage *msg;
 950         DBusMessageIter iter, dict_iter;
 951         struct wpas_dbus_priv *iface = wpa_s->global->dbus;
 952         struct wpa_supplicant *parent;
 953
 954         /* Do nothing if the control interface is not turned on */
 955         if (iface == NULL)
 956                 return;
 957
 958         parent = wpa_s->parent;
 959         if (parent->p2p_mgmt)
 960                 parent = parent->parent;
 961
 962         if (!wpa_s->dbus_groupobj_path || !wpa_s->dbus_new_path ||
 963             !parent->dbus_new_path)
 964                 return;
 965
 966         msg = dbus_message_new_signal(parent->dbus_new_path,
 967                                       WPAS_DBUS_NEW_IFACE_P2PDEVICE,
 968                                       "GroupFinished");
 969         if (msg == NULL)
 970                 return;
 971
 972         dbus_message_iter_init_append(msg, &iter);
 973         if (!wpa_dbus_dict_open_write(&iter, &dict_iter) ||
 974             !wpa_dbus_dict_append_object_path(&dict_iter,
 975                                               "interface_object",
 976                                               wpa_s->dbus_new_path) ||
 977             !wpa_dbus_dict_append_string(&dict_iter, "role", role) ||
 978             !wpa_dbus_dict_append_object_path(&dict_iter, "group_object",
 979                                               wpa_s->dbus_groupobj_path) ||
 980             !wpa_dbus_dict_close_write(&iter, &dict_iter))
 981                 wpa_printf(MSG_ERROR, "dbus: Failed to construct signal");
 982         else
 983                 dbus_connection_send(iface->con, msg, NULL);
 984         dbus_message_unref(msg);
 985 }
 986
 987
 988 /**
 989  * wpas_dbus_signal_p2p_provision_discovery - Signals various PD events
 990  *
 991  * @dev_addr - who sent the request or responded to our request.
 992  * @request - Will be 1 if request, 0 for response.
 993  * @status - valid only in case of response
 994  * @config_methods - wps config methods
 995  * @generated_pin - pin to be displayed in case of WPS_CONFIG_DISPLAY method
 996  *
 997  * Sends following provision discovery related events:
 998  *      ProvisionDiscoveryRequestDisplayPin
 999  *      ProvisionDiscoveryResponseDisplayPin
1000  *      ProvisionDiscoveryRequestEnterPin
1001  *      ProvisionDiscoveryResponseEnterPin
1002  *      ProvisionDiscoveryPBCRequest
1003  *      ProvisionDiscoveryPBCResponse
1004  *
1005  *      TODO::
1006  *      ProvisionDiscoveryFailure (timeout case)
1007  */
1008 void wpas_dbus_signal_p2p_provision_discovery(struct wpa_supplicant *wpa_s,
1009                                               const u8 *dev_addr, int request,
1010                                               enum p2p_prov_disc_status status,
1011                                               u16 config_methods,
1012                                               unsigned int generated_pin)
1013 {
1014         DBusMessage *msg;
1015         DBusMessageIter iter;
1016         struct wpas_dbus_priv *iface;
1017         char *_signal;
1018         int add_pin = 0;
1019         char peer_obj_path[WPAS_DBUS_OBJECT_PATH_MAX], *path;
1020         int error_ret = 1;
1021         char pin[9], *p_pin = NULL;
1022
1023         iface = wpa_s->global->dbus;
1024
1025         /* Do nothing if the control interface is not turned on */
1026         if (iface == NULL)
1027                 return;
1028
1029         if (wpa_s->p2p_mgmt)
1030                 wpa_s = wpa_s->parent;
1031         if (!wpa_s->dbus_new_path)
1032                 return;
1033
1034         if (request || !status) {
1035                 if (config_methods & WPS_CONFIG_DISPLAY)
1036                         _signal = request ?
1037                                  "ProvisionDiscoveryRequestDisplayPin" :
1038                                  "ProvisionDiscoveryResponseEnterPin";
1039                 else if (config_methods & WPS_CONFIG_KEYPAD)
1040                         _signal = request ?
1041                                  "ProvisionDiscoveryRequestEnterPin" :
1042                                  "ProvisionDiscoveryResponseDisplayPin";
1043                 else if (config_methods & WPS_CONFIG_PUSHBUTTON)
1044                         _signal = request ? "ProvisionDiscoveryPBCRequest" :
1045                                    "ProvisionDiscoveryPBCResponse";
1046                 else
1047                         return; /* Unknown or un-supported method */
1048         } else {
1049                 /* Explicit check for failure response */
1050                 _signal = "ProvisionDiscoveryFailure";
1051         }
1052
1053         add_pin = ((request && (config_methods & WPS_CONFIG_DISPLAY)) ||
1054                    (!request && !status &&
1055                         (config_methods & WPS_CONFIG_KEYPAD)));
1056
1057         if (add_pin) {
1058                 os_snprintf(pin, sizeof(pin), "%08d", generated_pin);
1059                 p_pin = pin;
1060         }
1061
1062         msg = dbus_message_new_signal(wpa_s->dbus_new_path,
1063                                       WPAS_DBUS_NEW_IFACE_P2PDEVICE, _signal);
1064         if (msg == NULL)
1065                 return;
1066
1067         /* Check if this is a known peer */
1068         if (!p2p_peer_known(wpa_s->global->p2p, dev_addr))
1069                 goto error;
1070
1071         os_snprintf(peer_obj_path, WPAS_DBUS_OBJECT_PATH_MAX,
1072                         "%s/" WPAS_DBUS_NEW_P2P_PEERS_PART "/"
1073                         COMPACT_MACSTR,
1074                         wpa_s->dbus_new_path, MAC2STR(dev_addr));
1075
1076         path = peer_obj_path;
1077
1078         dbus_message_iter_init_append(msg, &iter);
1079
1080         if (!dbus_message_iter_append_basic(&iter,
1081                                             DBUS_TYPE_OBJECT_PATH,
1082                                             &path))
1083                         goto error;
1084
1085         if (!request && status)
1086                 /* Attach status to ProvisionDiscoveryFailure */
1087                 error_ret = !dbus_message_iter_append_basic(&iter,
1088                                                     DBUS_TYPE_INT32,
1089                                                     &status);
1090         else
1091                 error_ret = (add_pin &&
1092                                  !dbus_message_iter_append_basic(&iter,
1093                                                         DBUS_TYPE_STRING,
1094                                                         &p_pin));
1095
1096 error:
1097         if (!error_ret)
1098                 dbus_connection_send(iface->con, msg, NULL);
1099         else
1100                 wpa_printf(MSG_ERROR, "dbus: Failed to construct signal");
1101
1102         dbus_message_unref(msg);
1103 }
1104
1105
1106 /**
1107  * wpas_dbus_signal_p2p_go_neg_req - Signal P2P GO Negotiation Request RX
1108  * @wpa_s: %wpa_supplicant network interface data
1109  * @src: Source address of the message triggering this notification
1110  * @dev_passwd_id: WPS Device Password Id
1111  * @go_intent: Peer's GO Intent value
1112  *
1113  * Sends signal to notify that a peer P2P Device is requesting group owner
1114  * negotiation with us.
1115  */
1116 void wpas_dbus_signal_p2p_go_neg_req(struct wpa_supplicant *wpa_s,
1117                                      const u8 *src, u16 dev_passwd_id,
1118                                      u8 go_intent)
1119 {
1120         DBusMessage *msg;
1121         DBusMessageIter iter;
1122         struct wpas_dbus_priv *iface;
1123         char peer_obj_path[WPAS_DBUS_OBJECT_PATH_MAX], *path;
1124
1125         iface = wpa_s->global->dbus;
1126
1127         /* Do nothing if the control interface is not turned on */
1128         if (iface == NULL)
1129                 return;
1130
1131         if (wpa_s->p2p_mgmt)
1132                 wpa_s = wpa_s->parent;
1133         if (!wpa_s->dbus_new_path)
1134                 return;
1135
1136         os_snprintf(peer_obj_path, WPAS_DBUS_OBJECT_PATH_MAX,
1137                     "%s/" WPAS_DBUS_NEW_P2P_PEERS_PART "/" COMPACT_MACSTR,
1138                     wpa_s->dbus_new_path, MAC2STR(src));
1139         path = peer_obj_path;
1140
1141         msg = dbus_message_new_signal(wpa_s->dbus_new_path,
1142                                       WPAS_DBUS_NEW_IFACE_P2PDEVICE,
1143                                       "GONegotiationRequest");
1144         if (msg == NULL)
1145                 return;
1146
1147         dbus_message_iter_init_append(msg, &iter);
1148
1149         if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_OBJECT_PATH,
1150                                             &path) ||
1151             !dbus_message_iter_append_basic(&iter, DBUS_TYPE_UINT16,
1152                                             &dev_passwd_id) ||
1153             !dbus_message_iter_append_basic(&iter, DBUS_TYPE_BYTE,
1154                                             &go_intent))
1155                 wpa_printf(MSG_ERROR, "dbus: Failed to construct signal");
1156         else
1157                 dbus_connection_send(iface->con, msg, NULL);
1158
1159         dbus_message_unref(msg);
1160 }
1161
1162
1163 static int wpas_dbus_get_group_obj_path(struct wpa_supplicant *wpa_s,
1164                                         const struct wpa_ssid *ssid,
1165                                         char *group_obj_path)
1166 {
1167         char group_name[3];
1168
1169         if (!wpa_s->dbus_new_path ||
1170             os_memcmp(ssid->ssid, P2P_WILDCARD_SSID, P2P_WILDCARD_SSID_LEN))
1171                 return -1;
1172
1173         os_memcpy(group_name, ssid->ssid + P2P_WILDCARD_SSID_LEN, 2);
1174         group_name[2] = '\0';
1175
1176         os_snprintf(group_obj_path, WPAS_DBUS_OBJECT_PATH_MAX,
1177                     "%s/" WPAS_DBUS_NEW_P2P_GROUPS_PART "/%s",
1178                     wpa_s->dbus_new_path, group_name);
1179
1180         return 0;
1181 }
1182
1183
1184 struct group_changed_data {
1185         struct wpa_supplicant *wpa_s;
1186         struct p2p_peer_info *info;
1187 };
1188
1189
1190 static int match_group_where_peer_is_client(struct p2p_group *group,
1191                                             void *user_data)
1192 {
1193         struct group_changed_data *data = user_data;
1194         const struct p2p_group_config *cfg;
1195         struct wpa_supplicant *wpa_s_go;
1196
1197         if (!p2p_group_is_client_connected(group, data->info->p2p_device_addr))
1198                 return 1;
1199
1200         cfg = p2p_group_get_config(group);
1201
1202         wpa_s_go = wpas_get_p2p_go_iface(data->wpa_s, cfg->ssid,
1203                                          cfg->ssid_len);
1204         if (wpa_s_go != NULL && wpa_s_go == data->wpa_s) {
1205                 wpas_dbus_signal_peer_groups_changed(
1206                         data->wpa_s->parent, data->info->p2p_device_addr);
1207                 return 0;
1208         }
1209
1210         return 1;
1211 }
1212
1213
1214 static void signal_peer_groups_changed(struct p2p_peer_info *info,
1215                                        void *user_data)
1216 {
1217         struct group_changed_data *data = user_data;
1218         struct wpa_supplicant *wpa_s_go;
1219
1220         wpa_s_go = wpas_get_p2p_client_iface(data->wpa_s,
1221                                              info->p2p_device_addr);
1222         if (wpa_s_go != NULL && wpa_s_go == data->wpa_s) {
1223                 wpas_dbus_signal_peer_groups_changed(data->wpa_s->parent,
1224                                                      info->p2p_device_addr);
1225                 return;
1226         }
1227
1228         data->info = info;
1229         p2p_loop_on_all_groups(data->wpa_s->global->p2p,
1230                                match_group_where_peer_is_client, data);
1231         data->info = NULL;
1232 }
1233
1234
1235 static void peer_groups_changed(struct wpa_supplicant *wpa_s)
1236 {
1237         struct group_changed_data data;
1238
1239         os_memset(&data, 0, sizeof(data));
1240         data.wpa_s = wpa_s;
1241
1242         p2p_loop_on_known_peers(wpa_s->global->p2p,
1243                                 signal_peer_groups_changed, &data);
1244 }
1245
1246
1247 /**
1248  * wpas_dbus_signal_p2p_group_started - Signals P2P group has
1249  * started. Emitted when a group is successfully started
1250  * irrespective of the role (client/GO) of the current device
1251  *
1252  * @wpa_s: %wpa_supplicant network interface data
1253  * @ssid: SSID object
1254  * @client: this device is P2P client
1255  * @network_id: network id of the group started, use instead of ssid->id
1256  *      to account for persistent groups
1257  */
1258 void wpas_dbus_signal_p2p_group_started(struct wpa_supplicant *wpa_s,
1259                                         const struct wpa_ssid *ssid,
1260                                         int client, int network_id)
1261 {
1262         DBusMessage *msg;
1263         DBusMessageIter iter, dict_iter;
1264         struct wpas_dbus_priv *iface;
1265         struct wpa_supplicant *parent;
1266
1267         parent = wpa_s->parent;
1268         if (parent->p2p_mgmt)
1269                 parent = parent->parent;
1270
1271         iface = parent->global->dbus;
1272
1273         /* Do nothing if the control interface is not turned on */
1274         if (iface == NULL || !parent->dbus_new_path || !wpa_s->dbus_new_path)
1275                 return;
1276
1277         if (wpa_s->dbus_groupobj_path == NULL)
1278                 return;
1279
1280         /* New interface has been created for this group */
1281         msg = dbus_message_new_signal(parent->dbus_new_path,
1282                                       WPAS_DBUS_NEW_IFACE_P2PDEVICE,
1283                                       "GroupStarted");
1284         if (msg == NULL)
1285                 return;
1286
1287         dbus_message_iter_init_append(msg, &iter);
1288         /*
1289          * In case the device supports creating a separate interface the
1290          * DBus client will need to know the object path for the interface
1291          * object this group was created on, so include it here.
1292          */
1293         if (!wpa_dbus_dict_open_write(&iter, &dict_iter) ||
1294             !wpa_dbus_dict_append_object_path(&dict_iter,
1295                                               "interface_object",
1296                                               wpa_s->dbus_new_path) ||
1297             !wpa_dbus_dict_append_string(&dict_iter, "role",
1298                                          client ? "client" : "GO") ||
1299             !wpa_dbus_dict_append_object_path(&dict_iter, "group_object",
1300                                               wpa_s->dbus_groupobj_path) ||
1301             !wpa_dbus_dict_close_write(&iter, &dict_iter)) {
1302                 wpa_printf(MSG_ERROR, "dbus: Failed to construct signal");
1303         } else {
1304                 dbus_connection_send(iface->con, msg, NULL);
1305                 if (client)
1306                         peer_groups_changed(wpa_s);
1307         }
1308         dbus_message_unref(msg);
1309 }
1310
1311
1312 /**
1313  * wpas_dbus_signal_p2p_go_neg_resp - Emit GONegotiation Success/Failure signal
1314  * @wpa_s: %wpa_supplicant network interface data
1315  * @res: Result of the GO Neg Request
1316  */
1317 void wpas_dbus_signal_p2p_go_neg_resp(struct wpa_supplicant *wpa_s,
1318                                       struct p2p_go_neg_results *res)
1319 {
1320         DBusMessage *msg;
1321         DBusMessageIter iter, dict_iter;
1322         DBusMessageIter iter_dict_entry, iter_dict_val, iter_dict_array;
1323         struct wpas_dbus_priv *iface;
1324         char peer_obj_path[WPAS_DBUS_OBJECT_PATH_MAX], *path;
1325         dbus_int32_t freqs[P2P_MAX_CHANNELS];
1326         dbus_int32_t *f_array = freqs;
1327
1328
1329         iface = wpa_s->global->dbus;
1330
1331         if (wpa_s->p2p_mgmt)
1332                 wpa_s = wpa_s->parent;
1333
1334         os_memset(freqs, 0, sizeof(freqs));
1335         /* Do nothing if the control interface is not turned on */
1336         if (iface == NULL || !wpa_s->dbus_new_path)
1337                 return;
1338
1339         os_snprintf(peer_obj_path, WPAS_DBUS_OBJECT_PATH_MAX,
1340                     "%s/" WPAS_DBUS_NEW_P2P_PEERS_PART "/" COMPACT_MACSTR,
1341                     wpa_s->dbus_new_path, MAC2STR(res->peer_device_addr));
1342         path = peer_obj_path;
1343
1344         msg = dbus_message_new_signal(wpa_s->dbus_new_path,
1345                                       WPAS_DBUS_NEW_IFACE_P2PDEVICE,
1346                                       res->status ? "GONegotiationFailure" :
1347                                                     "GONegotiationSuccess");
1348         if (msg == NULL)
1349                 return;
1350
1351         dbus_message_iter_init_append(msg, &iter);
1352         if (!wpa_dbus_dict_open_write(&iter, &dict_iter) ||
1353             !wpa_dbus_dict_append_object_path(&dict_iter, "peer_object",
1354                                               path) ||
1355             !wpa_dbus_dict_append_int32(&dict_iter, "status", res->status))
1356                 goto err;
1357
1358         if (!res->status) {
1359                 int i = 0;
1360                 int freq_list_num = 0;
1361
1362                 if ((res->role_go &&
1363                      !wpa_dbus_dict_append_string(&dict_iter, "passphrase",
1364                                                   res->passphrase)) ||
1365                     !wpa_dbus_dict_append_string(&dict_iter, "role_go",
1366                                                  res->role_go ? "GO" :
1367                                                  "client") ||
1368                     !wpa_dbus_dict_append_int32(&dict_iter, "frequency",
1369                                                 res->freq) ||
1370                     !wpa_dbus_dict_append_byte_array(&dict_iter, "ssid",
1371                                                      (const char *) res->ssid,
1372                                                      res->ssid_len) ||
1373                     !wpa_dbus_dict_append_byte_array(&dict_iter,
1374                                                      "peer_device_addr",
1375                                                      (const char *)
1376                                                      res->peer_device_addr,
1377                                                      ETH_ALEN) ||
1378                     !wpa_dbus_dict_append_byte_array(&dict_iter,
1379                                                      "peer_interface_addr",
1380                                                      (const char *)
1381                                                      res->peer_interface_addr,
1382                                                      ETH_ALEN) ||
1383                     !wpa_dbus_dict_append_string(&dict_iter, "wps_method",
1384                                                  p2p_wps_method_text(
1385                                                          res->wps_method)))
1386                         goto err;
1387
1388                 for (i = 0; i < P2P_MAX_CHANNELS; i++) {
1389                         if (res->freq_list[i]) {
1390                                 freqs[i] = res->freq_list[i];
1391                                 freq_list_num++;
1392                         }
1393                 }
1394
1395                 if (!wpa_dbus_dict_begin_array(&dict_iter,
1396                                                "frequency_list",
1397                                                DBUS_TYPE_INT32_AS_STRING,
1398                                                &iter_dict_entry,
1399                                                &iter_dict_val,
1400                                                &iter_dict_array) ||
1401                     !dbus_message_iter_append_fixed_array(&iter_dict_array,
1402                                                           DBUS_TYPE_INT32,
1403                                                           &f_array,
1404                                                           freq_list_num) ||
1405                     !wpa_dbus_dict_end_array(&dict_iter,
1406                                              &iter_dict_entry,
1407                                              &iter_dict_val,
1408                                              &iter_dict_array) ||
1409                     !wpa_dbus_dict_append_int32(&dict_iter, "persistent_group",
1410                                                 res->persistent_group) ||
1411                     !wpa_dbus_dict_append_uint32(&dict_iter,
1412                                                  "peer_config_timeout",
1413                                                  res->peer_config_timeout))
1414                         goto err;
1415         }
1416
1417         if (!wpa_dbus_dict_close_write(&iter, &dict_iter))
1418                 goto err;
1419
1420         dbus_connection_send(iface->con, msg, NULL);
1421 err:
1422         dbus_message_unref(msg);
1423 }
1424
1425
1426 /**
1427  * wpas_dbus_signal_p2p_invitation_result - Emit InvitationResult signal
1428  * @wpa_s: %wpa_supplicant network interface data
1429  * @status: Status of invitation process
1430  * @bssid: Basic Service Set Identifier
1431  */
1432 void wpas_dbus_signal_p2p_invitation_result(struct wpa_supplicant *wpa_s,
1433                                             int status, const u8 *bssid)
1434 {
1435         DBusMessage *msg;
1436         DBusMessageIter iter, dict_iter;
1437         struct wpas_dbus_priv *iface;
1438
1439         wpa_printf(MSG_DEBUG, "%s", __func__);
1440
1441         iface = wpa_s->global->dbus;
1442         /* Do nothing if the control interface is not turned on */
1443         if (iface == NULL)
1444                 return;
1445
1446         if (wpa_s->p2p_mgmt)
1447                 wpa_s = wpa_s->parent;
1448         if (!wpa_s->dbus_new_path)
1449                 return;
1450
1451         msg = dbus_message_new_signal(wpa_s->dbus_new_path,
1452                                       WPAS_DBUS_NEW_IFACE_P2PDEVICE,
1453                                       "InvitationResult");
1454
1455         if (msg == NULL)
1456                 return;
1457
1458         dbus_message_iter_init_append(msg, &iter);
1459         if (!wpa_dbus_dict_open_write(&iter, &dict_iter) ||
1460             !wpa_dbus_dict_append_int32(&dict_iter, "status", status) ||
1461             (bssid &&
1462              !wpa_dbus_dict_append_byte_array(&dict_iter, "BSSID",
1463                                               (const char *) bssid,
1464                                               ETH_ALEN)) ||
1465             !wpa_dbus_dict_close_write(&iter, &dict_iter))
1466                 wpa_printf(MSG_ERROR, "dbus: Failed to construct signal");
1467         else
1468                 dbus_connection_send(iface->con, msg, NULL);
1469         dbus_message_unref(msg);
1470 }
1471
1472
1473 /**
1474  *
1475  * Method to emit a signal for a peer joining the group.
1476  * The signal will carry path to the group member object
1477  * constructed using p2p i/f addr used for connecting.
1478  *
1479  * @wpa_s: %wpa_supplicant network interface data
1480  * @peer_addr: P2P Device Address of the peer joining the group
1481  */
1482 void wpas_dbus_signal_p2p_peer_joined(struct wpa_supplicant *wpa_s,
1483                                       const u8 *peer_addr)
1484 {
1485         struct wpas_dbus_priv *iface;
1486         DBusMessage *msg;
1487         DBusMessageIter iter;
1488         char peer_obj_path[WPAS_DBUS_OBJECT_PATH_MAX], *path;
1489         struct wpa_supplicant *parent;
1490
1491         iface = wpa_s->global->dbus;
1492
1493         /* Do nothing if the control interface is not turned on */
1494         if (iface == NULL)
1495                 return;
1496
1497         if (!wpa_s->dbus_groupobj_path)
1498                 return;
1499
1500         parent = wpa_s->parent;
1501         if (parent->p2p_mgmt)
1502                 parent = parent->parent;
1503         if (!parent->dbus_new_path)
1504                 return;
1505
1506         os_snprintf(peer_obj_path, WPAS_DBUS_OBJECT_PATH_MAX,
1507                         "%s/" WPAS_DBUS_NEW_P2P_PEERS_PART "/"
1508                         COMPACT_MACSTR,
1509                         parent->dbus_new_path, MAC2STR(peer_addr));
1510
1511         msg = dbus_message_new_signal(wpa_s->dbus_groupobj_path,
1512                                       WPAS_DBUS_NEW_IFACE_P2P_GROUP,
1513                                       "PeerJoined");
1514         if (msg == NULL)
1515                 return;
1516
1517         dbus_message_iter_init_append(msg, &iter);
1518         path = peer_obj_path;
1519         if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_OBJECT_PATH,
1520                                             &path)) {
1521                 wpa_printf(MSG_ERROR, "dbus: Failed to construct signal");
1522         } else {
1523                 dbus_connection_send(iface->con, msg, NULL);
1524                 wpas_dbus_signal_peer_groups_changed(parent, peer_addr);
1525         }
1526         dbus_message_unref(msg);
1527 }
1528
1529
1530 /**
1531  *
1532  * Method to emit a signal for a peer disconnecting the group.
1533  * The signal will carry path to the group member object
1534  * constructed using the P2P Device Address of the peer.
1535  *
1536  * @wpa_s: %wpa_supplicant network interface data
1537  * @peer_addr: P2P Device Address of the peer joining the group
1538  */
1539 void wpas_dbus_signal_p2p_peer_disconnected(struct wpa_supplicant *wpa_s,
1540                                             const u8 *peer_addr)
1541 {
1542         struct wpas_dbus_priv *iface;
1543         DBusMessage *msg;
1544         DBusMessageIter iter;
1545         char peer_obj_path[WPAS_DBUS_OBJECT_PATH_MAX], *path;
1546         struct wpa_supplicant *parent;
1547
1548         iface = wpa_s->global->dbus;
1549
1550         /* Do nothing if the control interface is not turned on */
1551         if (iface == NULL)
1552                 return;
1553
1554         if (!wpa_s->dbus_groupobj_path)
1555                 return;
1556
1557         parent = wpa_s->parent;
1558         if (parent->p2p_mgmt)
1559                 parent = parent->parent;
1560         if (!parent->dbus_new_path)
1561                 return;
1562
1563         os_snprintf(peer_obj_path, WPAS_DBUS_OBJECT_PATH_MAX,
1564                         "%s/" WPAS_DBUS_NEW_P2P_PEERS_PART "/"
1565                         COMPACT_MACSTR,
1566                         parent->dbus_new_path, MAC2STR(peer_addr));
1567
1568         msg = dbus_message_new_signal(wpa_s->dbus_groupobj_path,
1569                                       WPAS_DBUS_NEW_IFACE_P2P_GROUP,
1570                                       "PeerDisconnected");
1571         if (msg == NULL)
1572                 return;
1573
1574         dbus_message_iter_init_append(msg, &iter);
1575         path = peer_obj_path;
1576         if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_OBJECT_PATH,
1577                                             &path)) {
1578                 wpa_printf(MSG_ERROR,
1579                            "dbus: Failed to construct PeerDisconnected signal");
1580         } else {
1581                 dbus_connection_send(iface->con, msg, NULL);
1582                 wpas_dbus_signal_peer_groups_changed(parent, peer_addr);
1583         }
1584         dbus_message_unref(msg);
1585 }
1586
1587
1588 /**
1589  *
1590  * Method to emit a signal for a service discovery request.
1591  * The signal will carry station address, frequency, dialog token,
1592  * update indicator and it tlvs
1593  *
1594  * @wpa_s: %wpa_supplicant network interface data
1595  * @sa: station addr (p2p i/f) of the peer
1596  * @dialog_token: service discovery request dialog token
1597  * @update_indic: service discovery request update indicator
1598  * @tlvs: service discovery request genrated byte array of tlvs
1599  * @tlvs_len: service discovery request tlvs length
1600  */
1601 void wpas_dbus_signal_p2p_sd_request(struct wpa_supplicant *wpa_s,
1602                                      int freq, const u8 *sa, u8 dialog_token,
1603                                      u16 update_indic, const u8 *tlvs,
1604                                      size_t tlvs_len)
1605 {
1606         DBusMessage *msg;
1607         DBusMessageIter iter, dict_iter;
1608         struct wpas_dbus_priv *iface;
1609         char peer_obj_path[WPAS_DBUS_OBJECT_PATH_MAX], *path;
1610
1611         iface = wpa_s->global->dbus;
1612
1613         /* Do nothing if the control interface is not turned on */
1614         if (iface == NULL)
1615                 return;
1616
1617         if (wpa_s->p2p_mgmt)
1618                 wpa_s = wpa_s->parent;
1619         if (!wpa_s->dbus_new_path)
1620                 return;
1621
1622         /* Check if this is a known peer */
1623         if (!p2p_peer_known(wpa_s->global->p2p, sa))
1624                 return;
1625
1626         msg = dbus_message_new_signal(wpa_s->dbus_new_path,
1627                                       WPAS_DBUS_NEW_IFACE_P2PDEVICE,
1628                                       "ServiceDiscoveryRequest");
1629         if (msg == NULL)
1630                 return;
1631
1632         os_snprintf(peer_obj_path, WPAS_DBUS_OBJECT_PATH_MAX,
1633                     "%s/" WPAS_DBUS_NEW_P2P_PEERS_PART "/"
1634                     COMPACT_MACSTR, wpa_s->dbus_new_path, MAC2STR(sa));
1635
1636         path = peer_obj_path;
1637
1638         dbus_message_iter_init_append(msg, &iter);
1639         if (!wpa_dbus_dict_open_write(&iter, &dict_iter) ||
1640             !wpa_dbus_dict_append_object_path(&dict_iter, "peer_object",
1641                                               path) ||
1642             !wpa_dbus_dict_append_int32(&dict_iter, "frequency", freq) ||
1643             !wpa_dbus_dict_append_int32(&dict_iter, "dialog_token",
1644                                         dialog_token) ||
1645             !wpa_dbus_dict_append_uint16(&dict_iter, "update_indicator",
1646                                          update_indic) ||
1647             !wpa_dbus_dict_append_byte_array(&dict_iter, "tlvs",
1648                                              (const char *) tlvs,
1649                                              tlvs_len) ||
1650             !wpa_dbus_dict_close_write(&iter, &dict_iter))
1651                 wpa_printf(MSG_ERROR, "dbus: Failed to construct signal");
1652         else
1653                 dbus_connection_send(iface->con, msg, NULL);
1654         dbus_message_unref(msg);
1655 }
1656
1657
1658 /**
1659  *
1660  * Method to emit a signal for a service discovery response.
1661  * The signal will carry station address, update indicator and it
1662  * tlvs
1663  *
1664  * @wpa_s: %wpa_supplicant network interface data
1665  * @sa: station addr (p2p i/f) of the peer
1666  * @update_indic: service discovery request update indicator
1667  * @tlvs: service discovery request genrated byte array of tlvs
1668  * @tlvs_len: service discovery request tlvs length
1669  */
1670 void wpas_dbus_signal_p2p_sd_response(struct wpa_supplicant *wpa_s,
1671                                       const u8 *sa, u16 update_indic,
1672                                       const u8 *tlvs, size_t tlvs_len)
1673 {
1674         DBusMessage *msg;
1675         DBusMessageIter iter, dict_iter;
1676         struct wpas_dbus_priv *iface;
1677         char peer_obj_path[WPAS_DBUS_OBJECT_PATH_MAX], *path;
1678
1679         iface = wpa_s->global->dbus;
1680
1681         /* Do nothing if the control interface is not turned on */
1682         if (iface == NULL)
1683                 return;
1684
1685         if (wpa_s->p2p_mgmt)
1686                 wpa_s = wpa_s->parent;
1687         if (!wpa_s->dbus_new_path)
1688                 return;
1689
1690         /* Check if this is a known peer */
1691         if (!p2p_peer_known(wpa_s->global->p2p, sa))
1692                 return;
1693
1694         msg = dbus_message_new_signal(wpa_s->dbus_new_path,
1695                                       WPAS_DBUS_NEW_IFACE_P2PDEVICE,
1696                                       "ServiceDiscoveryResponse");
1697         if (msg == NULL)
1698                 return;
1699
1700         os_snprintf(peer_obj_path, WPAS_DBUS_OBJECT_PATH_MAX,
1701                     "%s/" WPAS_DBUS_NEW_P2P_PEERS_PART "/"
1702                     COMPACT_MACSTR, wpa_s->dbus_new_path, MAC2STR(sa));
1703
1704         path = peer_obj_path;
1705
1706         dbus_message_iter_init_append(msg, &iter);
1707         if (!wpa_dbus_dict_open_write(&iter, &dict_iter) ||
1708             !wpa_dbus_dict_append_object_path(&dict_iter, "peer_object",
1709                                               path) ||
1710             !wpa_dbus_dict_append_uint16(&dict_iter, "update_indicator",
1711                                          update_indic) ||
1712             !wpa_dbus_dict_append_byte_array(&dict_iter, "tlvs",
1713                                              (const char *) tlvs,
1714                                              tlvs_len) ||
1715             !wpa_dbus_dict_close_write(&iter, &dict_iter))
1716                 wpa_printf(MSG_ERROR, "dbus: Failed to construct signal");
1717         else
1718                 dbus_connection_send(iface->con, msg, NULL);
1719         dbus_message_unref(msg);
1720 }
1721
1722
1723 /**
1724  * wpas_dbus_signal_persistent_group - Send a persistent group related
1725  *      event signal
1726  * @wpa_s: %wpa_supplicant network interface data
1727  * @id: new persistent group id
1728  * @sig_name: signal name - PersistentGroupAdded, PersistentGroupRemoved
1729  * @properties: determines if add second argument with object properties
1730  *
1731  * Notify listeners about an event related to persistent groups.
1732  */
1733 static void wpas_dbus_signal_persistent_group(struct wpa_supplicant *wpa_s,
1734                                               int id, const char *sig_name,
1735                                               int properties)
1736 {
1737         struct wpas_dbus_priv *iface;
1738         DBusMessage *msg;
1739         DBusMessageIter iter;
1740         char pgrp_obj_path[WPAS_DBUS_OBJECT_PATH_MAX], *path;
1741
1742         iface = wpa_s->global->dbus;
1743
1744         /* Do nothing if the control interface is not turned on */
1745         if (iface == NULL)
1746                 return;
1747
1748         if (wpa_s->p2p_mgmt)
1749                 wpa_s = wpa_s->parent;
1750         if (!wpa_s->dbus_new_path)
1751                 return;
1752
1753         os_snprintf(pgrp_obj_path, WPAS_DBUS_OBJECT_PATH_MAX,
1754                     "%s/" WPAS_DBUS_NEW_PERSISTENT_GROUPS_PART "/%u",
1755                     wpa_s->dbus_new_path, id);
1756
1757         msg = dbus_message_new_signal(wpa_s->dbus_new_path,
1758                                       WPAS_DBUS_NEW_IFACE_P2PDEVICE,
1759                                       sig_name);
1760         if (msg == NULL)
1761                 return;
1762
1763         dbus_message_iter_init_append(msg, &iter);
1764         path = pgrp_obj_path;
1765         if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_OBJECT_PATH,
1766                                             &path) ||
1767             (properties &&
1768              !wpa_dbus_get_object_properties(
1769                      iface, pgrp_obj_path,
1770                      WPAS_DBUS_NEW_IFACE_PERSISTENT_GROUP, &iter)))
1771                 wpa_printf(MSG_ERROR, "dbus: Failed to construct signal");
1772         else
1773                 dbus_connection_send(iface->con, msg, NULL);
1774
1775         dbus_message_unref(msg);
1776 }
1777
1778
1779 /**
1780  * wpas_dbus_signal_persistent_group_added - Send a persistent_group
1781  *      added signal
1782  * @wpa_s: %wpa_supplicant network interface data
1783  * @id: new persistent group id
1784  *
1785  * Notify listeners about addition of a new persistent group.
1786  */
1787 static void wpas_dbus_signal_persistent_group_added(
1788         struct wpa_supplicant *wpa_s, int id)
1789 {
1790         wpas_dbus_signal_persistent_group(wpa_s, id, "PersistentGroupAdded",
1791                                           TRUE);
1792 }
1793
1794
1795 /**
1796  * wpas_dbus_signal_persistent_group_removed - Send a persistent_group
1797  *      removed signal
1798  * @wpa_s: %wpa_supplicant network interface data
1799  * @id: persistent group id
1800  *
1801  * Notify listeners about removal of a persistent group.
1802  */
1803 static void wpas_dbus_signal_persistent_group_removed(
1804         struct wpa_supplicant *wpa_s, int id)
1805 {
1806         wpas_dbus_signal_persistent_group(wpa_s, id, "PersistentGroupRemoved",
1807                                           FALSE);
1808 }
1809
1810
1811 /**
1812  * wpas_dbus_signal_p2p_wps_failed - Signals WpsFailed event
1813  * @wpa_s: %wpa_supplicant network interface data
1814  * @fail: WPS failure information
1815  *
1816  * Sends Event dbus signal with name "fail" and dictionary containing
1817  * "msg" field with fail message number (int32) as arguments
1818  */
1819 void wpas_dbus_signal_p2p_wps_failed(struct wpa_supplicant *wpa_s,
1820                                      struct wps_event_fail *fail)
1821 {
1822
1823         DBusMessage *msg;
1824         DBusMessageIter iter, dict_iter;
1825         struct wpas_dbus_priv *iface;
1826         char *key = "fail";
1827
1828         iface = wpa_s->global->dbus;
1829
1830         /* Do nothing if the control interface is not turned on */
1831         if (iface == NULL)
1832                 return;
1833
1834         if (wpa_s->p2p_mgmt)
1835                 wpa_s = wpa_s->parent;
1836
1837         if (!wpa_s->dbus_new_path)
1838                 return;
1839         msg = dbus_message_new_signal(wpa_s->dbus_new_path,
1840                                       WPAS_DBUS_NEW_IFACE_P2PDEVICE,
1841                                       "WpsFailed");
1842         if (msg == NULL)
1843                 return;
1844
1845         dbus_message_iter_init_append(msg, &iter);
1846
1847         if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &key) ||
1848             !wpa_dbus_dict_open_write(&iter, &dict_iter) ||
1849             !wpa_dbus_dict_append_int32(&dict_iter, "msg", fail->msg) ||
1850             !wpa_dbus_dict_append_int16(&dict_iter, "config_error",
1851                                         fail->config_error) ||
1852             !wpa_dbus_dict_close_write(&iter, &dict_iter))
1853                 wpa_printf(MSG_ERROR, "dbus: Failed to construct signal");
1854         else
1855                 dbus_connection_send(iface->con, msg, NULL);
1856
1857         dbus_message_unref(msg);
1858 }
1859
1860 #endif /* CONFIG_P2P */
1861
1862
1863 /**
1864  * wpas_dbus_signal_prop_changed - Signals change of property
1865  * @wpa_s: %wpa_supplicant network interface data
1866  * @property: indicates which property has changed
1867  *
1868  * Sends PropertyChanged signals with path, interface and arguments
1869  * depending on which property has changed.
1870  */
1871 void wpas_dbus_signal_prop_changed(struct wpa_supplicant *wpa_s,
1872                                    enum wpas_dbus_prop property)
1873 {
1874         char *prop;
1875         dbus_bool_t flush;
1876
1877         if (wpa_s->dbus_new_path == NULL)
1878                 return; /* Skip signal since D-Bus setup is not yet ready */
1879
1880         flush = FALSE;
1881         switch (property) {
1882         case WPAS_DBUS_PROP_AP_SCAN:
1883                 prop = "ApScan";
1884                 break;
1885         case WPAS_DBUS_PROP_SCANNING:
1886                 prop = "Scanning";
1887                 break;
1888         case WPAS_DBUS_PROP_STATE:
1889                 prop = "State";
1890                 break;
1891         case WPAS_DBUS_PROP_CURRENT_BSS:
1892                 prop = "CurrentBSS";
1893                 break;
1894         case WPAS_DBUS_PROP_CURRENT_NETWORK:
1895                 prop = "CurrentNetwork";
1896                 break;
1897         case WPAS_DBUS_PROP_BSSS:
1898                 prop = "BSSs";
1899                 break;
1900         case WPAS_DBUS_PROP_CURRENT_AUTH_MODE:
1901                 prop = "CurrentAuthMode";
1902                 break;
1903         case WPAS_DBUS_PROP_DISCONNECT_REASON:
1904                 prop = "DisconnectReason";
1905                 flush = TRUE;
1906                 break;
1907         default:
1908                 wpa_printf(MSG_ERROR, "dbus: %s: Unknown Property value %d",
1909                            __func__, property);
1910                 return;
1911         }
1912
1913         wpa_dbus_mark_property_changed(wpa_s->global->dbus,
1914                                        wpa_s->dbus_new_path,
1915                                        WPAS_DBUS_NEW_IFACE_INTERFACE, prop);
1916         if (flush) {
1917                 wpa_dbus_flush_object_changed_properties(
1918                         wpa_s->global->dbus->con, wpa_s->dbus_new_path);
1919         }
1920 }
1921
1922
1923 /**
1924  * wpas_dbus_bss_signal_prop_changed - Signals change of BSS property
1925  * @wpa_s: %wpa_supplicant network interface data
1926  * @property: indicates which property has changed
1927  * @id: unique BSS identifier
1928  *
1929  * Sends PropertyChanged signals with path, interface, and arguments depending
1930  * on which property has changed.
1931  */
1932 void wpas_dbus_bss_signal_prop_changed(struct wpa_supplicant *wpa_s,
1933                                        enum wpas_dbus_bss_prop property,
1934                                        unsigned int id)
1935 {
1936         char path[WPAS_DBUS_OBJECT_PATH_MAX];
1937         char *prop;
1938
1939         if (!wpa_s->dbus_new_path)
1940                 return;
1941
1942         switch (property) {
1943         case WPAS_DBUS_BSS_PROP_SIGNAL:
1944                 prop = "Signal";
1945                 break;
1946         case WPAS_DBUS_BSS_PROP_FREQ:
1947                 prop = "Frequency";
1948                 break;
1949         case WPAS_DBUS_BSS_PROP_MODE:
1950                 prop = "Mode";
1951                 break;
1952         case WPAS_DBUS_BSS_PROP_PRIVACY:
1953                 prop = "Privacy";
1954                 break;
1955         case WPAS_DBUS_BSS_PROP_RATES:
1956                 prop = "Rates";
1957                 break;
1958         case WPAS_DBUS_BSS_PROP_WPA:
1959                 prop = "WPA";
1960                 break;
1961         case WPAS_DBUS_BSS_PROP_RSN:
1962                 prop = "RSN";
1963                 break;
1964         case WPAS_DBUS_BSS_PROP_WPS:
1965                 prop = "WPS";
1966                 break;
1967         case WPAS_DBUS_BSS_PROP_IES:
1968                 prop = "IEs";
1969                 break;
1970         case WPAS_DBUS_BSS_PROP_AGE:
1971                 prop = "Age";
1972                 break;
1973         default:
1974                 wpa_printf(MSG_ERROR, "dbus: %s: Unknown Property value %d",
1975                            __func__, property);
1976                 return;
1977         }
1978
1979         os_snprintf(path, WPAS_DBUS_OBJECT_PATH_MAX,
1980                     "%s/" WPAS_DBUS_NEW_BSSIDS_PART "/%u",
1981                     wpa_s->dbus_new_path, id);
1982
1983         wpa_dbus_mark_property_changed(wpa_s->global->dbus, path,
1984                                        WPAS_DBUS_NEW_IFACE_BSS, prop);
1985 }
1986
1987
1988 /**
1989  * wpas_dbus_signal_debug_level_changed - Signals change of debug param
1990  * @global: wpa_global structure
1991  *
1992  * Sends PropertyChanged signals informing that debug level has changed.
1993  */
1994 void wpas_dbus_signal_debug_level_changed(struct wpa_global *global)
1995 {
1996         wpa_dbus_mark_property_changed(global->dbus, WPAS_DBUS_NEW_PATH,
1997                                        WPAS_DBUS_NEW_INTERFACE,
1998                                        "DebugLevel");
1999 }
2000
2001
2002 /**
2003  * wpas_dbus_signal_debug_timestamp_changed - Signals change of debug param
2004  * @global: wpa_global structure
2005  *
2006  * Sends PropertyChanged signals informing that debug timestamp has changed.
2007  */
2008 void wpas_dbus_signal_debug_timestamp_changed(struct wpa_global *global)
2009 {
2010         wpa_dbus_mark_property_changed(global->dbus, WPAS_DBUS_NEW_PATH,
2011                                        WPAS_DBUS_NEW_INTERFACE,
2012                                        "DebugTimestamp");
2013 }
2014
2015
2016 /**
2017  * wpas_dbus_signal_debug_show_keys_changed - Signals change of debug param
2018  * @global: wpa_global structure
2019  *
2020  * Sends PropertyChanged signals informing that debug show_keys has changed.
2021  */
2022 void wpas_dbus_signal_debug_show_keys_changed(struct wpa_global *global)
2023 {
2024         wpa_dbus_mark_property_changed(global->dbus, WPAS_DBUS_NEW_PATH,
2025                                        WPAS_DBUS_NEW_INTERFACE,
2026                                        "DebugShowKeys");
2027 }
2028
2029
2030 static void wpas_dbus_register(struct wpa_dbus_object_desc *obj_desc,
2031                                void *priv,
2032                                WPADBusArgumentFreeFunction priv_free,
2033                                const struct wpa_dbus_method_desc *methods,
2034                                const struct wpa_dbus_property_desc *properties,
2035                                const struct wpa_dbus_signal_desc *signals)
2036 {
2037         int n;
2038
2039         obj_desc->user_data = priv;
2040         obj_desc->user_data_free_func = priv_free;
2041         obj_desc->methods = methods;
2042         obj_desc->properties = properties;
2043         obj_desc->signals = signals;
2044
2045         for (n = 0; properties && properties->dbus_property; properties++)
2046                 n++;
2047
2048         obj_desc->prop_changed_flags = os_zalloc(n);
2049         if (!obj_desc->prop_changed_flags)
2050                 wpa_printf(MSG_DEBUG, "dbus: %s: can't register handlers",
2051                            __func__);
2052 }
2053
2054
2055 static const struct wpa_dbus_method_desc wpas_dbus_global_methods[] = {
2056         { "CreateInterface", WPAS_DBUS_NEW_INTERFACE,
2057           (WPADBusMethodHandler) wpas_dbus_handler_create_interface,
2058           {
2059                   { "args", "a{sv}", ARG_IN },
2060                   { "path", "o", ARG_OUT },
2061                   END_ARGS
2062           }
2063         },
2064         { "RemoveInterface", WPAS_DBUS_NEW_INTERFACE,
2065           (WPADBusMethodHandler) wpas_dbus_handler_remove_interface,
2066           {
2067                   { "path", "o", ARG_IN },
2068                   END_ARGS
2069           }
2070         },
2071         { "GetInterface", WPAS_DBUS_NEW_INTERFACE,
2072           (WPADBusMethodHandler) wpas_dbus_handler_get_interface,
2073           {
2074                   { "ifname", "s", ARG_IN },
2075                   { "path", "o", ARG_OUT },
2076                   END_ARGS
2077           }
2078         },
2079         { NULL, NULL, NULL, { END_ARGS } }
2080 };
2081
2082 static const struct wpa_dbus_property_desc wpas_dbus_global_properties[] = {
2083         { "DebugLevel", WPAS_DBUS_NEW_INTERFACE, "s",
2084           wpas_dbus_getter_debug_level,
2085           wpas_dbus_setter_debug_level
2086         },
2087         { "DebugTimestamp", WPAS_DBUS_NEW_INTERFACE, "b",
2088           wpas_dbus_getter_debug_timestamp,
2089           wpas_dbus_setter_debug_timestamp
2090         },
2091         { "DebugShowKeys", WPAS_DBUS_NEW_INTERFACE, "b",
2092           wpas_dbus_getter_debug_show_keys,
2093           wpas_dbus_setter_debug_show_keys
2094         },
2095         { "Interfaces", WPAS_DBUS_NEW_INTERFACE, "ao",
2096           wpas_dbus_getter_interfaces,
2097           NULL
2098         },
2099         { "EapMethods", WPAS_DBUS_NEW_INTERFACE, "as",
2100           wpas_dbus_getter_eap_methods,
2101           NULL
2102         },
2103         { "Capabilities", WPAS_DBUS_NEW_INTERFACE, "as",
2104           wpas_dbus_getter_global_capabilities,
2105           NULL
2106         },
2107 #ifdef CONFIG_WIFI_DISPLAY
2108         { "WFDIEs", WPAS_DBUS_NEW_INTERFACE, "ay",
2109           wpas_dbus_getter_global_wfd_ies,
2110           wpas_dbus_setter_global_wfd_ies
2111         },
2112 #endif /* CONFIG_WIFI_DISPLAY */
2113         { NULL, NULL, NULL, NULL, NULL }
2114 };
2115
2116 static const struct wpa_dbus_signal_desc wpas_dbus_global_signals[] = {
2117         { "InterfaceAdded", WPAS_DBUS_NEW_INTERFACE,
2118           {
2119                   { "path", "o", ARG_OUT },
2120                   { "properties", "a{sv}", ARG_OUT },
2121                   END_ARGS
2122           }
2123         },
2124         { "InterfaceRemoved", WPAS_DBUS_NEW_INTERFACE,
2125           {
2126                   { "path", "o", ARG_OUT },
2127                   END_ARGS
2128           }
2129         },
2130         /* Deprecated: use org.freedesktop.DBus.Properties.PropertiesChanged */
2131         { "PropertiesChanged", WPAS_DBUS_NEW_INTERFACE,
2132           {
2133                   { "properties", "a{sv}", ARG_OUT },
2134                   END_ARGS
2135           }
2136         },
2137         { NULL, NULL, { END_ARGS } }
2138 };
2139
2140
2141 /**
2142  * wpas_dbus_ctrl_iface_init - Initialize dbus control interface
2143  * @global: Pointer to global data from wpa_supplicant_init()
2144  * Returns: 0 on success or -1 on failure
2145  *
2146  * Initialize the dbus control interface for wpa_supplicantand and start
2147  * receiving commands from external programs over the bus.
2148  */
2149 int wpas_dbus_ctrl_iface_init(struct wpas_dbus_priv *priv)
2150 {
2151         struct wpa_dbus_object_desc *obj_desc;
2152         int ret;
2153
2154         obj_desc = os_zalloc(sizeof(struct wpa_dbus_object_desc));
2155         if (!obj_desc) {
2156                 wpa_printf(MSG_ERROR,
2157                            "Not enough memory to create object description");
2158                 return -1;
2159         }
2160
2161         wpas_dbus_register(obj_desc, priv->global, NULL,
2162                            wpas_dbus_global_methods,
2163                            wpas_dbus_global_properties,
2164                            wpas_dbus_global_signals);
2165
2166         wpa_printf(MSG_DEBUG, "dbus: Register D-Bus object '%s'",
2167                    WPAS_DBUS_NEW_PATH);
2168         ret = wpa_dbus_ctrl_iface_init(priv, WPAS_DBUS_NEW_PATH,
2169                                        WPAS_DBUS_NEW_SERVICE,
2170                                        obj_desc);
2171         if (ret < 0)
2172                 free_dbus_object_desc(obj_desc);
2173         else
2174                 priv->dbus_new_initialized = 1;
2175
2176         return ret;
2177 }
2178
2179
2180 /**
2181  * wpas_dbus_ctrl_iface_deinit - Deinitialize dbus ctrl interface for
2182  * wpa_supplicant
2183  * @iface: Pointer to dbus private data from wpas_dbus_init()
2184  *
2185  * Deinitialize the dbus control interface that was initialized with
2186  * wpas_dbus_ctrl_iface_init().
2187  */
2188 void wpas_dbus_ctrl_iface_deinit(struct wpas_dbus_priv *iface)
2189 {
2190         if (!iface->dbus_new_initialized)
2191                 return;
2192         wpa_printf(MSG_DEBUG, "dbus: Unregister D-Bus object '%s'",
2193                    WPAS_DBUS_NEW_PATH);
2194         dbus_connection_unregister_object_path(iface->con,
2195                                                WPAS_DBUS_NEW_PATH);
2196 }
2197
2198
2199 static void wpa_dbus_free(void *ptr)
2200 {
2201         os_free(ptr);
2202 }
2203
2204
2205 static const struct wpa_dbus_property_desc wpas_dbus_network_properties[] = {
2206         { "Properties", WPAS_DBUS_NEW_IFACE_NETWORK, "a{sv}",
2207           wpas_dbus_getter_network_properties,
2208           wpas_dbus_setter_network_properties
2209         },
2210         { "Enabled", WPAS_DBUS_NEW_IFACE_NETWORK, "b",
2211           wpas_dbus_getter_enabled,
2212           wpas_dbus_setter_enabled
2213         },
2214         { NULL, NULL, NULL, NULL, NULL }
2215 };
2216
2217
2218 static const struct wpa_dbus_signal_desc wpas_dbus_network_signals[] = {
2219         /* Deprecated: use org.freedesktop.DBus.Properties.PropertiesChanged */
2220         { "PropertiesChanged", WPAS_DBUS_NEW_IFACE_NETWORK,
2221           {
2222                   { "properties", "a{sv}", ARG_OUT },
2223                   END_ARGS
2224           }
2225         },
2226         { NULL, NULL, { END_ARGS } }
2227 };
2228
2229
2230 /**
2231  * wpas_dbus_register_network - Register a configured network with dbus
2232  * @wpa_s: wpa_supplicant interface structure
2233  * @ssid: network configuration data
2234  * Returns: 0 on success, -1 on failure
2235  *
2236  * Registers network representing object with dbus
2237  */
2238 int wpas_dbus_register_network(struct wpa_supplicant *wpa_s,
2239                                struct wpa_ssid *ssid)
2240 {
2241         struct wpas_dbus_priv *ctrl_iface;
2242         struct wpa_dbus_object_desc *obj_desc;
2243         struct network_handler_args *arg;
2244         char net_obj_path[WPAS_DBUS_OBJECT_PATH_MAX];
2245
2246 #ifdef CONFIG_P2P
2247         /*
2248          * If it is a persistent group register it as such.
2249          * This is to handle cases where an interface is being initialized
2250          * with a list of networks read from config.
2251          */
2252         if (network_is_persistent_group(ssid))
2253                 return wpas_dbus_register_persistent_group(wpa_s, ssid);
2254 #endif /* CONFIG_P2P */
2255
2256         /* Do nothing if the control interface is not turned on */
2257         if (wpa_s == NULL || wpa_s->global == NULL || !wpa_s->dbus_new_path)
2258                 return 0;
2259         ctrl_iface = wpa_s->global->dbus;
2260         if (ctrl_iface == NULL)
2261                 return 0;
2262
2263         os_snprintf(net_obj_path, WPAS_DBUS_OBJECT_PATH_MAX,
2264                     "%s/" WPAS_DBUS_NEW_NETWORKS_PART "/%u",
2265                     wpa_s->dbus_new_path, ssid->id);
2266
2267         wpa_printf(MSG_DEBUG, "dbus: Register network object '%s'",
2268                    net_obj_path);
2269         obj_desc = os_zalloc(sizeof(struct wpa_dbus_object_desc));
2270         if (!obj_desc) {
2271                 wpa_printf(MSG_ERROR,
2272                            "Not enough memory to create object description");
2273                 goto err;
2274         }
2275
2276         /* allocate memory for handlers arguments */
2277         arg = os_zalloc(sizeof(struct network_handler_args));
2278         if (!arg) {
2279                 wpa_printf(MSG_ERROR,
2280                            "Not enough memory to create arguments for method");
2281                 goto err;
2282         }
2283
2284         arg->wpa_s = wpa_s;
2285         arg->ssid = ssid;
2286
2287         wpas_dbus_register(obj_desc, arg, wpa_dbus_free, NULL,
2288                            wpas_dbus_network_properties,
2289                            wpas_dbus_network_signals);
2290
2291         if (wpa_dbus_register_object_per_iface(ctrl_iface, net_obj_path,
2292                                                wpa_s->ifname, obj_desc))
2293                 goto err;
2294
2295         wpas_dbus_signal_network_added(wpa_s, ssid->id);
2296
2297         return 0;
2298
2299 err:
2300         free_dbus_object_desc(obj_desc);
2301         return -1;
2302 }
2303
2304
2305 /**
2306  * wpas_dbus_unregister_network - Unregister a configured network from dbus
2307  * @wpa_s: wpa_supplicant interface structure
2308  * @nid: network id
2309  * Returns: 0 on success, -1 on failure
2310  *
2311  * Unregisters network representing object from dbus
2312  */
2313 int wpas_dbus_unregister_network(struct wpa_supplicant *wpa_s, int nid)
2314 {
2315         struct wpas_dbus_priv *ctrl_iface;
2316         char net_obj_path[WPAS_DBUS_OBJECT_PATH_MAX];
2317         int ret;
2318 #ifdef CONFIG_P2P
2319         struct wpa_ssid *ssid;
2320
2321         ssid = wpa_config_get_network(wpa_s->conf, nid);
2322
2323         /* If it is a persistent group unregister it as such */
2324         if (ssid && network_is_persistent_group(ssid))
2325                 return wpas_dbus_unregister_persistent_group(wpa_s, nid);
2326 #endif /* CONFIG_P2P */
2327
2328         /* Do nothing if the control interface is not turned on */
2329         if (wpa_s->global == NULL || wpa_s->dbus_new_path == NULL)
2330                 return 0;
2331         ctrl_iface = wpa_s->global->dbus;
2332         if (ctrl_iface == NULL)
2333                 return 0;
2334
2335         os_snprintf(net_obj_path, WPAS_DBUS_OBJECT_PATH_MAX,
2336                     "%s/" WPAS_DBUS_NEW_NETWORKS_PART "/%u",
2337                     wpa_s->dbus_new_path, nid);
2338
2339         wpa_printf(MSG_DEBUG, "dbus: Unregister network object '%s'",
2340                    net_obj_path);
2341         ret = wpa_dbus_unregister_object_per_iface(ctrl_iface, net_obj_path);
2342
2343         if (!ret)
2344                 wpas_dbus_signal_network_removed(wpa_s, nid);
2345
2346         return ret;
2347 }
2348
2349
2350 static const struct wpa_dbus_property_desc wpas_dbus_bss_properties[] = {
2351         { "SSID", WPAS_DBUS_NEW_IFACE_BSS, "ay",
2352           wpas_dbus_getter_bss_ssid,
2353           NULL
2354         },
2355         { "BSSID", WPAS_DBUS_NEW_IFACE_BSS, "ay",
2356           wpas_dbus_getter_bss_bssid,
2357           NULL
2358         },
2359         { "Privacy", WPAS_DBUS_NEW_IFACE_BSS, "b",
2360           wpas_dbus_getter_bss_privacy,
2361           NULL
2362         },
2363         { "Mode", WPAS_DBUS_NEW_IFACE_BSS, "s",
2364           wpas_dbus_getter_bss_mode,
2365           NULL
2366         },
2367         { "Signal", WPAS_DBUS_NEW_IFACE_BSS, "n",
2368           wpas_dbus_getter_bss_signal,
2369           NULL
2370         },
2371         { "Frequency", WPAS_DBUS_NEW_IFACE_BSS, "q",
2372           wpas_dbus_getter_bss_frequency,
2373           NULL
2374         },
2375         { "Rates", WPAS_DBUS_NEW_IFACE_BSS, "au",
2376           wpas_dbus_getter_bss_rates,
2377           NULL
2378         },
2379         { "WPA", WPAS_DBUS_NEW_IFACE_BSS, "a{sv}",
2380           wpas_dbus_getter_bss_wpa,
2381           NULL
2382         },
2383         { "RSN", WPAS_DBUS_NEW_IFACE_BSS, "a{sv}",
2384           wpas_dbus_getter_bss_rsn,
2385           NULL
2386         },
2387         { "WPS", WPAS_DBUS_NEW_IFACE_BSS, "a{sv}",
2388           wpas_dbus_getter_bss_wps,
2389           NULL
2390         },
2391         { "IEs", WPAS_DBUS_NEW_IFACE_BSS, "ay",
2392           wpas_dbus_getter_bss_ies,
2393           NULL
2394         },
2395         { "Age", WPAS_DBUS_NEW_IFACE_BSS, "u",
2396           wpas_dbus_getter_bss_age,
2397           NULL
2398         },
2399         { NULL, NULL, NULL, NULL, NULL }
2400 };
2401
2402
2403 static const struct wpa_dbus_signal_desc wpas_dbus_bss_signals[] = {
2404         /* Deprecated: use org.freedesktop.DBus.Properties.PropertiesChanged */
2405         { "PropertiesChanged", WPAS_DBUS_NEW_IFACE_BSS,
2406           {
2407                   { "properties", "a{sv}", ARG_OUT },
2408                   END_ARGS
2409           }
2410         },
2411         { NULL, NULL, { END_ARGS } }
2412 };
2413
2414
2415 /**
2416  * wpas_dbus_unregister_bss - Unregister a scanned BSS from dbus
2417  * @wpa_s: wpa_supplicant interface structure
2418  * @bssid: scanned network bssid
2419  * @id: unique BSS identifier
2420  * Returns: 0 on success, -1 on failure
2421  *
2422  * Unregisters BSS representing object from dbus
2423  */
2424 int wpas_dbus_unregister_bss(struct wpa_supplicant *wpa_s,
2425                              u8 bssid[ETH_ALEN], unsigned int id)
2426 {
2427         struct wpas_dbus_priv *ctrl_iface;
2428         char bss_obj_path[WPAS_DBUS_OBJECT_PATH_MAX];
2429
2430         /* Do nothing if the control interface is not turned on */
2431         if (wpa_s == NULL || wpa_s->global == NULL || !wpa_s->dbus_new_path)
2432                 return 0;
2433         ctrl_iface = wpa_s->global->dbus;
2434         if (ctrl_iface == NULL)
2435                 return 0;
2436
2437         os_snprintf(bss_obj_path, WPAS_DBUS_OBJECT_PATH_MAX,
2438                     "%s/" WPAS_DBUS_NEW_BSSIDS_PART "/%u",
2439                     wpa_s->dbus_new_path, id);
2440
2441         wpa_printf(MSG_DEBUG, "dbus: Unregister BSS object '%s'",
2442                    bss_obj_path);
2443         if (wpa_dbus_unregister_object_per_iface(ctrl_iface, bss_obj_path)) {
2444                 wpa_printf(MSG_ERROR, "dbus: Cannot unregister BSS object %s",
2445                            bss_obj_path);
2446                 return -1;
2447         }
2448
2449         wpas_dbus_signal_bss_removed(wpa_s, bss_obj_path);
2450         wpas_dbus_signal_prop_changed(wpa_s, WPAS_DBUS_PROP_BSSS);
2451
2452         return 0;
2453 }
2454
2455
2456 /**
2457  * wpas_dbus_register_bss - Register a scanned BSS with dbus
2458  * @wpa_s: wpa_supplicant interface structure
2459  * @bssid: scanned network bssid
2460  * @id: unique BSS identifier
2461  * Returns: 0 on success, -1 on failure
2462  *
2463  * Registers BSS representing object with dbus
2464  */
2465 int wpas_dbus_register_bss(struct wpa_supplicant *wpa_s,
2466                            u8 bssid[ETH_ALEN], unsigned int id)
2467 {
2468         struct wpas_dbus_priv *ctrl_iface;
2469         struct wpa_dbus_object_desc *obj_desc;
2470         char bss_obj_path[WPAS_DBUS_OBJECT_PATH_MAX];
2471         struct bss_handler_args *arg;
2472
2473         /* Do nothing if the control interface is not turned on */
2474         if (wpa_s == NULL || wpa_s->global == NULL || !wpa_s->dbus_new_path)
2475                 return 0;
2476         ctrl_iface = wpa_s->global->dbus;
2477         if (ctrl_iface == NULL)
2478                 return 0;
2479
2480         os_snprintf(bss_obj_path, WPAS_DBUS_OBJECT_PATH_MAX,
2481                     "%s/" WPAS_DBUS_NEW_BSSIDS_PART "/%u",
2482                     wpa_s->dbus_new_path, id);
2483
2484         obj_desc = os_zalloc(sizeof(struct wpa_dbus_object_desc));
2485         if (!obj_desc) {
2486                 wpa_printf(MSG_ERROR,
2487                            "Not enough memory to create object description");
2488                 goto err;
2489         }
2490
2491         arg = os_zalloc(sizeof(struct bss_handler_args));
2492         if (!arg) {
2493                 wpa_printf(MSG_ERROR,
2494                            "Not enough memory to create arguments for handler");
2495                 goto err;
2496         }
2497         arg->wpa_s = wpa_s;
2498         arg->id = id;
2499
2500         wpas_dbus_register(obj_desc, arg, wpa_dbus_free, NULL,
2501                            wpas_dbus_bss_properties,
2502                            wpas_dbus_bss_signals);
2503
2504         wpa_printf(MSG_DEBUG, "dbus: Register BSS object '%s'",
2505                    bss_obj_path);
2506         if (wpa_dbus_register_object_per_iface(ctrl_iface, bss_obj_path,
2507                                                wpa_s->ifname, obj_desc)) {
2508                 wpa_printf(MSG_ERROR,
2509                            "Cannot register BSSID dbus object %s.",
2510                            bss_obj_path);
2511                 goto err;
2512         }
2513
2514         wpas_dbus_signal_bss_added(wpa_s, bss_obj_path);
2515         wpas_dbus_signal_prop_changed(wpa_s, WPAS_DBUS_PROP_BSSS);
2516
2517         return 0;
2518
2519 err:
2520         free_dbus_object_desc(obj_desc);
2521         return -1;
2522 }
2523
2524
2525 static const struct wpa_dbus_method_desc wpas_dbus_interface_methods[] = {
2526         { "Scan", WPAS_DBUS_NEW_IFACE_INTERFACE,
2527           (WPADBusMethodHandler) wpas_dbus_handler_scan,
2528           {
2529                   { "args", "a{sv}", ARG_IN },
2530                   END_ARGS
2531           }
2532         },
2533         { "SignalPoll", WPAS_DBUS_NEW_IFACE_INTERFACE,
2534           (WPADBusMethodHandler) wpas_dbus_handler_signal_poll,
2535           {
2536                   { "args", "a{sv}", ARG_OUT },
2537                   END_ARGS
2538           }
2539         },
2540         { "Disconnect", WPAS_DBUS_NEW_IFACE_INTERFACE,
2541           (WPADBusMethodHandler) wpas_dbus_handler_disconnect,
2542           {
2543                   END_ARGS
2544           }
2545         },
2546         { "AddNetwork", WPAS_DBUS_NEW_IFACE_INTERFACE,
2547           (WPADBusMethodHandler) wpas_dbus_handler_add_network,
2548           {
2549                   { "args", "a{sv}", ARG_IN },
2550                   { "path", "o", ARG_OUT },
2551                   END_ARGS
2552           }
2553         },
2554         { "Reassociate", WPAS_DBUS_NEW_IFACE_INTERFACE,
2555           (WPADBusMethodHandler) wpas_dbus_handler_reassociate,
2556           {
2557                   END_ARGS
2558           }
2559         },
2560         { "Reattach", WPAS_DBUS_NEW_IFACE_INTERFACE,
2561           (WPADBusMethodHandler) wpas_dbus_handler_reattach,
2562           {
2563                   END_ARGS
2564           }
2565         },
2566         { "Reconnect", WPAS_DBUS_NEW_IFACE_INTERFACE,
2567           (WPADBusMethodHandler) wpas_dbus_handler_reconnect,
2568           {
2569                   END_ARGS
2570           }
2571         },
2572         { "RemoveNetwork", WPAS_DBUS_NEW_IFACE_INTERFACE,
2573           (WPADBusMethodHandler) wpas_dbus_handler_remove_network,
2574           {
2575                   { "path", "o", ARG_IN },
2576                   END_ARGS
2577           }
2578         },
2579         { "RemoveAllNetworks", WPAS_DBUS_NEW_IFACE_INTERFACE,
2580           (WPADBusMethodHandler) wpas_dbus_handler_remove_all_networks,
2581           {
2582                   END_ARGS
2583           }
2584         },
2585         { "SelectNetwork", WPAS_DBUS_NEW_IFACE_INTERFACE,
2586           (WPADBusMethodHandler) wpas_dbus_handler_select_network,
2587           {
2588                   { "path", "o", ARG_IN },
2589                   END_ARGS
2590           }
2591         },
2592         { "NetworkReply", WPAS_DBUS_NEW_IFACE_INTERFACE,
2593           (WPADBusMethodHandler) wpas_dbus_handler_network_reply,
2594           {
2595                   { "path", "o", ARG_IN },
2596                   { "field", "s", ARG_IN },
2597                   { "value", "s", ARG_IN },
2598                   END_ARGS
2599           }
2600         },
2601 #ifndef CONFIG_NO_CONFIG_BLOBS
2602         { "AddBlob", WPAS_DBUS_NEW_IFACE_INTERFACE,
2603           (WPADBusMethodHandler) wpas_dbus_handler_add_blob,
2604           {
2605                   { "name", "s", ARG_IN },
2606                   { "data", "ay", ARG_IN },
2607                   END_ARGS
2608           }
2609         },
2610         { "GetBlob", WPAS_DBUS_NEW_IFACE_INTERFACE,
2611           (WPADBusMethodHandler) wpas_dbus_handler_get_blob,
2612           {
2613                   { "name", "s", ARG_IN },
2614                   { "data", "ay", ARG_OUT },
2615                   END_ARGS
2616           }
2617         },
2618         { "RemoveBlob", WPAS_DBUS_NEW_IFACE_INTERFACE,
2619           (WPADBusMethodHandler) wpas_dbus_handler_remove_blob,
2620           {
2621                   { "name", "s", ARG_IN },
2622                   END_ARGS
2623           }
2624         },
2625 #endif /* CONFIG_NO_CONFIG_BLOBS */
2626         { "SetPKCS11EngineAndModulePath", WPAS_DBUS_NEW_IFACE_INTERFACE,
2627           (WPADBusMethodHandler)
2628           wpas_dbus_handler_set_pkcs11_engine_and_module_path,
2629           {
2630                   { "pkcs11_engine_path", "s", ARG_IN },
2631                   { "pkcs11_module_path", "s", ARG_IN },
2632                   END_ARGS
2633           }
2634         },
2635 #ifdef CONFIG_WPS
2636         { "Start", WPAS_DBUS_NEW_IFACE_WPS,
2637           (WPADBusMethodHandler) wpas_dbus_handler_wps_start,
2638           {
2639                   { "args", "a{sv}", ARG_IN },
2640                   { "output", "a{sv}", ARG_OUT },
2641                   END_ARGS
2642           }
2643         },
2644         { "Cancel", WPAS_DBUS_NEW_IFACE_WPS,
2645           (WPADBusMethodHandler) wpas_dbus_handler_wps_cancel,
2646           {
2647                   END_ARGS
2648           }
2649         },
2650 #endif /* CONFIG_WPS */
2651 #ifdef CONFIG_P2P
2652         { "Find", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
2653           (WPADBusMethodHandler) wpas_dbus_handler_p2p_find,
2654           {
2655                   { "args", "a{sv}", ARG_IN },
2656                   END_ARGS
2657           }
2658         },
2659         { "StopFind", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
2660           (WPADBusMethodHandler) wpas_dbus_handler_p2p_stop_find,
2661           {
2662                   END_ARGS
2663           }
2664         },
2665         { "Listen", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
2666           (WPADBusMethodHandler) wpas_dbus_handler_p2p_listen,
2667           {
2668                   { "timeout", "i", ARG_IN },
2669                   END_ARGS
2670           }
2671         },
2672         { "ExtendedListen", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
2673           (WPADBusMethodHandler) wpas_dbus_handler_p2p_extendedlisten,
2674           {
2675                   { "args", "a{sv}", ARG_IN },
2676                   END_ARGS
2677           }
2678         },
2679         { "PresenceRequest", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
2680           (WPADBusMethodHandler) wpas_dbus_handler_p2p_presence_request,
2681           {
2682                   { "args", "a{sv}", ARG_IN },
2683                   END_ARGS
2684           }
2685         },
2686         { "ProvisionDiscoveryRequest", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
2687           (WPADBusMethodHandler) wpas_dbus_handler_p2p_prov_disc_req,
2688           {
2689                   { "peer", "o", ARG_IN },
2690                   { "config_method", "s", ARG_IN },
2691                   END_ARGS
2692           }
2693         },
2694         { "Connect", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
2695           (WPADBusMethodHandler) wpas_dbus_handler_p2p_connect,
2696           {
2697                   { "args", "a{sv}", ARG_IN },
2698                   { "generated_pin", "s", ARG_OUT },
2699                   END_ARGS
2700           }
2701         },
2702         { "GroupAdd", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
2703           (WPADBusMethodHandler) wpas_dbus_handler_p2p_group_add,
2704           {
2705                   { "args", "a{sv}", ARG_IN },
2706                   END_ARGS
2707           }
2708         },
2709         { "Cancel", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
2710           (WPADBusMethodHandler) wpas_dbus_handler_p2p_cancel,
2711           {
2712                   END_ARGS
2713           }
2714         },
2715         { "Invite", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
2716           (WPADBusMethodHandler) wpas_dbus_handler_p2p_invite,
2717           {
2718                   { "args", "a{sv}", ARG_IN },
2719                   END_ARGS
2720           }
2721         },
2722         { "Disconnect", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
2723           (WPADBusMethodHandler) wpas_dbus_handler_p2p_disconnect,
2724           {
2725                   END_ARGS
2726           }
2727         },
2728         { "RejectPeer", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
2729           (WPADBusMethodHandler) wpas_dbus_handler_p2p_rejectpeer,
2730           {
2731                   { "peer", "o", ARG_IN },
2732                   END_ARGS
2733           }
2734         },
2735         { "RemoveClient", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
2736           (WPADBusMethodHandler) wpas_dbus_handler_p2p_remove_client,
2737           {
2738                   { "args", "a{sv}", ARG_IN },
2739                   END_ARGS
2740           }
2741         },
2742         { "Flush", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
2743           (WPADBusMethodHandler) wpas_dbus_handler_p2p_flush,
2744           {
2745                   END_ARGS
2746           }
2747         },
2748         { "AddService", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
2749           (WPADBusMethodHandler) wpas_dbus_handler_p2p_add_service,
2750           {
2751                   { "args", "a{sv}", ARG_IN },
2752                   END_ARGS
2753           }
2754         },
2755         { "DeleteService", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
2756           (WPADBusMethodHandler) wpas_dbus_handler_p2p_delete_service,
2757           {
2758                   { "args", "a{sv}", ARG_IN },
2759                   END_ARGS
2760           }
2761         },
2762         { "FlushService", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
2763           (WPADBusMethodHandler) wpas_dbus_handler_p2p_flush_service,
2764           {
2765                   END_ARGS
2766           }
2767         },
2768         { "ServiceDiscoveryRequest", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
2769           (WPADBusMethodHandler) wpas_dbus_handler_p2p_service_sd_req,
2770           {
2771                   { "args", "a{sv}", ARG_IN },
2772                   { "ref", "t", ARG_OUT },
2773                   END_ARGS
2774           }
2775         },
2776         { "ServiceDiscoveryResponse", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
2777           (WPADBusMethodHandler) wpas_dbus_handler_p2p_service_sd_res,
2778           {
2779                   { "args", "a{sv}", ARG_IN },
2780                   END_ARGS
2781           }
2782         },
2783         { "ServiceDiscoveryCancelRequest", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
2784           (WPADBusMethodHandler) wpas_dbus_handler_p2p_service_sd_cancel_req,
2785           {
2786                   { "args", "t", ARG_IN },
2787                   END_ARGS
2788           }
2789         },
2790         { "ServiceUpdate", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
2791           (WPADBusMethodHandler) wpas_dbus_handler_p2p_service_update,
2792           {
2793                   END_ARGS
2794           }
2795         },
2796         { "ServiceDiscoveryExternal", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
2797           (WPADBusMethodHandler) wpas_dbus_handler_p2p_serv_disc_external,
2798           {
2799                   { "arg", "i", ARG_IN },
2800                   END_ARGS
2801           }
2802         },
2803         { "AddPersistentGroup", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
2804           (WPADBusMethodHandler) wpas_dbus_handler_add_persistent_group,
2805           {
2806                   { "args", "a{sv}", ARG_IN },
2807                   { "path", "o", ARG_OUT },
2808                   END_ARGS
2809           }
2810         },
2811         { "RemovePersistentGroup", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
2812           (WPADBusMethodHandler) wpas_dbus_handler_remove_persistent_group,
2813           {
2814                   { "path", "o", ARG_IN },
2815                   END_ARGS
2816           }
2817         },
2818         { "RemoveAllPersistentGroups", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
2819           (WPADBusMethodHandler)
2820           wpas_dbus_handler_remove_all_persistent_groups,
2821           {
2822                   END_ARGS
2823           }
2824         },
2825 #endif /* CONFIG_P2P */
2826         { "FlushBSS", WPAS_DBUS_NEW_IFACE_INTERFACE,
2827           (WPADBusMethodHandler) wpas_dbus_handler_flush_bss,
2828           {
2829                   { "age", "u", ARG_IN },
2830                   END_ARGS
2831           }
2832         },
2833 #ifdef CONFIG_AP
2834         { "SubscribeProbeReq", WPAS_DBUS_NEW_IFACE_INTERFACE,
2835           (WPADBusMethodHandler) wpas_dbus_handler_subscribe_preq,
2836           {
2837                   END_ARGS
2838           }
2839         },
2840         { "UnsubscribeProbeReq", WPAS_DBUS_NEW_IFACE_INTERFACE,
2841           (WPADBusMethodHandler) wpas_dbus_handler_unsubscribe_preq,
2842           {
2843                   END_ARGS
2844           }
2845         },
2846 #endif /* CONFIG_AP */
2847         { "EAPLogoff", WPAS_DBUS_NEW_IFACE_INTERFACE,
2848           (WPADBusMethodHandler) wpas_dbus_handler_eap_logoff,
2849           {
2850                   END_ARGS
2851           }
2852         },
2853         { "EAPLogon", WPAS_DBUS_NEW_IFACE_INTERFACE,
2854           (WPADBusMethodHandler) wpas_dbus_handler_eap_logon,
2855           {
2856                   END_ARGS
2857           }
2858         },
2859 #ifdef CONFIG_AUTOSCAN
2860         { "AutoScan", WPAS_DBUS_NEW_IFACE_INTERFACE,
2861           (WPADBusMethodHandler) wpas_dbus_handler_autoscan,
2862           {
2863                   { "arg", "s", ARG_IN },
2864                   END_ARGS
2865           }
2866         },
2867 #endif /* CONFIG_AUTOSCAN */
2868 #ifdef CONFIG_TDLS
2869         { "TDLSDiscover", WPAS_DBUS_NEW_IFACE_INTERFACE,
2870           (WPADBusMethodHandler) wpas_dbus_handler_tdls_discover,
2871           {
2872                   { "peer_address", "s", ARG_IN },
2873                   END_ARGS
2874           }
2875         },
2876         { "TDLSSetup", WPAS_DBUS_NEW_IFACE_INTERFACE,
2877           (WPADBusMethodHandler) wpas_dbus_handler_tdls_setup,
2878           {
2879                   { "peer_address", "s", ARG_IN },
2880                   END_ARGS
2881           }
2882         },
2883         { "TDLSStatus", WPAS_DBUS_NEW_IFACE_INTERFACE,
2884           (WPADBusMethodHandler) wpas_dbus_handler_tdls_status,
2885           {
2886                   { "peer_address", "s", ARG_IN },
2887                   { "status", "s", ARG_OUT },
2888                   END_ARGS
2889           }
2890         },
2891         { "TDLSTeardown", WPAS_DBUS_NEW_IFACE_INTERFACE,
2892           (WPADBusMethodHandler) wpas_dbus_handler_tdls_teardown,
2893           {
2894                   { "peer_address", "s", ARG_IN },
2895                   END_ARGS
2896           }
2897         },
2898 #endif /* CONFIG_TDLS */
2899         { NULL, NULL, NULL, { END_ARGS } }
2900 };
2901
2902 static const struct wpa_dbus_property_desc wpas_dbus_interface_properties[] = {
2903         { "Capabilities", WPAS_DBUS_NEW_IFACE_INTERFACE, "a{sv}",
2904           wpas_dbus_getter_capabilities,
2905           NULL
2906         },
2907         { "State", WPAS_DBUS_NEW_IFACE_INTERFACE, "s",
2908           wpas_dbus_getter_state,
2909           NULL
2910         },
2911         { "Scanning", WPAS_DBUS_NEW_IFACE_INTERFACE, "b",
2912           wpas_dbus_getter_scanning,
2913           NULL
2914         },
2915         { "ApScan", WPAS_DBUS_NEW_IFACE_INTERFACE, "u",
2916           wpas_dbus_getter_ap_scan,
2917           wpas_dbus_setter_ap_scan
2918         },
2919         { "BSSExpireAge", WPAS_DBUS_NEW_IFACE_INTERFACE, "u",
2920           wpas_dbus_getter_bss_expire_age,
2921           wpas_dbus_setter_bss_expire_age
2922         },
2923         { "BSSExpireCount", WPAS_DBUS_NEW_IFACE_INTERFACE, "u",
2924           wpas_dbus_getter_bss_expire_count,
2925           wpas_dbus_setter_bss_expire_count
2926         },
2927         { "Country", WPAS_DBUS_NEW_IFACE_INTERFACE, "s",
2928           wpas_dbus_getter_country,
2929           wpas_dbus_setter_country
2930         },
2931         { "Ifname", WPAS_DBUS_NEW_IFACE_INTERFACE, "s",
2932           wpas_dbus_getter_ifname,
2933           NULL
2934         },
2935         { "Driver", WPAS_DBUS_NEW_IFACE_INTERFACE, "s",
2936           wpas_dbus_getter_driver,
2937           NULL
2938         },
2939         { "BridgeIfname", WPAS_DBUS_NEW_IFACE_INTERFACE, "s",
2940           wpas_dbus_getter_bridge_ifname,
2941           NULL
2942         },
2943         { "CurrentBSS", WPAS_DBUS_NEW_IFACE_INTERFACE, "o",
2944           wpas_dbus_getter_current_bss,
2945           NULL
2946         },
2947         { "CurrentNetwork", WPAS_DBUS_NEW_IFACE_INTERFACE, "o",
2948           wpas_dbus_getter_current_network,
2949           NULL
2950         },
2951         { "CurrentAuthMode", WPAS_DBUS_NEW_IFACE_INTERFACE, "s",
2952           wpas_dbus_getter_current_auth_mode,
2953           NULL
2954         },
2955         { "Blobs", WPAS_DBUS_NEW_IFACE_INTERFACE, "a{say}",
2956           wpas_dbus_getter_blobs,
2957           NULL
2958         },
2959         { "BSSs", WPAS_DBUS_NEW_IFACE_INTERFACE, "ao",
2960           wpas_dbus_getter_bsss,
2961           NULL
2962         },
2963         { "Networks", WPAS_DBUS_NEW_IFACE_INTERFACE, "ao",
2964           wpas_dbus_getter_networks,
2965           NULL
2966         },
2967         { "FastReauth", WPAS_DBUS_NEW_IFACE_INTERFACE, "b",
2968           wpas_dbus_getter_fast_reauth,
2969           wpas_dbus_setter_fast_reauth
2970         },
2971         { "ScanInterval", WPAS_DBUS_NEW_IFACE_INTERFACE, "i",
2972           wpas_dbus_getter_scan_interval,
2973           wpas_dbus_setter_scan_interval
2974         },
2975         { "PKCS11EnginePath", WPAS_DBUS_NEW_IFACE_INTERFACE, "s",
2976           wpas_dbus_getter_pkcs11_engine_path,
2977           NULL
2978         },
2979         { "PKCS11ModulePath", WPAS_DBUS_NEW_IFACE_INTERFACE, "s",
2980           wpas_dbus_getter_pkcs11_module_path,
2981           NULL
2982         },
2983 #ifdef CONFIG_WPS
2984         { "ProcessCredentials", WPAS_DBUS_NEW_IFACE_WPS, "b",
2985           wpas_dbus_getter_process_credentials,
2986           wpas_dbus_setter_process_credentials
2987         },
2988         { "ConfigMethods", WPAS_DBUS_NEW_IFACE_WPS, "s",
2989           wpas_dbus_getter_config_methods,
2990           wpas_dbus_setter_config_methods
2991         },
2992 #endif /* CONFIG_WPS */
2993 #ifdef CONFIG_P2P
2994         { "P2PDeviceConfig", WPAS_DBUS_NEW_IFACE_P2PDEVICE, "a{sv}",
2995           wpas_dbus_getter_p2p_device_config,
2996           wpas_dbus_setter_p2p_device_config
2997         },
2998         { "Peers", WPAS_DBUS_NEW_IFACE_P2PDEVICE, "ao",
2999           wpas_dbus_getter_p2p_peers,
3000           NULL
3001         },
3002         { "Role", WPAS_DBUS_NEW_IFACE_P2PDEVICE, "s",
3003           wpas_dbus_getter_p2p_role,
3004           NULL
3005         },
3006         { "Group", WPAS_DBUS_NEW_IFACE_P2PDEVICE, "o",
3007           wpas_dbus_getter_p2p_group,
3008           NULL
3009         },
3010         { "PeerGO", WPAS_DBUS_NEW_IFACE_P2PDEVICE, "o",
3011           wpas_dbus_getter_p2p_peergo,
3012           NULL
3013         },
3014         { "PersistentGroups", WPAS_DBUS_NEW_IFACE_P2PDEVICE, "ao",
3015           wpas_dbus_getter_persistent_groups,
3016           NULL
3017         },
3018 #endif /* CONFIG_P2P */
3019         { "DisconnectReason", WPAS_DBUS_NEW_IFACE_INTERFACE, "i",
3020           wpas_dbus_getter_disconnect_reason,
3021           NULL
3022         },
3023         { NULL, NULL, NULL, NULL, NULL }
3024 };
3025
3026 static const struct wpa_dbus_signal_desc wpas_dbus_interface_signals[] = {
3027         { "ScanDone", WPAS_DBUS_NEW_IFACE_INTERFACE,
3028           {
3029                   { "success", "b", ARG_OUT },
3030                   END_ARGS
3031           }
3032         },
3033         { "BSSAdded", WPAS_DBUS_NEW_IFACE_INTERFACE,
3034           {
3035                   { "path", "o", ARG_OUT },
3036                   { "properties", "a{sv}", ARG_OUT },
3037                   END_ARGS
3038           }
3039         },
3040         { "BSSRemoved", WPAS_DBUS_NEW_IFACE_INTERFACE,
3041           {
3042                   { "path", "o", ARG_OUT },
3043                   END_ARGS
3044           }
3045         },
3046         { "BlobAdded", WPAS_DBUS_NEW_IFACE_INTERFACE,
3047           {
3048                   { "name", "s", ARG_OUT },
3049                   END_ARGS
3050           }
3051         },
3052         { "BlobRemoved", WPAS_DBUS_NEW_IFACE_INTERFACE,
3053           {
3054                   { "name", "s", ARG_OUT },
3055                   END_ARGS
3056           }
3057         },
3058         { "NetworkAdded", WPAS_DBUS_NEW_IFACE_INTERFACE,
3059           {
3060                   { "path", "o", ARG_OUT },
3061                   { "properties", "a{sv}", ARG_OUT },
3062                   END_ARGS
3063           }
3064         },
3065         { "NetworkRemoved", WPAS_DBUS_NEW_IFACE_INTERFACE,
3066           {
3067                   { "path", "o", ARG_OUT },
3068                   END_ARGS
3069           }
3070         },
3071         { "NetworkSelected", WPAS_DBUS_NEW_IFACE_INTERFACE,
3072           {
3073                   { "path", "o", ARG_OUT },
3074                   END_ARGS
3075           }
3076         },
3077         /* Deprecated: use org.freedesktop.DBus.Properties.PropertiesChanged */
3078         { "PropertiesChanged", WPAS_DBUS_NEW_IFACE_INTERFACE,
3079           {
3080                   { "properties", "a{sv}", ARG_OUT },
3081                   END_ARGS
3082           }
3083         },
3084 #ifdef CONFIG_WPS
3085         { "Event", WPAS_DBUS_NEW_IFACE_WPS,
3086           {
3087                   { "name", "s", ARG_OUT },
3088                   { "args", "a{sv}", ARG_OUT },
3089                   END_ARGS
3090           }
3091         },
3092         { "Credentials", WPAS_DBUS_NEW_IFACE_WPS,
3093           {
3094                   { "credentials", "a{sv}", ARG_OUT },
3095                   END_ARGS
3096           }
3097         },
3098         /* Deprecated: use org.freedesktop.DBus.Properties.PropertiesChanged */
3099         { "PropertiesChanged", WPAS_DBUS_NEW_IFACE_WPS,
3100           {
3101                   { "properties", "a{sv}", ARG_OUT },
3102                   END_ARGS
3103           }
3104         },
3105 #endif /* CONFIG_WPS */
3106 #ifdef CONFIG_P2P
3107         { "DeviceFound", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
3108           {
3109                   { "path", "o", ARG_OUT },
3110                   END_ARGS
3111           }
3112         },
3113         { "DeviceLost", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
3114           {
3115                   { "path", "o", ARG_OUT },
3116                   END_ARGS
3117           }
3118         },
3119         { "FindStopped", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
3120           {
3121                   END_ARGS
3122           }
3123         },
3124         { "ProvisionDiscoveryRequestDisplayPin", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
3125           {
3126                   { "peer_object", "o", ARG_OUT },
3127                   { "pin", "s", ARG_OUT },
3128                   END_ARGS
3129           }
3130         },
3131         { "ProvisionDiscoveryResponseDisplayPin", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
3132           {
3133                   { "peer_object", "o", ARG_OUT },
3134                   { "pin", "s", ARG_OUT },
3135                   END_ARGS
3136           }
3137         },
3138         { "ProvisionDiscoveryRequestEnterPin", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
3139           {
3140                   { "peer_object", "o", ARG_OUT },
3141                   END_ARGS
3142           }
3143         },
3144         { "ProvisionDiscoveryResponseEnterPin", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
3145           {
3146                   { "peer_object", "o", ARG_OUT },
3147                   END_ARGS
3148           }
3149         },
3150         { "ProvisionDiscoveryPBCRequest", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
3151           {
3152                   { "peer_object", "o", ARG_OUT },
3153                   END_ARGS
3154           }
3155         },
3156         { "ProvisionDiscoveryPBCResponse", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
3157           {
3158                   { "peer_object", "o", ARG_OUT },
3159                   END_ARGS
3160           }
3161         },
3162         { "ProvisionDiscoveryFailure", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
3163           {
3164                   { "peer_object", "o", ARG_OUT },
3165                   { "status", "i", ARG_OUT },
3166                   END_ARGS
3167           }
3168         },
3169         { "GroupStarted", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
3170           {
3171                   { "properties", "a{sv}", ARG_OUT },
3172                   END_ARGS
3173           }
3174         },
3175         { "GONegotiationSuccess", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
3176           {
3177                   { "properties", "a{sv}", ARG_OUT },
3178                   END_ARGS
3179           }
3180         },
3181         { "GONegotiationFailure", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
3182           {
3183                   { "properties", "a{sv}", ARG_OUT },
3184                   END_ARGS
3185           }
3186         },
3187         { "GONegotiationRequest", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
3188           {
3189                   { "path", "o", ARG_OUT },
3190                   { "dev_passwd_id", "i", ARG_OUT },
3191                   { "device_go_intent", "y", ARG_OUT },
3192                   END_ARGS
3193           }
3194         },
3195         { "InvitationResult", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
3196           {
3197                   { "invite_result", "a{sv}", ARG_OUT },
3198                   END_ARGS
3199           }
3200         },
3201         { "GroupFinished", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
3202           {
3203                   { "properties", "a{sv}", ARG_OUT },
3204                   END_ARGS
3205           }
3206         },
3207         { "ServiceDiscoveryRequest", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
3208           {
3209                   { "sd_request", "a{sv}", ARG_OUT },
3210                   END_ARGS
3211           }
3212         },
3213         { "ServiceDiscoveryResponse", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
3214           {
3215                   { "sd_response", "a{sv}", ARG_OUT },
3216                   END_ARGS
3217           }
3218         },
3219         { "PersistentGroupAdded", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
3220           {
3221                   { "path", "o", ARG_OUT },
3222                   { "properties", "a{sv}", ARG_OUT },
3223                   END_ARGS
3224           }
3225         },
3226         { "PersistentGroupRemoved", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
3227           {
3228                   { "path", "o", ARG_OUT },
3229                   END_ARGS
3230           }
3231         },
3232         { "WpsFailed", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
3233           {
3234                   { "name", "s", ARG_OUT },
3235                   { "args", "a{sv}", ARG_OUT },
3236                   END_ARGS
3237           }
3238         },
3239 #endif /* CONFIG_P2P */
3240 #ifdef CONFIG_AP
3241         { "ProbeRequest", WPAS_DBUS_NEW_IFACE_INTERFACE,
3242           {
3243                   { "args", "a{sv}", ARG_OUT },
3244                   END_ARGS
3245           }
3246         },
3247 #endif /* CONFIG_AP */
3248         { "Certification", WPAS_DBUS_NEW_IFACE_INTERFACE,
3249           {
3250                   { "certification", "a{sv}", ARG_OUT },
3251                   END_ARGS
3252           }
3253         },
3254         { "EAP", WPAS_DBUS_NEW_IFACE_INTERFACE,
3255           {
3256                   { "status", "s", ARG_OUT },
3257                   { "parameter", "s", ARG_OUT },
3258                   END_ARGS
3259           }
3260         },
3261         { "StaAuthorized", WPAS_DBUS_NEW_IFACE_INTERFACE,
3262           {
3263                   { "name", "s", ARG_OUT },
3264                   END_ARGS
3265           }
3266         },
3267         { "StaDeauthorized", WPAS_DBUS_NEW_IFACE_INTERFACE,
3268           {
3269                   { "name", "s", ARG_OUT },
3270                   END_ARGS
3271           }
3272         },
3273         { "NetworkRequest", WPAS_DBUS_NEW_IFACE_INTERFACE,
3274           {
3275                   { "path", "o", ARG_OUT },
3276                   { "field", "s", ARG_OUT },
3277                   { "text", "s", ARG_OUT },
3278                   END_ARGS
3279           }
3280         },
3281         { NULL, NULL, { END_ARGS } }
3282 };
3283
3284
3285 /**
3286  * wpas_dbus_register_interface - Register an interface with D-Bus
3287  * @wpa_s: wpa_supplicant interface structure
3288  * Returns: 0 on success, -1 on failure
3289  */
3290 int wpas_dbus_register_interface(struct wpa_supplicant *wpa_s)
3291 {
3292
3293         struct wpa_dbus_object_desc *obj_desc = NULL;
3294         struct wpas_dbus_priv *ctrl_iface = wpa_s->global->dbus;
3295         int next;
3296
3297         /* Do nothing if the control interface is not turned on */
3298         if (ctrl_iface == NULL)
3299                 return 0;
3300
3301         /* Create and set the interface's object path */
3302         wpa_s->dbus_new_path = os_zalloc(WPAS_DBUS_OBJECT_PATH_MAX);
3303         if (wpa_s->dbus_new_path == NULL)
3304                 return -1;
3305         next = ctrl_iface->next_objid++;
3306         os_snprintf(wpa_s->dbus_new_path, WPAS_DBUS_OBJECT_PATH_MAX,
3307                     WPAS_DBUS_NEW_PATH_INTERFACES "/%u",
3308                     next);
3309
3310         obj_desc = os_zalloc(sizeof(struct wpa_dbus_object_desc));
3311         if (!obj_desc) {
3312                 wpa_printf(MSG_ERROR,
3313                            "Not enough memory to create object description");
3314                 goto err;
3315         }
3316
3317         wpas_dbus_register(obj_desc, wpa_s, NULL, wpas_dbus_interface_methods,
3318                            wpas_dbus_interface_properties,
3319                            wpas_dbus_interface_signals);
3320
3321         wpa_printf(MSG_DEBUG, "dbus: Register interface object '%s'",
3322                    wpa_s->dbus_new_path);
3323         if (wpa_dbus_register_object_per_iface(ctrl_iface,
3324                                                wpa_s->dbus_new_path,
3325                                                wpa_s->ifname, obj_desc))
3326                 goto err;
3327
3328         wpas_dbus_signal_interface_added(wpa_s);
3329
3330         return 0;
3331
3332 err:
3333         os_free(wpa_s->dbus_new_path);
3334         wpa_s->dbus_new_path = NULL;
3335         free_dbus_object_desc(obj_desc);
3336         return -1;
3337 }
3338
3339
3340 /**
3341  * wpas_dbus_unregister_interface - Unregister the interface from D-Bus
3342  * @wpa_s: wpa_supplicant interface structure
3343  * Returns: 0 on success, -1 on failure
3344  */
3345 int wpas_dbus_unregister_interface(struct wpa_supplicant *wpa_s)
3346 {
3347         struct wpas_dbus_priv *ctrl_iface;
3348
3349         /* Do nothing if the control interface is not turned on */
3350         if (wpa_s == NULL || wpa_s->global == NULL)
3351                 return 0;
3352         ctrl_iface = wpa_s->global->dbus;
3353         if (ctrl_iface == NULL || wpa_s->dbus_new_path == NULL)
3354                 return 0;
3355
3356         wpa_printf(MSG_DEBUG, "dbus: Unregister interface object '%s'",
3357                    wpa_s->dbus_new_path);
3358
3359 #ifdef CONFIG_AP
3360         if (wpa_s->preq_notify_peer) {
3361                 wpas_dbus_unsubscribe_noc(ctrl_iface);
3362                 os_free(wpa_s->preq_notify_peer);
3363                 wpa_s->preq_notify_peer = NULL;
3364         }
3365 #endif /* CONFIG_AP */
3366
3367         if (wpa_dbus_unregister_object_per_iface(ctrl_iface,
3368                                                  wpa_s->dbus_new_path))
3369                 return -1;
3370
3371         wpas_dbus_signal_interface_removed(wpa_s);
3372
3373         os_free(wpa_s->dbus_new_path);
3374         wpa_s->dbus_new_path = NULL;
3375
3376         return 0;
3377 }
3378
3379 #ifdef CONFIG_P2P
3380
3381 static const struct wpa_dbus_property_desc wpas_dbus_p2p_peer_properties[] = {
3382         { "DeviceName", WPAS_DBUS_NEW_IFACE_P2P_PEER, "s",
3383           wpas_dbus_getter_p2p_peer_device_name,
3384           NULL
3385         },
3386         { "Manufacturer", WPAS_DBUS_NEW_IFACE_P2P_PEER, "s",
3387           wpas_dbus_getter_p2p_peer_manufacturer,
3388           NULL
3389         },
3390         { "ModelName", WPAS_DBUS_NEW_IFACE_P2P_PEER, "s",
3391           wpas_dbus_getter_p2p_peer_modelname,
3392           NULL
3393         },
3394         { "ModelNumber", WPAS_DBUS_NEW_IFACE_P2P_PEER, "s",
3395           wpas_dbus_getter_p2p_peer_modelnumber,
3396           NULL
3397         },
3398         { "SerialNumber", WPAS_DBUS_NEW_IFACE_P2P_PEER, "s",
3399           wpas_dbus_getter_p2p_peer_serialnumber,
3400           NULL
3401         },
3402         { "PrimaryDeviceType", WPAS_DBUS_NEW_IFACE_P2P_PEER, "ay",
3403           wpas_dbus_getter_p2p_peer_primary_device_type,
3404           NULL
3405         },
3406         { "config_method", WPAS_DBUS_NEW_IFACE_P2P_PEER, "q",
3407           wpas_dbus_getter_p2p_peer_config_method,
3408           NULL
3409         },
3410         { "level", WPAS_DBUS_NEW_IFACE_P2P_PEER, "i",
3411           wpas_dbus_getter_p2p_peer_level,
3412           NULL
3413         },
3414         { "devicecapability", WPAS_DBUS_NEW_IFACE_P2P_PEER, "y",
3415           wpas_dbus_getter_p2p_peer_device_capability,
3416           NULL
3417         },
3418         { "groupcapability", WPAS_DBUS_NEW_IFACE_P2P_PEER, "y",
3419           wpas_dbus_getter_p2p_peer_group_capability,
3420           NULL
3421         },
3422         { "SecondaryDeviceTypes", WPAS_DBUS_NEW_IFACE_P2P_PEER, "aay",
3423           wpas_dbus_getter_p2p_peer_secondary_device_types,
3424           NULL
3425         },
3426         { "VendorExtension", WPAS_DBUS_NEW_IFACE_P2P_PEER, "aay",
3427           wpas_dbus_getter_p2p_peer_vendor_extension,
3428           NULL
3429         },
3430         { "IEs", WPAS_DBUS_NEW_IFACE_P2P_PEER, "ay",
3431           wpas_dbus_getter_p2p_peer_ies,
3432           NULL
3433         },
3434         { "DeviceAddress", WPAS_DBUS_NEW_IFACE_P2P_PEER, "ay",
3435           wpas_dbus_getter_p2p_peer_device_address,
3436           NULL
3437         },
3438         { "Groups", WPAS_DBUS_NEW_IFACE_P2P_PEER, "ao",
3439           wpas_dbus_getter_p2p_peer_groups,
3440           NULL
3441         },
3442         { NULL, NULL, NULL, NULL, NULL }
3443 };
3444
3445 static const struct wpa_dbus_signal_desc wpas_dbus_p2p_peer_signals[] = {
3446         /* Deprecated: use org.freedesktop.DBus.Properties.PropertiesChanged */
3447         { "PropertiesChanged", WPAS_DBUS_NEW_IFACE_P2P_PEER,
3448           {
3449                   { "properties", "a{sv}", ARG_OUT },
3450                   END_ARGS
3451           }
3452         },
3453         { NULL, NULL, { END_ARGS } }
3454 };
3455
3456 /**
3457  * wpas_dbus_signal_peer - Send a peer related event signal
3458  * @wpa_s: %wpa_supplicant network interface data
3459  * @dev: peer device object
3460  * @interface: name of the interface emitting this signal.
3461  *      In case of peer objects, it would be emitted by either
3462  *      the "interface object" or by "peer objects"
3463  * @sig_name: signal name - DeviceFound
3464  *
3465  * Notify listeners about event related with newly found p2p peer device
3466  */
3467 static void wpas_dbus_signal_peer(struct wpa_supplicant *wpa_s,
3468                                   const u8 *dev_addr, const char *interface,
3469                                   const char *sig_name)
3470 {
3471         struct wpas_dbus_priv *iface;
3472         DBusMessage *msg;
3473         DBusMessageIter iter;
3474         char peer_obj_path[WPAS_DBUS_OBJECT_PATH_MAX], *path;
3475
3476         if (wpa_s->p2p_mgmt)
3477                 wpa_s = wpa_s->parent;
3478
3479         iface = wpa_s->global->dbus;
3480
3481         /* Do nothing if the control interface is not turned on */
3482         if (iface == NULL || !wpa_s->dbus_new_path)
3483                 return;
3484
3485         os_snprintf(peer_obj_path, WPAS_DBUS_OBJECT_PATH_MAX,
3486                     "%s/" WPAS_DBUS_NEW_P2P_PEERS_PART "/" COMPACT_MACSTR,
3487                     wpa_s->dbus_new_path, MAC2STR(dev_addr));
3488
3489         msg = dbus_message_new_signal(wpa_s->dbus_new_path, interface,
3490                                       sig_name);
3491         if (msg == NULL)
3492                 return;
3493
3494         dbus_message_iter_init_append(msg, &iter);
3495         path = peer_obj_path;
3496         if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_OBJECT_PATH,
3497                                             &path))
3498                 wpa_printf(MSG_ERROR, "dbus: Failed to construct signal");
3499         else
3500                 dbus_connection_send(iface->con, msg, NULL);
3501
3502         dbus_message_unref(msg);
3503 }
3504
3505
3506 /**
3507  * wpas_dbus_signal_peer_found - Send a peer found signal
3508  * @wpa_s: %wpa_supplicant network interface data
3509  * @dev_addr: Peer P2P Device Address
3510  *
3511  * Notify listeners about find a p2p peer device found
3512  */
3513 void wpas_dbus_signal_peer_device_found(struct wpa_supplicant *wpa_s,
3514                                         const u8 *dev_addr)
3515 {
3516         wpas_dbus_signal_peer(wpa_s, dev_addr,
3517                               WPAS_DBUS_NEW_IFACE_P2PDEVICE,
3518                               "DeviceFound");
3519 }
3520
3521 /**
3522  * wpas_dbus_signal_peer_lost - Send a peer lost signal
3523  * @wpa_s: %wpa_supplicant network interface data
3524  * @dev_addr: Peer P2P Device Address
3525  *
3526  * Notify listeners about lost a p2p peer device
3527  */
3528 void wpas_dbus_signal_peer_device_lost(struct wpa_supplicant *wpa_s,
3529                                        const u8 *dev_addr)
3530 {
3531         wpas_dbus_signal_peer(wpa_s, dev_addr,
3532                               WPAS_DBUS_NEW_IFACE_P2PDEVICE,
3533                               "DeviceLost");
3534 }
3535
3536 /**
3537  * wpas_dbus_register_peer - Register a discovered peer object with dbus
3538  * @wpa_s: wpa_supplicant interface structure
3539  * @dev_addr: P2P Device Address of the peer
3540  * Returns: 0 on success, -1 on failure
3541  *
3542  * Registers network representing object with dbus
3543  */
3544 int wpas_dbus_register_peer(struct wpa_supplicant *wpa_s, const u8 *dev_addr)
3545 {
3546         struct wpas_dbus_priv *ctrl_iface;
3547         struct wpa_dbus_object_desc *obj_desc;
3548         struct peer_handler_args *arg;
3549         char peer_obj_path[WPAS_DBUS_OBJECT_PATH_MAX];
3550
3551         /* Do nothing if the control interface is not turned on */
3552         if (wpa_s == NULL || wpa_s->global == NULL)
3553                 return 0;
3554
3555         ctrl_iface = wpa_s->global->dbus;
3556         if (ctrl_iface == NULL)
3557                 return 0;
3558
3559         wpa_s = wpa_s->parent->parent;
3560         if (!wpa_s->dbus_new_path)
3561                 return 0;
3562
3563         os_snprintf(peer_obj_path, WPAS_DBUS_OBJECT_PATH_MAX,
3564                     "%s/" WPAS_DBUS_NEW_P2P_PEERS_PART "/" COMPACT_MACSTR,
3565                     wpa_s->dbus_new_path, MAC2STR(dev_addr));
3566
3567         wpa_printf(MSG_INFO, "dbus: Register peer object '%s'",
3568                    peer_obj_path);
3569         obj_desc = os_zalloc(sizeof(struct wpa_dbus_object_desc));
3570         if (!obj_desc) {
3571                 wpa_printf(MSG_ERROR,
3572                            "Not enough memory to create object description");
3573                 goto err;
3574         }
3575
3576         /* allocate memory for handlers arguments */
3577         arg = os_zalloc(sizeof(struct peer_handler_args));
3578         if (!arg) {
3579                 wpa_printf(MSG_ERROR,
3580                            "Not enough memory to create arguments for method");
3581                 goto err;
3582         }
3583
3584         arg->wpa_s = wpa_s;
3585         os_memcpy(arg->p2p_device_addr, dev_addr, ETH_ALEN);
3586
3587         wpas_dbus_register(obj_desc, arg, wpa_dbus_free,
3588                            NULL,
3589                            wpas_dbus_p2p_peer_properties,
3590                            wpas_dbus_p2p_peer_signals);
3591
3592         if (wpa_dbus_register_object_per_iface(ctrl_iface, peer_obj_path,
3593                                                wpa_s->ifname, obj_desc))
3594                 goto err;
3595
3596         return 0;
3597
3598 err:
3599         free_dbus_object_desc(obj_desc);
3600         return -1;
3601 }
3602
3603 /**
3604  * wpas_dbus_unregister_peer - Unregister a peer object with dbus
3605  * @wpa_s: wpa_supplicant interface structure
3606  * @dev_addr: p2p device addr
3607  * Returns: 0 on success, -1 on failure
3608  *
3609  * Registers network representing object with dbus
3610  */
3611 int wpas_dbus_unregister_peer(struct wpa_supplicant *wpa_s,
3612                                   const u8 *dev_addr)
3613 {
3614         struct wpas_dbus_priv *ctrl_iface;
3615         char peer_obj_path[WPAS_DBUS_OBJECT_PATH_MAX];
3616         int ret;
3617
3618         /* Do nothing if the control interface is not turned on */
3619         if (wpa_s == NULL || wpa_s->global == NULL)
3620                 return 0;
3621
3622         wpa_s = wpa_s->parent->parent;
3623         if (!wpa_s->dbus_new_path)
3624                 return 0;
3625
3626         ctrl_iface = wpa_s->global->dbus;
3627         if (ctrl_iface == NULL)
3628                 return 0;
3629
3630         os_snprintf(peer_obj_path, WPAS_DBUS_OBJECT_PATH_MAX,
3631                     "%s/" WPAS_DBUS_NEW_P2P_PEERS_PART "/" COMPACT_MACSTR,
3632                     wpa_s->dbus_new_path, MAC2STR(dev_addr));
3633
3634         wpa_printf(MSG_INFO, "dbus: Unregister peer object '%s'",
3635                    peer_obj_path);
3636         ret = wpa_dbus_unregister_object_per_iface(ctrl_iface, peer_obj_path);
3637
3638         return ret;
3639 }
3640
3641
3642 /**
3643  * wpas_dbus_signal_p2p_find_stopped - Send P2P Find stopped signal
3644  * @wpa_s: %wpa_supplicant network interface data
3645  *
3646  * Notify listeners about P2P Find stopped
3647  */
3648 void wpas_dbus_signal_p2p_find_stopped(struct wpa_supplicant *wpa_s)
3649 {
3650         struct wpas_dbus_priv *iface;
3651         DBusMessage *msg;
3652
3653         iface = wpa_s->global->dbus;
3654
3655         /* Do nothing if the control interface is not turned on */
3656         if (iface == NULL || !wpa_s->dbus_new_path)
3657                 return;
3658
3659         msg = dbus_message_new_signal(wpa_s->dbus_new_path,
3660                                       WPAS_DBUS_NEW_IFACE_P2PDEVICE,
3661                                       "FindStopped");
3662         if (msg == NULL)
3663                 return;
3664
3665         dbus_connection_send(iface->con, msg, NULL);
3666
3667         dbus_message_unref(msg);
3668 }
3669
3670
3671 /**
3672  * wpas_dbus_signal_peer_groups_changed - Send peer group change property signal
3673  * @wpa_s: %wpa_supplicant network interface data
3674  * @dev_addr: P2P Device Address
3675  *
3676  * Notify listeners about peer Groups property changes.
3677  */
3678 void wpas_dbus_signal_peer_groups_changed(struct wpa_supplicant *wpa_s,
3679                                           const u8 *dev_addr)
3680 {
3681         char peer_obj_path[WPAS_DBUS_OBJECT_PATH_MAX];
3682
3683         if (wpa_s->p2p_mgmt)
3684                 wpa_s = wpa_s->parent;
3685
3686         if (!wpa_s->dbus_new_path)
3687                 return;
3688         os_snprintf(peer_obj_path, WPAS_DBUS_OBJECT_PATH_MAX,
3689                     "%s/" WPAS_DBUS_NEW_P2P_PEERS_PART "/" COMPACT_MACSTR,
3690                     wpa_s->dbus_new_path, MAC2STR(dev_addr));
3691
3692         wpa_dbus_mark_property_changed(wpa_s->global->dbus, peer_obj_path,
3693                                        WPAS_DBUS_NEW_IFACE_P2P_PEER, "Groups");
3694 }
3695
3696
3697 static const struct wpa_dbus_property_desc wpas_dbus_p2p_group_properties[] = {
3698         { "Members", WPAS_DBUS_NEW_IFACE_P2P_GROUP, "ao",
3699           wpas_dbus_getter_p2p_group_members,
3700           NULL
3701         },
3702         { "Group", WPAS_DBUS_NEW_IFACE_P2P_GROUP, "o",
3703           wpas_dbus_getter_p2p_group,
3704           NULL
3705         },
3706         { "Role", WPAS_DBUS_NEW_IFACE_P2P_GROUP, "s",
3707           wpas_dbus_getter_p2p_role,
3708           NULL
3709         },
3710         { "SSID", WPAS_DBUS_NEW_IFACE_P2P_GROUP, "ay",
3711           wpas_dbus_getter_p2p_group_ssid,
3712           NULL
3713         },
3714         { "BSSID", WPAS_DBUS_NEW_IFACE_P2P_GROUP, "ay",
3715           wpas_dbus_getter_p2p_group_bssid,
3716           NULL
3717         },
3718         { "Frequency", WPAS_DBUS_NEW_IFACE_P2P_GROUP, "q",
3719           wpas_dbus_getter_p2p_group_frequency,
3720           NULL
3721         },
3722         { "Passphrase", WPAS_DBUS_NEW_IFACE_P2P_GROUP, "s",
3723           wpas_dbus_getter_p2p_group_passphrase,
3724           NULL
3725         },
3726         { "PSK", WPAS_DBUS_NEW_IFACE_P2P_GROUP, "ay",
3727           wpas_dbus_getter_p2p_group_psk,
3728           NULL
3729         },
3730         { "WPSVendorExtensions", WPAS_DBUS_NEW_IFACE_P2P_GROUP, "aay",
3731           wpas_dbus_getter_p2p_group_vendor_ext,
3732           wpas_dbus_setter_p2p_group_vendor_ext
3733         },
3734         { NULL, NULL, NULL, NULL, NULL }
3735 };
3736
3737 static const struct wpa_dbus_signal_desc wpas_dbus_p2p_group_signals[] = {
3738         { "PeerJoined", WPAS_DBUS_NEW_IFACE_P2P_GROUP,
3739           {
3740                   { "peer", "o", ARG_OUT },
3741                   END_ARGS
3742           }
3743         },
3744         { "PeerDisconnected", WPAS_DBUS_NEW_IFACE_P2P_GROUP,
3745           {
3746                   { "peer", "o", ARG_OUT },
3747                   END_ARGS
3748           }
3749         },
3750         { NULL, NULL, { END_ARGS } }
3751 };
3752
3753 /**
3754  * wpas_dbus_register_p2p_group - Register a p2p group object with dbus
3755  * @wpa_s: wpa_supplicant interface structure
3756  * @ssid: SSID struct
3757  * Returns: 0 on success, -1 on failure
3758  *
3759  * Registers p2p group representing object with dbus
3760  */
3761 void wpas_dbus_register_p2p_group(struct wpa_supplicant *wpa_s,
3762                                   struct wpa_ssid *ssid)
3763 {
3764         struct wpas_dbus_priv *ctrl_iface;
3765         struct wpa_dbus_object_desc *obj_desc;
3766         char group_obj_path[WPAS_DBUS_OBJECT_PATH_MAX];
3767
3768         /* Do nothing if the control interface is not turned on */
3769         if (wpa_s == NULL || wpa_s->global == NULL)
3770                 return;
3771
3772         ctrl_iface = wpa_s->global->dbus;
3773         if (ctrl_iface == NULL)
3774                 return;
3775
3776         if (wpa_s->dbus_groupobj_path) {
3777                 wpa_printf(MSG_INFO, "%s: Group object '%s' already exists",
3778                            __func__, wpa_s->dbus_groupobj_path);
3779                 return;
3780         }
3781
3782         if (wpas_dbus_get_group_obj_path(wpa_s, ssid, group_obj_path) < 0)
3783                 return;
3784
3785         wpa_s->dbus_groupobj_path = os_strdup(group_obj_path);
3786         if (wpa_s->dbus_groupobj_path == NULL)
3787                 return;
3788
3789         wpa_printf(MSG_INFO, "dbus: Register group object '%s'",
3790                    group_obj_path);
3791         obj_desc = os_zalloc(sizeof(struct wpa_dbus_object_desc));
3792         if (!obj_desc) {
3793                 wpa_printf(MSG_ERROR,
3794                            "Not enough memory to create object description");
3795                 goto err;
3796         }
3797
3798         wpas_dbus_register(obj_desc, wpa_s, NULL, NULL,
3799                            wpas_dbus_p2p_group_properties,
3800                            wpas_dbus_p2p_group_signals);
3801
3802         if (wpa_dbus_register_object_per_iface(ctrl_iface, group_obj_path,
3803                                                wpa_s->ifname, obj_desc))
3804                 goto err;
3805
3806         return;
3807
3808 err:
3809         if (wpa_s->dbus_groupobj_path) {
3810                 os_free(wpa_s->dbus_groupobj_path);
3811                 wpa_s->dbus_groupobj_path = NULL;
3812         }
3813
3814         free_dbus_object_desc(obj_desc);
3815 }
3816
3817 /**
3818  * wpas_dbus_unregister_p2p_group - Unregister a p2p group object from dbus
3819  * @wpa_s: wpa_supplicant interface structure
3820  * @ssid: network name of the p2p group started
3821  */
3822 void wpas_dbus_unregister_p2p_group(struct wpa_supplicant *wpa_s,
3823                                     const struct wpa_ssid *ssid)
3824 {
3825         struct wpas_dbus_priv *ctrl_iface;
3826
3827         /* Do nothing if the control interface is not turned on */
3828         if (wpa_s == NULL || wpa_s->global == NULL)
3829                 return;
3830
3831         if (wpa_s->p2p_mgmt)
3832                 wpa_s = wpa_s->parent;
3833
3834         ctrl_iface = wpa_s->global->dbus;
3835         if (ctrl_iface == NULL)
3836                 return;
3837
3838         if (!wpa_s->dbus_groupobj_path) {
3839                 wpa_printf(MSG_DEBUG,
3840                            "%s: Group object '%s' already unregistered",
3841                            __func__, wpa_s->dbus_groupobj_path);
3842                 return;
3843         }
3844
3845         peer_groups_changed(wpa_s);
3846
3847         wpa_printf(MSG_DEBUG, "dbus: Unregister group object '%s'",
3848                    wpa_s->dbus_groupobj_path);
3849
3850         wpa_dbus_unregister_object_per_iface(ctrl_iface,
3851                                              wpa_s->dbus_groupobj_path);
3852
3853         os_free(wpa_s->dbus_groupobj_path);
3854         wpa_s->dbus_groupobj_path = NULL;
3855 }
3856
3857 static const struct wpa_dbus_property_desc
3858         wpas_dbus_persistent_group_properties[] = {
3859         { "Properties", WPAS_DBUS_NEW_IFACE_PERSISTENT_GROUP, "a{sv}",
3860           wpas_dbus_getter_persistent_group_properties,
3861           wpas_dbus_setter_persistent_group_properties
3862         },
3863         { NULL, NULL, NULL, NULL, NULL }
3864 };
3865
3866 /* No signals intended for persistent group objects */
3867
3868 /**
3869  * wpas_dbus_register_persistent_group - Register a configured(saved)
3870  *      persistent group with dbus
3871  * @wpa_s: wpa_supplicant interface structure
3872  * @ssid: persistent group (still represented as a network within wpa)
3873  *        configuration data
3874  * Returns: 0 on success, -1 on failure
3875  *
3876  * Registers a persistent group representing object with dbus.
3877  */
3878 int wpas_dbus_register_persistent_group(struct wpa_supplicant *wpa_s,
3879                                         struct wpa_ssid *ssid)
3880 {
3881         struct wpas_dbus_priv *ctrl_iface;
3882         struct wpa_dbus_object_desc *obj_desc;
3883         struct network_handler_args *arg;
3884         char pgrp_obj_path[WPAS_DBUS_OBJECT_PATH_MAX];
3885
3886         /* Do nothing if the control interface is not turned on */
3887         if (wpa_s == NULL || wpa_s->global == NULL)
3888                 return 0;
3889         wpa_s = wpa_s->parent->parent;
3890         if (!wpa_s->dbus_new_path)
3891                 return 0;
3892
3893         /* Make sure ssid is a persistent group */
3894         if (ssid->disabled != 2 && !ssid->p2p_persistent_group)
3895                 return -1; /* should we return w/o complaining? */
3896
3897         if (wpa_s->p2p_mgmt)
3898                 wpa_s = wpa_s->parent;
3899
3900         ctrl_iface = wpa_s->global->dbus;
3901         if (ctrl_iface == NULL)
3902                 return 0;
3903
3904         /*
3905          * Intentionally not coming up with different numbering scheme
3906          * for persistent groups.
3907          */
3908         os_snprintf(pgrp_obj_path, WPAS_DBUS_OBJECT_PATH_MAX,
3909                     "%s/" WPAS_DBUS_NEW_PERSISTENT_GROUPS_PART "/%u",
3910                     wpa_s->dbus_new_path, ssid->id);
3911
3912         wpa_printf(MSG_DEBUG, "dbus: Register persistent group object '%s'",
3913                    pgrp_obj_path);
3914         obj_desc = os_zalloc(sizeof(struct wpa_dbus_object_desc));
3915         if (!obj_desc) {
3916                 wpa_printf(MSG_ERROR,
3917                            "dbus: Not enough memory to create object description");
3918                 goto err;
3919         }
3920
3921         /*
3922          * Reusing the same context structure as that for networks
3923          * since these are represented using same data structure.
3924          */
3925         /* allocate memory for handlers arguments */
3926         arg = os_zalloc(sizeof(struct network_handler_args));
3927         if (!arg) {
3928                 wpa_printf(MSG_ERROR,
3929                            "dbus: Not enough memory to create arguments for method");
3930                 goto err;
3931         }
3932
3933         arg->wpa_s = wpa_s;
3934         arg->ssid = ssid;
3935
3936         wpas_dbus_register(obj_desc, arg, wpa_dbus_free, NULL,
3937                            wpas_dbus_persistent_group_properties,
3938                            NULL);
3939
3940         if (wpa_dbus_register_object_per_iface(ctrl_iface, pgrp_obj_path,
3941                                                wpa_s->ifname, obj_desc))
3942                 goto err;
3943
3944         wpas_dbus_signal_persistent_group_added(wpa_s, ssid->id);
3945
3946         return 0;
3947
3948 err:
3949         free_dbus_object_desc(obj_desc);
3950         return -1;
3951 }
3952
3953
3954 /**
3955  * wpas_dbus_unregister_persistent_group - Unregister a persistent_group
3956  *      from dbus
3957  * @wpa_s: wpa_supplicant interface structure
3958  * @nid: network id
3959  * Returns: 0 on success, -1 on failure
3960  *
3961  * Unregisters persistent group representing object from dbus
3962  *
3963  * NOTE: There is a slight issue with the semantics here. While the
3964  * implementation simply means the persistent group is unloaded from memory,
3965  * it should not get interpreted as the group is actually being erased/removed
3966  * from persistent storage as well.
3967  */
3968 int wpas_dbus_unregister_persistent_group(struct wpa_supplicant *wpa_s,
3969                                           int nid)
3970 {
3971         struct wpas_dbus_priv *ctrl_iface;
3972         char pgrp_obj_path[WPAS_DBUS_OBJECT_PATH_MAX];
3973         int ret;
3974
3975         /* Do nothing if the control interface is not turned on */
3976         if (wpa_s == NULL || wpa_s->global == NULL)
3977                 return 0;
3978
3979         wpa_s = wpa_s->parent->parent;
3980
3981         ctrl_iface = wpa_s->global->dbus;
3982         if (ctrl_iface == NULL || !wpa_s->dbus_new_path)
3983                 return 0;
3984
3985         os_snprintf(pgrp_obj_path, WPAS_DBUS_OBJECT_PATH_MAX,
3986                     "%s/" WPAS_DBUS_NEW_PERSISTENT_GROUPS_PART "/%u",
3987                     wpa_s->dbus_new_path, nid);
3988
3989         wpa_printf(MSG_DEBUG, "dbus: Unregister persistent group object '%s'",
3990                    pgrp_obj_path);
3991         ret = wpa_dbus_unregister_object_per_iface(ctrl_iface, pgrp_obj_path);
3992
3993         if (!ret)
3994                 wpas_dbus_signal_persistent_group_removed(wpa_s, nid);
3995
3996         return ret;
3997 }
3998
3999 #endif /* CONFIG_P2P */