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