/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
* Copyright (C) 2017 Intel Corporation
*/
#include "src/core/nm-default-daemon.h"
#include "nm-device-iwd.h"
#include <linux/if_ether.h>
#include "devices/nm-device-private.h"
#include "devices/nm-device.h"
#include "nm-act-request.h"
#include "nm-config.h"
#include "nm-core-internal.h"
#include "nm-dbus-manager.h"
#include "nm-glib-aux/nm-ref-string.h"
#include "nm-iwd-manager.h"
#include "nm-libnm-core-intern/nm-common-macros.h"
#include "nm-setting-8021x.h"
#include "nm-setting-connection.h"
#include "nm-setting-wireless-security.h"
#include "nm-setting-wireless.h"
#include "nm-std-aux/nm-dbus-compat.h"
#include "nm-utils.h"
#include "nm-wifi-common.h"
#include "nm-wifi-utils.h"
#include "settings/nm-settings-connection.h"
#include "settings/nm-settings.h"
#include "supplicant/nm-supplicant-types.h"
#include "nm-auth-utils.h"
#include "nm-manager.h"
#define _NMLOG_DEVICE_TYPE NMDeviceIwd
#include "devices/nm-device-logging.h"
/*****************************************************************************/
NM_GOBJECT_PROPERTIES_DEFINE(NMDeviceIwd,
PROP_MODE,
PROP_BITRATE,
PROP_ACCESS_POINTS,
PROP_ACTIVE_ACCESS_POINT,
PROP_CAPABILITIES,
PROP_SCANNING,
PROP_LAST_SCAN, );
typedef struct {
GDBusObject * dbus_obj;
GDBusProxy * dbus_device_proxy;
GDBusProxy * dbus_station_proxy;
GDBusProxy * dbus_ap_proxy;
GDBusProxy * dbus_adhoc_proxy;
CList aps_lst_head;
NMWifiAP * current_ap;
GCancellable * cancellable;
NMDeviceWifiCapabilities capabilities;
NMActRequestGetSecretsCallId *wifi_secrets_id;
guint periodic_scan_id;
guint periodic_update_id;
bool enabled : 1;
bool can_scan : 1;
bool nm_autoconnect : 1;
bool iwd_autoconnect : 1;
bool scanning : 1;
bool scan_requested : 1;
bool act_mode_switch : 1;
bool secrets_failed : 1;
bool networks_requested : 1;
bool networks_changed : 1;
gint64 last_scan;
uint32_t ap_id;
guint32 rate;
NMEtherAddr current_ap_bssid;
GDBusMethodInvocation * pending_agent_request;
NMActiveConnection * assumed_ac;
guint assumed_ac_timeout;
} NMDeviceIwdPrivate;
struct _NMDeviceIwd {
NMDevice parent;
NMDeviceIwdPrivate _priv;
};
struct _NMDeviceIwdClass {
NMDeviceClass parent;
};
/*****************************************************************************/
G_DEFINE_TYPE(NMDeviceIwd, nm_device_iwd, NM_TYPE_DEVICE)
#define NM_DEVICE_IWD_GET_PRIVATE(self) \
_NM_GET_PRIVATE(self, NMDeviceIwd, NM_IS_DEVICE_IWD, NMDevice)
/*****************************************************************************/
static void schedule_periodic_scan(NMDeviceIwd *self, gboolean initial_scan);
static gboolean check_scanning_prohibited(NMDeviceIwd *self, gboolean periodic);
/*****************************************************************************/
static void
_ap_dump(NMDeviceIwd *self, NMLogLevel log_level, const NMWifiAP *ap, const char *prefix)
{
char buf[1024];
buf[0] = '\0';
_NMLOG(log_level,
LOGD_WIFI_SCAN,
"wifi-ap: %-7s %s",
prefix,
nm_wifi_ap_to_string(ap, buf, sizeof(buf), 0));
}
/* Callers ensure we're not removing current_ap */
static void
ap_add_remove(NMDeviceIwd *self,
gboolean is_adding, /* or else is removing */
NMWifiAP * ap,
gboolean recheck_available_connections)
{
NMDeviceIwdPrivate *priv = NM_DEVICE_IWD_GET_PRIVATE(self);
if (is_adding) {
g_object_ref(ap);
ap->wifi_device = NM_DEVICE(self);
c_list_link_tail(&priv->aps_lst_head, &ap->aps_lst);
nm_dbus_object_export(NM_DBUS_OBJECT(ap));
_ap_dump(self, LOGL_DEBUG, ap, "added");
nm_device_wifi_emit_signal_access_point(NM_DEVICE(self), ap, TRUE);
} else {
ap->wifi_device = NULL;
c_list_unlink(&ap->aps_lst);
_ap_dump(self, LOGL_DEBUG, ap, "removed");
}
_notify(self, PROP_ACCESS_POINTS);
if (!is_adding) {
nm_device_wifi_emit_signal_access_point(NM_DEVICE(self), ap, FALSE);
nm_dbus_object_clear_and_unexport(&ap);
}
if (priv->enabled && !priv->iwd_autoconnect)
nm_device_emit_recheck_auto_activate(NM_DEVICE(self));
if (recheck_available_connections)
nm_device_recheck_available_connections(NM_DEVICE(self));
}
static void
set_current_ap(NMDeviceIwd *self, NMWifiAP *new_ap, gboolean recheck_available_connections)
{
NMDeviceIwdPrivate *priv;
NMWifiAP * old_ap;
g_return_if_fail(NM_IS_DEVICE_IWD(self));
priv = NM_DEVICE_IWD_GET_PRIVATE(self);
old_ap = priv->current_ap;
if (old_ap == new_ap)
return;
if (new_ap)
priv->current_ap = g_object_ref(new_ap);
else
priv->current_ap = NULL;
if (old_ap) {
if (nm_wifi_ap_get_fake(old_ap))
ap_add_remove(self, FALSE, old_ap, recheck_available_connections);
g_object_unref(old_ap);
}
memset(&priv->current_ap_bssid, 0, ETH_ALEN);
_notify(self, PROP_ACTIVE_ACCESS_POINT);
_notify(self, PROP_MODE);
}
static void
remove_all_aps(NMDeviceIwd *self)
{
NMDeviceIwdPrivate *priv = NM_DEVICE_IWD_GET_PRIVATE(self);
NMWifiAP * ap, *ap_safe;
if (c_list_is_empty(&priv->aps_lst_head))
return;
c_list_for_each_entry_safe (ap, ap_safe, &priv->aps_lst_head, aps_lst)
ap_add_remove(self, FALSE, ap, FALSE);
if (!priv->iwd_autoconnect)
nm_device_emit_recheck_auto_activate(NM_DEVICE(self));
nm_device_recheck_available_connections(NM_DEVICE(self));
}
static NM80211ApSecurityFlags
ap_security_flags_from_network_type(const char *type)
{
NM80211ApSecurityFlags flags;
if (nm_streq(type, "psk"))
flags = NM_802_11_AP_SEC_KEY_MGMT_PSK;
else if (nm_streq(type, "8021x"))
flags = NM_802_11_AP_SEC_KEY_MGMT_802_1X;
else
return NM_802_11_AP_SEC_NONE;
flags |= NM_802_11_AP_SEC_PAIR_CCMP;
flags |= NM_802_11_AP_SEC_GROUP_CCMP;
return flags;
}
static NMWifiAP *
ap_from_network(NMDeviceIwd *self,
GDBusProxy * network,
NMRefString *bss_path,
gint64 last_seen_msec,
int16_t signal)
{
NMDeviceIwdPrivate *priv = NM_DEVICE_IWD_GET_PRIVATE(self);
gs_unref_variant GVariant *name_value = NULL;
gs_unref_variant GVariant *type_value = NULL;
const char * name;
const char * type;
uint32_t ap_id;
gs_unref_bytes GBytes *ssid = NULL;
NMWifiAP * ap;
NMSupplicantBssInfo bss_info;
g_return_val_if_fail(network, NULL);
name_value = g_dbus_proxy_get_cached_property(network, "Name");
type_value = g_dbus_proxy_get_cached_property(network, "Type");
if (!name_value || !g_variant_is_of_type(name_value, G_VARIANT_TYPE_STRING) || !type_value
|| !g_variant_is_of_type(type_value, G_VARIANT_TYPE_STRING))
return NULL;
name = g_variant_get_string(name_value, NULL);
type = g_variant_get_string(type_value, NULL);
if (nm_streq(type, "wep")) {
/* WEP not supported */
return NULL;
}
/* What we get from IWD are networks, or ESSs, that may contain
* multiple APs, or BSSs, each. We don't get information about any
* specific BSSs within an ESS but we can safely present each ESS
* as an individual BSS to NM, which will be seen as ESSs comprising
* a single BSS each. NM won't be able to handle roaming but IWD
* already does that. We fake the BSSIDs as they don't play any
* role either.
*/
ap_id = priv->ap_id++;
ssid = g_bytes_new(name, NM_MIN(32u, strlen(name)));
bss_info = (NMSupplicantBssInfo){
.bss_path = bss_path,
.last_seen_msec = last_seen_msec,
.bssid_valid = TRUE,
.mode = NM_802_11_MODE_INFRA,
.rsn_flags = ap_security_flags_from_network_type(type),
.ssid = ssid,
.signal_percent = nm_wifi_utils_level_to_quality(signal / 100),
.frequency = 2417,
.max_rate = 65000,
.bssid = NM_ETHER_ADDR_INIT(0x00, 0x01, 0x02, ap_id >> 16, ap_id >> 8, ap_id),
};
ap = nm_wifi_ap_new_from_properties(&bss_info);
nm_assert(bss_path == nm_wifi_ap_get_supplicant_path(ap));
return ap;
}
static void
insert_ap_from_network(NMDeviceIwd *self,
GHashTable * aps,
const char * path,
gint64 last_seen_msec,
int16_t signal)
{
gs_unref_object GDBusProxy *network_proxy = NULL;
nm_auto_ref_string NMRefString *bss_path = nm_ref_string_new(path);
NMWifiAP * ap;
if (g_hash_table_lookup(aps, bss_path)) {
_LOGD(LOGD_WIFI, "Duplicate network at %s", path);
return;
}
network_proxy =
nm_iwd_manager_get_dbus_interface(nm_iwd_manager_get(), path, NM_IWD_NETWORK_INTERFACE);
ap = ap_from_network(self, network_proxy, bss_path, last_seen_msec, signal);
if (!ap)
return;
g_hash_table_insert(aps, bss_path, ap);
}
static void
get_ordered_networks_cb(GObject *source, GAsyncResult *res, gpointer user_data)
{
NMDeviceIwd * self = user_data;
NMDeviceIwdPrivate *priv;
gs_free_error GError *error = NULL;
gs_unref_variant GVariant *variant = NULL;
GVariantIter * networks;
const char * path;
int16_t signal;
NMWifiAP * ap, *ap_safe, *new_ap;
gboolean changed;
GHashTableIter ap_iter;
gs_unref_hashtable GHashTable *new_aps = NULL;
gint64 last_seen_msec;
variant = g_dbus_proxy_call_finish(G_DBUS_PROXY(source), res, &error);
if (!variant && nm_utils_error_is_cancelled(error))
return;
priv = NM_DEVICE_IWD_GET_PRIVATE(self);
priv->networks_requested = FALSE;
if (!variant) {
_LOGE(LOGD_WIFI, "Station.GetOrderedNetworks failed: %s", error->message);
return;
}
if (!g_variant_is_of_type(variant, G_VARIANT_TYPE("(a(on))"))) {
_LOGE(LOGD_WIFI,
"Station.GetOrderedNetworks returned type %s instead of (a(on))",
g_variant_get_type_string(variant));
return;
}
new_aps = g_hash_table_new_full(nm_direct_hash, NULL, NULL, g_object_unref);
g_variant_get(variant, "(a(on))", &networks);
last_seen_msec = nm_utils_get_monotonic_timestamp_msec();
while (g_variant_iter_next(networks, "(&on)", &path, &signal))
insert_ap_from_network(self, new_aps, path, last_seen_msec, signal);
g_variant_iter_free(networks);
changed = priv->networks_changed;
priv->networks_changed = FALSE;
c_list_for_each_entry_safe (ap, ap_safe, &priv->aps_lst_head, aps_lst) {
new_ap = g_hash_table_lookup(new_aps, nm_wifi_ap_get_supplicant_path(ap));
if (new_ap) {
if (nm_wifi_ap_set_strength(ap, nm_wifi_ap_get_strength(new_ap))) {
_ap_dump(self, LOGL_TRACE, ap, "updated");
changed = TRUE;
}
g_hash_table_remove(new_aps, nm_wifi_ap_get_supplicant_path(ap));
continue;
}
if (ap == priv->current_ap) {
/* Normally IWD will prevent the current AP from being
* removed from the list and set a low signal strength,
* but just making sure.
*/
continue;
}
ap_add_remove(self, FALSE, ap, FALSE);
changed = TRUE;
}
g_hash_table_iter_init(&ap_iter, new_aps);
while (g_hash_table_iter_next(&ap_iter, NULL, (gpointer) &ap)) {
ap_add_remove(self, TRUE, ap, FALSE);
g_hash_table_iter_remove(&ap_iter);
changed = TRUE;
}
if (changed) {
if (!priv->iwd_autoconnect)
nm_device_emit_recheck_auto_activate(NM_DEVICE(self));
nm_device_recheck_available_connections(NM_DEVICE(self));
}
}
static void
update_aps(NMDeviceIwd *self)
{
NMDeviceIwdPrivate *priv = NM_DEVICE_IWD_GET_PRIVATE(self);
if (!priv->cancellable)
priv->cancellable = g_cancellable_new();
g_dbus_proxy_call(priv->dbus_station_proxy,
"GetOrderedNetworks",
NULL,
G_DBUS_CALL_FLAGS_NONE,
2000,
priv->cancellable,
get_ordered_networks_cb,
self);
priv->networks_requested = TRUE;
}
static void
periodic_update(NMDeviceIwd *self)
{
NMDeviceIwdPrivate *priv = NM_DEVICE_IWD_GET_PRIVATE(self);
int ifindex;
guint32 new_rate;
int percent;
NMEtherAddr bssid;
gboolean ap_changed = FALSE;
NMPlatform * platform;
ifindex = nm_device_get_ifindex(NM_DEVICE(self));
if (ifindex <= 0)
g_return_if_reached();
platform = nm_device_get_platform(NM_DEVICE(self));
/* TODO: obtain quality through the net.connman.iwd.SignalLevelAgent API.
* For now we're waking up for the rate/BSSID updates anyway.
*/
if (!nm_platform_wifi_get_station(platform, ifindex, &bssid, &percent, &new_rate)) {
_LOGD(LOGD_WIFI, "BSSID / quality / rate platform query failed");
return;
}
if (nm_wifi_ap_set_strength(priv->current_ap, (gint8) percent)) {
#if NM_MORE_LOGGING
ap_changed = TRUE;
#endif
}
if (new_rate != priv->rate) {
priv->rate = new_rate;
_notify(self, PROP_BITRATE);
}
if (nm_ether_addr_is_valid(&bssid) && !nm_ether_addr_equal(&bssid, &priv->current_ap_bssid)) {
priv->current_ap_bssid = bssid;
ap_changed |= nm_wifi_ap_set_address_bin(priv->current_ap, &bssid);
ap_changed |= nm_wifi_ap_set_freq(priv->current_ap,
nm_platform_wifi_get_frequency(platform, ifindex));
}
if (ap_changed)
_ap_dump(self, LOGL_DEBUG, priv->current_ap, "updated");
}
static gboolean
periodic_update_cb(gpointer user_data)
{
periodic_update(user_data);
return TRUE;
}
static void
send_disconnect(NMDeviceIwd *self)
{
NMDeviceIwdPrivate *priv = NM_DEVICE_IWD_GET_PRIVATE(self);
g_dbus_proxy_call(priv->dbus_station_proxy,
"Disconnect",
NULL,
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
NULL,
NULL);
}
static void
wifi_secrets_cancel(NMDeviceIwd *self)
{
NMDeviceIwdPrivate *priv = NM_DEVICE_IWD_GET_PRIVATE(self);
if (priv->wifi_secrets_id)
nm_act_request_cancel_secrets(NULL, priv->wifi_secrets_id);
nm_assert(!priv->wifi_secrets_id);
if (priv->pending_agent_request) {
g_dbus_method_invocation_return_error_literal(priv->pending_agent_request,
NM_DEVICE_ERROR,
NM_DEVICE_ERROR_INVALID_CONNECTION,
"NM secrets request cancelled");
g_clear_object(&priv->pending_agent_request);
}
}
static void
cleanup_assumed_connect(NMDeviceIwd *self)
{
NMDeviceIwdPrivate *priv = NM_DEVICE_IWD_GET_PRIVATE(self);
if (!priv->assumed_ac)
return;
g_signal_handlers_disconnect_by_data(priv->assumed_ac, self);
g_clear_object(&priv->assumed_ac);
}
static void
cleanup_association_attempt(NMDeviceIwd *self, gboolean disconnect)
{
NMDeviceIwdPrivate *priv = NM_DEVICE_IWD_GET_PRIVATE(self);
cleanup_assumed_connect(self);
wifi_secrets_cancel(self);
set_current_ap(self, NULL, TRUE);
nm_clear_g_source(&priv->periodic_update_id);
nm_clear_g_source(&priv->assumed_ac_timeout);
if (disconnect && priv->dbus_station_proxy)
send_disconnect(self);
}
static void
reset_mode(NMDeviceIwd * self,
GCancellable * cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
NMDeviceIwdPrivate *priv = NM_DEVICE_IWD_GET_PRIVATE(self);
g_dbus_proxy_call(
priv->dbus_device_proxy,
DBUS_INTERFACE_PROPERTIES ".Set",
g_variant_new("(ssv)", NM_IWD_DEVICE_INTERFACE, "Mode", g_variant_new_string("station")),
G_DBUS_CALL_FLAGS_NONE,
2000,
cancellable,
callback,
user_data);
}
static gboolean
get_variant_boolean(GVariant *v, const char *property)
{
if (!v || !g_variant_is_of_type(v, G_VARIANT_TYPE_BOOLEAN)) {
nm_log_warn(LOGD_DEVICE | LOGD_WIFI,
"Property %s not cached or not boolean type",
property);
return FALSE;
}
return g_variant_get_boolean(v);
}
static const char *
get_variant_state(GVariant *v)
{
if (!v || !g_variant_is_of_type(v, G_VARIANT_TYPE_STRING)) {
nm_log_warn(LOGD_DEVICE | LOGD_WIFI, "State property not cached or not a string");
return "unknown";
}
return g_variant_get_string(v, NULL);
}
static void
deactivate(NMDevice *device)
{
NMDeviceIwd * self = NM_DEVICE_IWD(device);
NMDeviceIwdPrivate *priv = NM_DEVICE_IWD_GET_PRIVATE(self);
if (!priv->dbus_obj)
return;
if (priv->dbus_station_proxy) {
gs_unref_variant GVariant *value =
g_dbus_proxy_get_cached_property(priv->dbus_station_proxy, "State");
if (NM_IN_STRSET(get_variant_state(value), "disconnecting", "disconnected"))
return;
}
cleanup_association_attempt(self, TRUE);
priv->act_mode_switch = FALSE;
if (!priv->dbus_station_proxy)
reset_mode(self, NULL, NULL, NULL);
}
static void
disconnect_cb(GObject *source, GAsyncResult *res, gpointer user_data)
{
gs_unref_object NMDeviceIwd *self = NULL;
NMDeviceDeactivateCallback callback;
gpointer callback_user_data;
gs_unref_variant GVariant *variant = NULL;
gs_free_error GError *error = NULL;
nm_utils_user_data_unpack(user_data, &self, &callback, &callback_user_data);
variant = g_dbus_proxy_call_finish(G_DBUS_PROXY(source), res, &error);
callback(NM_DEVICE(self), error, callback_user_data);
}
static void
disconnect_cb_on_idle(gpointer user_data, GCancellable *cancellable)
{
gs_unref_object NMDeviceIwd *self = NULL;
NMDeviceDeactivateCallback callback;
gpointer callback_user_data;
gs_free_error GError *cancelled_error = NULL;
nm_utils_user_data_unpack(user_data, &self, &callback, &callback_user_data);
g_cancellable_set_error_if_cancelled(cancellable, &cancelled_error);
callback(NM_DEVICE(self), cancelled_error, callback_user_data);
}
static void
deactivate_async(NMDevice * device,
GCancellable * cancellable,
NMDeviceDeactivateCallback callback,
gpointer callback_user_data)
{
NMDeviceIwd * self = NM_DEVICE_IWD(device);
NMDeviceIwdPrivate *priv = NM_DEVICE_IWD_GET_PRIVATE(self);
gpointer user_data;
nm_assert(G_IS_CANCELLABLE(cancellable));
nm_assert(callback);
user_data = nm_utils_user_data_pack(g_object_ref(self), callback, callback_user_data);
if (!priv->dbus_obj) {
nm_utils_invoke_on_idle(cancellable, disconnect_cb_on_idle, user_data);
return;
}
cleanup_association_attempt(self, FALSE);
priv->act_mode_switch = FALSE;
if (priv->dbus_station_proxy) {
g_dbus_proxy_call(priv->dbus_station_proxy,
"Disconnect",
NULL,
G_DBUS_CALL_FLAGS_NONE,
-1,
cancellable,
disconnect_cb,
user_data);
} else
reset_mode(self, cancellable, disconnect_cb, user_data);
}
static gboolean
is_connection_known_network(NMConnection *connection)
{
NMIwdNetworkSecurity security;
gs_free char * ssid = NULL;
if (!nm_wifi_connection_get_iwd_ssid_and_security(connection, &ssid, &security))
return FALSE;
return nm_iwd_manager_is_known_network(nm_iwd_manager_get(), ssid, security);
}
static gboolean
is_ap_known_network(NMWifiAP *ap)
{
gs_unref_object GDBusProxy *network_proxy = NULL;
gs_unref_variant GVariant *known_network = NULL;
network_proxy =
nm_iwd_manager_get_dbus_interface(nm_iwd_manager_get(),
nm_ref_string_get_str(nm_wifi_ap_get_supplicant_path(ap)),
NM_IWD_NETWORK_INTERFACE);
if (!network_proxy)
return FALSE;
known_network = g_dbus_proxy_get_cached_property(network_proxy, "KnownNetwork");
return nm_g_variant_is_of_type(known_network, G_VARIANT_TYPE_OBJECT_PATH);
}
static gboolean
check_connection_compatible(NMDevice *device, NMConnection *connection, GError **error)
{
NMDeviceIwd * self = NM_DEVICE_IWD(device);
NMDeviceIwdPrivate * priv = NM_DEVICE_IWD_GET_PRIVATE(self);
NMSettingWireless * s_wireless;
const char * mac;
const char *const * mac_blacklist;
int i;
const char * perm_hw_addr;
const char * mode;
NMIwdNetworkSecurity security;
GBytes * ssid;
const guint8 * ssid_bytes;
gsize ssid_len;
if (!NM_DEVICE_CLASS(nm_device_iwd_parent_class)
->check_connection_compatible(device, connection, error))
return FALSE;
s_wireless = nm_connection_get_setting_wireless(connection);
/* complete_connection would be called (if at all) before this function
* so an SSID should always be set. IWD doesn't support non-UTF8 SSIDs
* (ignores BSSes with such SSIDs and has no way to represent them on
* DBus) so we can cut it short for connections with a non-UTF8 SSID.
*/
ssid = nm_setting_wireless_get_ssid(s_wireless);
if (!ssid)
return FALSE;
ssid_bytes = g_bytes_get_data(ssid, &ssid_len);
if (!g_utf8_validate((const char *) ssid_bytes, ssid_len, NULL)) {
nm_utils_error_set_literal(error,
NM_UTILS_ERROR_CONNECTION_AVAILABLE_INCOMPATIBLE,
"non-UTF-8 connection SSID not supported by IWD backend");
return FALSE;
}
perm_hw_addr = nm_device_get_permanent_hw_address(device);
mac = nm_setting_wireless_get_mac_address(s_wireless);
if (perm_hw_addr) {
if (mac && !nm_utils_hwaddr_matches(mac, -1, perm_hw_addr, -1)) {
nm_utils_error_set_literal(error,
NM_UTILS_ERROR_CONNECTION_AVAILABLE_INCOMPATIBLE,
"device MAC address does not match the profile");
return FALSE;
}
/* Check for MAC address blacklist */
mac_blacklist = nm_setting_wireless_get_mac_address_blacklist(s_wireless);
for (i = 0; mac_blacklist[i]; i++) {
nm_assert(nm_utils_hwaddr_valid(mac_blacklist[i], ETH_ALEN));
if (nm_utils_hwaddr_matches(mac_blacklist[i], -1, perm_hw_addr, -1)) {
nm_utils_error_set_literal(error,
NM_UTILS_ERROR_CONNECTION_AVAILABLE_TEMPORARY,
"MAC address blacklisted");
return FALSE;
}
}
} else if (mac) {
nm_utils_error_set_literal(error,
NM_UTILS_ERROR_CONNECTION_AVAILABLE_TEMPORARY,
"device has no valid MAC address as required by profile");
return FALSE;
}
if (!nm_wifi_connection_get_iwd_ssid_and_security(connection, NULL, &security)
|| security == NM_IWD_NETWORK_SECURITY_WEP) {
nm_utils_error_set_literal(error,
NM_UTILS_ERROR_CONNECTION_AVAILABLE_INCOMPATIBLE,
"connection authentication type not supported by IWD backend");
return FALSE;
}
mode = nm_setting_wireless_get_mode(s_wireless);
/* Hidden SSIDs only supported in client mode */
if (nm_setting_wireless_get_hidden(s_wireless)
&& !NM_IN_STRSET(mode, NULL, NM_SETTING_WIRELESS_MODE_INFRA)) {
nm_utils_error_set_literal(
error,
NM_UTILS_ERROR_CONNECTION_AVAILABLE_INCOMPATIBLE,
"non-infrastructure hidden networks not supported by the IWD backend");
return FALSE;
}
if (NM_IN_STRSET(mode, NULL, NM_SETTING_WIRELESS_MODE_INFRA)) {
/* 8021x networks can only be used if they've been provisioned on the IWD side and
* thus are Known Networks.
*/
if (security == NM_IWD_NETWORK_SECURITY_8021X) {
if (!is_connection_known_network(connection)) {
nm_utils_error_set_literal(error,
NM_UTILS_ERROR_CONNECTION_AVAILABLE_INCOMPATIBLE,
"802.1x connections must have IWD provisioning files");
return FALSE;
}
} else if (!NM_IN_SET(security,
NM_IWD_NETWORK_SECURITY_OPEN,
NM_IWD_NETWORK_SECURITY_PSK)) {
nm_utils_error_set_literal(error,
NM_UTILS_ERROR_CONNECTION_AVAILABLE_INCOMPATIBLE,
"IWD backend only supports Open, PSK and 802.1x network "
"authentication in Infrastructure mode");
return FALSE;
}
} else if (nm_streq(mode, NM_SETTING_WIRELESS_MODE_AP)) {
NMSettingWirelessSecurity *s_wireless_sec =
nm_connection_get_setting_wireless_security(connection);
if (!(priv->capabilities & NM_WIFI_DEVICE_CAP_AP)) {
nm_utils_error_set_literal(error,
NM_UTILS_ERROR_CONNECTION_AVAILABLE_INCOMPATIBLE,
"device does not support Access Point mode");
return FALSE;
}
if (!NM_IN_SET(security, NM_IWD_NETWORK_SECURITY_PSK) || !s_wireless_sec
|| !nm_streq0(nm_setting_wireless_security_get_key_mgmt(s_wireless_sec), "wpa-psk")) {
nm_utils_error_set_literal(error,
NM_UTILS_ERROR_CONNECTION_AVAILABLE_INCOMPATIBLE,
"IWD backend only supports PSK authentication in AP mode");
return FALSE;
}
} else if (nm_streq(mode, NM_SETTING_WIRELESS_MODE_ADHOC)) {
NMSettingWirelessSecurity *s_wireless_sec =
nm_connection_get_setting_wireless_security(connection);
if (!(priv->capabilities & NM_WIFI_DEVICE_CAP_ADHOC)) {
nm_utils_error_set_literal(error,
NM_UTILS_ERROR_CONNECTION_AVAILABLE_INCOMPATIBLE,
"device does not support Ad-Hoc mode");
return FALSE;
}
if (!NM_IN_SET(security, NM_IWD_NETWORK_SECURITY_OPEN, NM_IWD_NETWORK_SECURITY_PSK)
|| (s_wireless_sec
&& !nm_streq0(nm_setting_wireless_security_get_key_mgmt(s_wireless_sec),
"wpa-psk"))) {
nm_utils_error_set_literal(
error,
NM_UTILS_ERROR_CONNECTION_AVAILABLE_INCOMPATIBLE,
"IWD backend only supports Open and PSK authentication in Ad-Hoc mode");
return FALSE;
}
} else {
nm_utils_error_set(error,
NM_UTILS_ERROR_CONNECTION_AVAILABLE_INCOMPATIBLE,
"'%s' type profiles not supported by IWD backend",
mode);
return FALSE;
}
return TRUE;
}
static gboolean
check_connection_available(NMDevice * device,
NMConnection * connection,
NMDeviceCheckConAvailableFlags flags,
const char * specific_object,
GError ** error)
{
NMDeviceIwd * self = NM_DEVICE_IWD(device);
NMDeviceIwdPrivate * priv = NM_DEVICE_IWD_GET_PRIVATE(self);
NMSettingWireless * s_wifi;
const char * mode;
NMWifiAP * ap = NULL;
NMIwdNetworkSecurity security;
s_wifi = nm_connection_get_setting_wireless(connection);
g_return_val_if_fail(s_wifi, FALSE);
/* a connection that is available for a certain @specific_object, MUST
* also be available in general (without @specific_object). */
if (specific_object) {
ap = nm_wifi_ap_lookup_for_device(NM_DEVICE(self), specific_object);
if (!ap) {
nm_utils_error_set_literal(error,
NM_UTILS_ERROR_CONNECTION_AVAILABLE_TEMPORARY,
"requested access point not found");
return FALSE;
}
if (!nm_wifi_ap_check_compatible(ap, connection)) {
nm_utils_error_set_literal(error,
NM_UTILS_ERROR_CONNECTION_AVAILABLE_TEMPORARY,
"requested access point is not compatible with profile");
return FALSE;
}
}
/* AP and Ad-Hoc connections can be activated independent of the scan list */
mode = nm_setting_wireless_get_mode(s_wifi);
if (NM_IN_STRSET(mode, NM_SETTING_WIRELESS_MODE_AP, NM_SETTING_WIRELESS_MODE_ADHOC))
return TRUE;
/* Hidden SSIDs obviously don't always appear in the scan list either.
*
* For an explicit user-activation-request, a connection is considered
* available because for hidden Wi-Fi, clients didn't consistently
* set the 'hidden' property to indicate hidden SSID networks. If
* activating but the network isn't available let the device recheck
* availability.
*/
if (nm_setting_wireless_get_hidden(s_wifi)
|| NM_FLAGS_HAS(flags, _NM_DEVICE_CHECK_CON_AVAILABLE_FOR_USER_REQUEST_IGNORE_AP))
return TRUE;
if (!ap)
ap = nm_wifi_aps_find_first_compatible(&priv->aps_lst_head, connection);
if (!ap) {
nm_utils_error_set_literal(error,
NM_UTILS_ERROR_CONNECTION_AVAILABLE_TEMPORARY,
"no compatible access point found");
return FALSE;
}
/* 8021x networks can only be used if they've been provisioned on the IWD side and
* thus are Known Networks.
*/
if (nm_wifi_connection_get_iwd_ssid_and_security(connection, NULL, &security)
&& security == NM_IWD_NETWORK_SECURITY_8021X) {
if (!is_ap_known_network(ap)) {
nm_utils_error_set_literal(
error,
NM_UTILS_ERROR_CONNECTION_AVAILABLE_TEMPORARY,
"802.1x network is not an IWD Known Network (missing provisioning file?)");
return FALSE;
}
}
return TRUE;
}
/* To be used where the SSID has been validated before */
static char *
iwd_ssid_to_str(const GBytes *ssid)
{
const guint8 *ssid_bytes;
gsize ssid_len;
ssid_bytes = g_bytes_get_data((GBytes *) ssid, &ssid_len);
nm_assert(ssid && g_utf8_validate((const char *) ssid_bytes, ssid_len, NULL));
return g_strndup((const char *) ssid_bytes, ssid_len);
}
static gboolean
complete_connection(NMDevice * device,
NMConnection * connection,
const char * specific_object,
NMConnection *const *existing_connections,
GError ** error)
{
NMDeviceIwd * self = NM_DEVICE_IWD(device);
NMDeviceIwdPrivate *priv = NM_DEVICE_IWD_GET_PRIVATE(self);
NMSettingWireless * s_wifi;
gs_free char * ssid_utf8 = NULL;
NMWifiAP * ap;
GBytes * ssid = NULL;
gboolean hidden = FALSE;
const char * mode;
s_wifi = nm_connection_get_setting_wireless(connection);
mode = s_wifi ? nm_setting_wireless_get_mode(s_wifi) : NULL;
if (nm_streq0(mode, NM_SETTING_WIRELESS_MODE_AP) || !specific_object) {
const guint8 *ssid_bytes;
gsize ssid_len;
/* If not given a specific object, we need at minimum an SSID */
if (!s_wifi) {
g_set_error_literal(error,
NM_DEVICE_ERROR,
NM_DEVICE_ERROR_INVALID_CONNECTION,
"A 'wireless' setting is required if no AP path was given.");
return FALSE;
}
ssid = nm_setting_wireless_get_ssid(s_wifi);
ssid_bytes = g_bytes_get_data(ssid, &ssid_len);
if (!ssid || ssid_len == 0 || !g_utf8_validate((const char *) ssid_bytes, ssid_len, NULL)) {
g_set_error_literal(error,
NM_DEVICE_ERROR,
NM_DEVICE_ERROR_INVALID_CONNECTION,
"A 'wireless' setting with a valid UTF-8 SSID is required if no AP "
"path was given.");
return FALSE;
}
}
if (nm_streq0(mode, NM_SETTING_WIRELESS_MODE_AP)) {
if (!nm_setting_verify(NM_SETTING(s_wifi), connection, error))
return FALSE;
ap = NULL;
} else if (!specific_object) {
/* Find a compatible AP in the scan list */
ap = nm_wifi_aps_find_first_compatible(&priv->aps_lst_head, connection);
if (!ap) {
/* If we still don't have an AP, then the WiFI settings needs to be
* fully specified by the client. Might not be able to find an AP
* if the network isn't broadcasting the SSID for example.
*/
if (!nm_setting_verify(NM_SETTING(s_wifi), connection, error))
return FALSE;
/* We could either require the profile to be marked as hidden by the
* client or at least check that a hidden AP with a matching security
* type is in range using Station.GetHiddenAccessPoints(). For now
* assume it is hidden even though that will reveal the SSID on the
* air.
*/
hidden = TRUE;
}
} else {
ap = nm_wifi_ap_lookup_for_device(NM_DEVICE(self), specific_object);
if (!ap) {
g_set_error(error,
NM_DEVICE_ERROR,
NM_DEVICE_ERROR_SPECIFIC_OBJECT_NOT_FOUND,
"The access point %s was not in the scan list.",
specific_object);
return FALSE;
}
ssid = nm_wifi_ap_get_ssid(ap);
/* Add a wifi setting if one doesn't exist yet */
if (!s_wifi) {
s_wifi = (NMSettingWireless *) nm_setting_wireless_new();
nm_connection_add_setting(connection, NM_SETTING(s_wifi));
}
}
if (ap) {
if (!nm_wifi_ap_complete_connection(ap, connection, FALSE, error))
return FALSE;
}
ssid_utf8 = iwd_ssid_to_str(ssid);
nm_utils_complete_generic(
nm_device_get_platform(device),
connection,
NM_SETTING_WIRELESS_SETTING_NAME,
existing_connections,
ssid_utf8,
ssid_utf8,
NULL,
nm_setting_wireless_get_mac_address(s_wifi) ? NULL : nm_device_get_iface(device),
TRUE);
if (hidden)
g_object_set(s_wifi, NM_SETTING_WIRELESS_HIDDEN, TRUE, NULL);
return TRUE;
}
static gboolean
is_available(NMDevice *device, NMDeviceCheckDevAvailableFlags flags)
{
NMDeviceIwd * self = NM_DEVICE_IWD(device);
NMDeviceIwdPrivate *priv = NM_DEVICE_IWD_GET_PRIVATE(self);
NMDeviceState state = nm_device_get_state(device);
/* Available if either the device is UP and in station mode
* or in AP/Ad-Hoc modes while activating or activated. Device
* may be temporarily DOWN while activating or deactivating and
* we don't want it to be marked unavailable because of this.
*
* For reference:
* We call nm_device_queue_recheck_available whenever
* priv->enabled changes or priv->dbus_station_proxy changes.
*/
return priv->dbus_obj && priv->enabled
&& (priv->dbus_station_proxy
|| (state >= NM_DEVICE_STATE_CONFIG && state <= NM_DEVICE_STATE_DEACTIVATING));
}
static gboolean
get_autoconnect_allowed(NMDevice *device)
{
NMDeviceIwdPrivate *priv = NM_DEVICE_IWD_GET_PRIVATE(NM_DEVICE_IWD(device));
return priv->nm_autoconnect;
}
static gboolean
can_auto_connect(NMDevice *device, NMSettingsConnection *sett_conn, char **specific_object)
{
NMDeviceIwd * self = NM_DEVICE_IWD(device);
NMDeviceIwdPrivate *priv = NM_DEVICE_IWD_GET_PRIVATE(self);
NMConnection * connection;
NMSettingWireless * s_wifi;
NMWifiAP * ap;
const char * mode;
guint64 timestamp = 0;
nm_assert(!specific_object || !*specific_object);
if (!NM_DEVICE_CLASS(nm_device_iwd_parent_class)->can_auto_connect(device, sett_conn, NULL))
return FALSE;
connection = nm_settings_connection_get_connection(sett_conn);
s_wifi = nm_connection_get_setting_wireless(connection);
g_return_val_if_fail(s_wifi, FALSE);
/* Don't auto-activate AP or Ad-Hoc connections.
* Note the wpa_supplicant backend has the opposite policy.
*/
mode = nm_setting_wireless_get_mode(s_wifi);
if (mode && g_strcmp0(mode, NM_SETTING_WIRELESS_MODE_INFRA) != 0)
return FALSE;
/* Don't autoconnect to networks that have been tried at least once
* but haven't been successful, since these are often accidental choices
* from the menu and the user may not know the password.
*/
if (nm_settings_connection_get_timestamp(sett_conn, ×tamp)) {
if (timestamp == 0)
return FALSE;
}
ap = nm_wifi_aps_find_first_compatible(&priv->aps_lst_head, connection);
if (ap) {
/* All good; connection is usable */
NM_SET_OUT(specific_object, g_strdup(nm_dbus_object_get_path(NM_DBUS_OBJECT(ap))));
return TRUE;
}
return FALSE;
}
const CList *
_nm_device_iwd_get_aps(NMDeviceIwd *self)
{
return &NM_DEVICE_IWD_GET_PRIVATE(self)->aps_lst_head;
}
static void
scan_cb(GObject *source, GAsyncResult *res, gpointer user_data)
{
NMDeviceIwd * self = user_data;
NMDeviceIwdPrivate *priv;
gs_unref_variant GVariant *variant = NULL;
gs_free_error GError *error = NULL;
variant = g_dbus_proxy_call_finish(G_DBUS_PROXY(source), res, &error);
if (!variant && nm_utils_error_is_cancelled(error))
return;
priv = NM_DEVICE_IWD_GET_PRIVATE(self);
priv->scan_requested = FALSE;
priv->last_scan = nm_utils_get_monotonic_timestamp_msec();
_notify(self, PROP_LAST_SCAN);
/* On success, priv->scanning becomes true right before or right
* after this callback, so the next automatic scan will be
* scheduled when priv->scanning goes back to false. On error,
* schedule a retry now.
*/
if (error && !priv->scanning)
schedule_periodic_scan(self, FALSE);
}
static void
dbus_request_scan_cb(NMDevice * device,
GDBusMethodInvocation *context,
NMAuthSubject * subject,
GError * error,
gpointer user_data)
{
NMDeviceIwd * self = NM_DEVICE_IWD(device);
NMDeviceIwdPrivate *priv;
gs_unref_variant GVariant *scan_options = user_data;
if (error) {
g_dbus_method_invocation_return_gerror(context, error);
return;
}
if (check_scanning_prohibited(self, FALSE)) {
g_dbus_method_invocation_return_error_literal(context,
NM_DEVICE_ERROR,
NM_DEVICE_ERROR_NOT_ALLOWED,
"Scanning not allowed at this time");
return;
}
priv = NM_DEVICE_IWD_GET_PRIVATE(self);
if (!priv->can_scan) {
g_dbus_method_invocation_return_error_literal(context,
NM_DEVICE_ERROR,
NM_DEVICE_ERROR_NOT_ALLOWED,
"Scanning not allowed while unavailable");
return;
}
if (scan_options) {
gs_unref_variant GVariant *val = g_variant_lookup_value(scan_options, "ssids", NULL);
if (val) {
g_dbus_method_invocation_return_error_literal(context,
NM_DEVICE_ERROR,
NM_DEVICE_ERROR_NOT_ALLOWED,
"'ssid' scan option not supported");
return;
}
}
if (!priv->scanning && !priv->scan_requested) {
g_dbus_proxy_call(priv->dbus_station_proxy,
"Scan",
NULL,
G_DBUS_CALL_FLAGS_NONE,
-1,
priv->cancellable,
scan_cb,
self);
priv->scan_requested = TRUE;
}
g_dbus_method_invocation_return_value(context, NULL);
}
void
_nm_device_iwd_request_scan(NMDeviceIwd *self, GVariant *options, GDBusMethodInvocation *invocation)
{
NMDeviceIwdPrivate *priv = NM_DEVICE_IWD_GET_PRIVATE(self);
NMDevice * device = NM_DEVICE(self);
if (!priv->can_scan) {
g_dbus_method_invocation_return_error_literal(invocation,
NM_DEVICE_ERROR,
NM_DEVICE_ERROR_NOT_ALLOWED,
"Scanning not allowed while unavailable");
return;
}
nm_device_auth_request(device,
invocation,
NULL,
NM_AUTH_PERMISSION_WIFI_SCAN,
TRUE,
NULL,
dbus_request_scan_cb,
nm_g_variant_ref(options));
}
static gboolean
check_scanning_prohibited(NMDeviceIwd *self, gboolean periodic)
{
NMDeviceIwdPrivate *priv = NM_DEVICE_IWD_GET_PRIVATE(self);
g_return_val_if_fail(priv->dbus_obj != NULL, TRUE);
switch (nm_device_get_state(NM_DEVICE(self))) {
case NM_DEVICE_STATE_UNKNOWN:
case NM_DEVICE_STATE_UNMANAGED:
case NM_DEVICE_STATE_UNAVAILABLE:
case NM_DEVICE_STATE_PREPARE:
case NM_DEVICE_STATE_CONFIG:
case NM_DEVICE_STATE_IP_CONFIG:
case NM_DEVICE_STATE_IP_CHECK:
case NM_DEVICE_STATE_SECONDARIES:
case NM_DEVICE_STATE_DEACTIVATING:
/* Prohibit scans when unusable or activating */
return TRUE;
case NM_DEVICE_STATE_DISCONNECTED:
case NM_DEVICE_STATE_FAILED:
case NM_DEVICE_STATE_ACTIVATED:
case NM_DEVICE_STATE_NEED_AUTH:
break;
}
/* Prohibit scans if IWD is busy */
return !priv->can_scan;
}
static const char *
get_agent_request_network_path(GDBusMethodInvocation *invocation)
{
const char *method_name = g_dbus_method_invocation_get_method_name(invocation);
GVariant * params = g_dbus_method_invocation_get_parameters(invocation);
const char *network_path = NULL;
if (nm_streq(method_name, "RequestPassphrase"))
g_variant_get(params, "(&o)", &network_path);
else if (nm_streq(method_name, "RequestPrivateKeyPassphrase"))
g_variant_get(params, "(&o)", &network_path);
else if (nm_streq(method_name, "RequestUserNameAndPassword"))
g_variant_get(params, "(&o)", &network_path);
else if (nm_streq(method_name, "RequestUserPassword"))
g_variant_get(params, "(&os)", &network_path, NULL);
return network_path;
}
/*
* try_reply_agent_request
*
* Check if the connection settings already have the secrets corresponding
* to the IWD agent method that was invoked. If they do, send the method reply
* with the appropriate secrets. Otherwise, return the missing secret's setting
* name and key so the caller can send a NM secrets request with this data.
* Return TRUE in either case, return FALSE if an error is detected.
*/
static gboolean
try_reply_agent_request(NMDeviceIwd * self,
NMConnection * connection,
GDBusMethodInvocation *invocation,
const char ** setting_name,
const char ** setting_key,
gboolean * replied)
{
const char * method_name = g_dbus_method_invocation_get_method_name(invocation);
NMSettingWirelessSecurity *s_wireless_sec;
NMSetting8021x * s_8021x;
s_wireless_sec = nm_connection_get_setting_wireless_security(connection);
s_8021x = nm_connection_get_setting_802_1x(connection);
*replied = FALSE;
if (nm_streq(method_name, "RequestPassphrase")) {
const char *psk;
if (!s_wireless_sec)
return FALSE;
psk = nm_setting_wireless_security_get_psk(s_wireless_sec);
if (psk) {
_LOGD(LOGD_DEVICE | LOGD_WIFI, "Returning the PSK to the IWD Agent");
g_dbus_method_invocation_return_value(invocation, g_variant_new("(s)", psk));
*replied = TRUE;
return TRUE;
}
*setting_name = NM_SETTING_WIRELESS_SECURITY_SETTING_NAME;
*setting_key = NM_SETTING_WIRELESS_SECURITY_PSK;
return TRUE;
} else if (nm_streq(method_name, "RequestPrivateKeyPassphrase")) {
const char *password;
if (!s_8021x)
return FALSE;
password = nm_setting_802_1x_get_private_key_password(s_8021x);
if (password) {
_LOGD(LOGD_DEVICE | LOGD_WIFI, "Returning the private key password to the IWD Agent");
g_dbus_method_invocation_return_value(invocation, g_variant_new("(s)", password));
*replied = TRUE;
return TRUE;
}
*setting_name = NM_SETTING_802_1X_SETTING_NAME;
*setting_key = NM_SETTING_802_1X_PRIVATE_KEY_PASSWORD;
return TRUE;
} else if (nm_streq(method_name, "RequestUserNameAndPassword")) {
const char *identity, *password;
if (!s_8021x)
return FALSE;
identity = nm_setting_802_1x_get_identity(s_8021x);
password = nm_setting_802_1x_get_password(s_8021x);
if (identity && password) {
_LOGD(LOGD_DEVICE | LOGD_WIFI, "Returning the username and password to the IWD Agent");
g_dbus_method_invocation_return_value(invocation,
g_variant_new("(ss)", identity, password));
*replied = TRUE;
return TRUE;
}
*setting_name = NM_SETTING_802_1X_SETTING_NAME;
if (!identity)
*setting_key = NM_SETTING_802_1X_IDENTITY;
else
*setting_key = NM_SETTING_802_1X_PASSWORD;
return TRUE;
} else if (nm_streq(method_name, "RequestUserPassword")) {
const char *password;
if (!s_8021x)
return FALSE;
password = nm_setting_802_1x_get_password(s_8021x);
if (password) {
_LOGD(LOGD_DEVICE | LOGD_WIFI, "Returning the user password to the IWD Agent");
g_dbus_method_invocation_return_value(invocation, g_variant_new("(s)", password));
*replied = TRUE;
return TRUE;
}
*setting_name = NM_SETTING_802_1X_SETTING_NAME;
*setting_key = NM_SETTING_802_1X_PASSWORD;
return TRUE;
} else
return FALSE;
}
static gboolean
assumed_ac_timeout_cb(gpointer user_data)
{
NMDeviceIwd * self = user_data;
NMDeviceIwdPrivate *priv = NM_DEVICE_IWD_GET_PRIVATE(self);
nm_assert(priv->assumed_ac);
priv->assumed_ac_timeout = 0;
nm_device_state_changed(NM_DEVICE(self),
NM_DEVICE_STATE_FAILED,
NM_DEVICE_STATE_REASON_SUPPLICANT_TIMEOUT);
/* NMDevice's state change -> NMActRequests/NMActiveConnection's state
* change -> assumed_connection_state_changed_before_managed() ->
* cleanup_association_attempt() so no need to call it explicitly.
*/
return G_SOURCE_REMOVE;
}
static void wifi_secrets_get_one(NMDeviceIwd * self,
const char * setting_name,
NMSecretAgentGetSecretsFlags flags,
const char * setting_key,
GDBusMethodInvocation * invocation);
static void
wifi_secrets_cb(NMActRequest * req,
NMActRequestGetSecretsCallId *call_id,
NMSettingsConnection * s_connection,
GError * error,
gpointer user_data)
{
NMDeviceIwd * self;
NMDeviceIwdPrivate * priv;
NMDevice * device;
GDBusMethodInvocation * invocation;
const char * setting_name;
const char * setting_key;
gboolean replied;
NMSecretAgentGetSecretsFlags get_secret_flags =
NM_SECRET_AGENT_GET_SECRETS_FLAG_ALLOW_INTERACTION;
nm_utils_user_data_unpack(user_data, &self, &invocation);
g_return_if_fail(NM_IS_DEVICE_IWD(self));
priv = NM_DEVICE_IWD_GET_PRIVATE(self);
device = NM_DEVICE(self);
g_return_if_fail(priv->wifi_secrets_id == call_id);
priv->wifi_secrets_id = NULL;
if (nm_utils_error_is_cancelled(error)) {
priv->secrets_failed = TRUE;
g_dbus_method_invocation_return_error_literal(invocation,
NM_DEVICE_ERROR,
NM_DEVICE_ERROR_INVALID_CONNECTION,
"NM secrets request cancelled");
return;
}
g_return_if_fail(req == nm_device_get_act_request(device));
g_return_if_fail(nm_act_request_get_settings_connection(req) == s_connection);
if (nm_device_get_state(device) != NM_DEVICE_STATE_NEED_AUTH)
goto secrets_error;
if (error) {
_LOGW(LOGD_WIFI, "%s", error->message);
goto secrets_error;
}
if (!try_reply_agent_request(self,
nm_act_request_get_applied_connection(req),
invocation,
&setting_name,
&setting_key,
&replied))
goto secrets_error;
if (replied) {
/* If we replied to the secrets request from IWD in the "disconnected"
* state and IWD doesn't move to a new state within 1 second, assume
* something went wrong (shouldn't happen). If a state change arrives
* after that nothing is lost, state_changed() will try to assume the
* connection again.
*/
if (priv->assumed_ac) {
gs_unref_variant GVariant *value =
g_dbus_proxy_get_cached_property(priv->dbus_station_proxy, "State");
if (nm_streq(get_variant_state(value), "disconnected"))
priv->assumed_ac_timeout = g_timeout_add_seconds(1, assumed_ac_timeout_cb, self);
}
/* Change state back to what it was before NEED_AUTH */
nm_device_state_changed(device, NM_DEVICE_STATE_CONFIG, NM_DEVICE_STATE_REASON_NONE);
return;
}
if (nm_settings_connection_get_timestamp(nm_act_request_get_settings_connection(req), NULL))
get_secret_flags |= NM_SECRET_AGENT_GET_SECRETS_FLAG_REQUEST_NEW;
/* Request further secrets if we still need something */
wifi_secrets_get_one(self, setting_name, get_secret_flags, setting_key, invocation);
return;
secrets_error:
g_dbus_method_invocation_return_error_literal(invocation,
NM_DEVICE_ERROR,
NM_DEVICE_ERROR_INVALID_CONNECTION,
"NM secrets request failed");
if (priv->assumed_ac) {
nm_device_state_changed(device, NM_DEVICE_STATE_FAILED, NM_DEVICE_STATE_REASON_NO_SECRETS);
/* NMDevice's state change -> NMActRequests/NMActiveConnection's state
* change -> assumed_connection_state_changed_before_managed() ->
* cleanup_association_attempt() so no need to call it explicitly.
*/
} else {
priv->secrets_failed = TRUE;
/* Now wait for the Connect callback to update device state */
}
}
static void
wifi_secrets_get_one(NMDeviceIwd * self,
const char * setting_name,
NMSecretAgentGetSecretsFlags flags,
const char * setting_key,
GDBusMethodInvocation * invocation)
{
NMDeviceIwdPrivate *priv = NM_DEVICE_IWD_GET_PRIVATE(self);
NMActRequest * req;
wifi_secrets_cancel(self);
req = nm_device_get_act_request(NM_DEVICE(self));
g_return_if_fail(NM_IS_ACT_REQUEST(req));
priv->wifi_secrets_id = nm_act_request_get_secrets(req,
TRUE,
setting_name,
flags,
NM_MAKE_STRV(setting_key),
wifi_secrets_cb,
nm_utils_user_data_pack(self, invocation));
}
static void
network_connect_cb(GObject *source, GAsyncResult *res, gpointer user_data)
{
NMDeviceIwd * self = user_data;
NMDevice * device = NM_DEVICE(self);
NMDeviceIwdPrivate *priv = NM_DEVICE_IWD_GET_PRIVATE(self);
gs_unref_variant GVariant *variant = NULL;
gs_free_error GError *error = NULL;
NMConnection * connection;
gs_free char * ssid = NULL;
NMDeviceStateReason reason = NM_DEVICE_STATE_REASON_SUPPLICANT_FAILED;
GVariant * value;
gboolean disconnect;
disconnect = !priv->iwd_autoconnect
|| nm_device_autoconnect_blocked_get(device, NM_DEVICE_AUTOCONNECT_BLOCKED_ALL);
variant = g_dbus_proxy_call_finish(G_DBUS_PROXY(source), res, &error);
if (!variant) {
gs_free char *dbus_error = NULL;
/* Connection failed; radio problems or if the network wasn't
* open, the passwords or certificates may be wrong.
*/
_LOGE(LOGD_DEVICE | LOGD_WIFI,
"Activation: (wifi) Network.Connect failed: %s",
error->message);
if (nm_utils_error_is_cancelled(error))
return;
if (!NM_IN_SET(nm_device_get_state(device),
NM_DEVICE_STATE_CONFIG,
NM_DEVICE_STATE_NEED_AUTH))
return;
connection = nm_device_get_applied_connection(device);
if (!connection)
goto failed;
if (g_error_matches(error, G_IO_ERROR, G_IO_ERROR_DBUS_ERROR))
dbus_error = g_dbus_error_get_remote_error(error);
if (nm_streq0(dbus_error, "net.connman.iwd.Failed")) {
nm_connection_clear_secrets(connection);
/* If secrets were wrong, we'd be getting a net.connman.iwd.Failed */
reason = NM_DEVICE_STATE_REASON_NO_SECRETS;
} else if (nm_streq0(dbus_error, "net.connman.iwd.Aborted") && priv->secrets_failed) {
/* If agent call was cancelled we'd be getting a net.connman.iwd.Aborted */
reason = NM_DEVICE_STATE_REASON_NO_SECRETS;
}
goto failed;
}
nm_assert(nm_device_get_state(device) == NM_DEVICE_STATE_CONFIG);
disconnect = TRUE;
connection = nm_device_get_applied_connection(device);
if (!connection)
goto failed;
if (!nm_wifi_connection_get_iwd_ssid_and_security(connection, &ssid, NULL))
goto failed;
_LOGI(LOGD_DEVICE | LOGD_WIFI,
"Activation: (wifi) Stage 2 of 5 (Device Configure) successful. Connected to '%s'.",
ssid);
nm_device_activate_schedule_stage3_ip_config_start(device);
return;
failed:
/* If necessary call Disconnect to make sure IWD's autoconnect is disabled */
cleanup_association_attempt(self, disconnect);
nm_device_state_changed(device, NM_DEVICE_STATE_FAILED, reason);
value = g_dbus_proxy_get_cached_property(priv->dbus_station_proxy, "State");
if (!priv->iwd_autoconnect && nm_streq(get_variant_state(value), "disconnected")) {
schedule_periodic_scan(self, TRUE);
if (!priv->nm_autoconnect) {
priv->nm_autoconnect = true;
nm_device_emit_recheck_auto_activate(device);
}
}
g_variant_unref(value);
}
static void
act_failed_cb(GObject *source, GAsyncResult *res, gpointer user_data)
{
NMDeviceIwd * self = user_data;
NMDevice * device = NM_DEVICE(self);
gs_unref_variant GVariant *variant = NULL;
gs_free_error GError *error = NULL;
variant = g_dbus_proxy_call_finish(G_DBUS_PROXY(source), res, &error);
if (!variant && nm_utils_error_is_cancelled(error))
return;
/* Change state to FAILED unless already done by state_changed
* which may have been triggered by the station interface
* appearing on DBus.
*/
if (nm_device_get_state(device) == NM_DEVICE_STATE_CONFIG)
nm_device_queue_state(device,
NM_DEVICE_STATE_FAILED,
NM_DEVICE_STATE_REASON_SUPPLICANT_FAILED);
}
static void
act_start_cb(GObject *source, GAsyncResult *res, gpointer user_data)
{
NMDeviceIwd * self = user_data;
NMDeviceIwdPrivate *priv = NM_DEVICE_IWD_GET_PRIVATE(self);
NMDevice * device = NM_DEVICE(self);
gs_unref_variant GVariant *variant = NULL;
gs_free_error GError *error = NULL;
gs_free char * ssid = NULL;
variant = g_dbus_proxy_call_finish(G_DBUS_PROXY(source), res, &error);
if (!variant) {
_LOGE(LOGD_DEVICE | LOGD_WIFI,
"Activation: (wifi) {AccessPoint,AdHoc}.Start() failed: %s",
error->message);
if (nm_utils_error_is_cancelled(error))
return;
if (!NM_IN_SET(nm_device_get_state(device), NM_DEVICE_STATE_CONFIG))
return;
goto error;
}
nm_assert(nm_device_get_state(device) == NM_DEVICE_STATE_CONFIG);
if (!nm_wifi_connection_get_iwd_ssid_and_security(nm_device_get_applied_connection(device),
&ssid,
NULL))
goto error;
_LOGI(LOGD_DEVICE | LOGD_WIFI,
"Activation: (wifi) Stage 2 of 5 (Device Configure) successful. Started '%s'.",
ssid);
nm_device_activate_schedule_stage3_ip_config_start(device);
return;
error:
reset_mode(self, priv->cancellable, act_failed_cb, self);
}
/* Check if we're activating an AP/AdHoc connection and if the target
* DBus interface has appeared already. If so proceed to call Start or
* StartOpen on that interface.
*/
static void
act_check_interface(NMDeviceIwd *self)
{
NMDeviceIwdPrivate * priv = NM_DEVICE_IWD_GET_PRIVATE(self);
NMDevice * device = NM_DEVICE(self);
NMSettingWireless * s_wireless;
GDBusProxy * proxy = NULL;
gs_free char * ssid = NULL;
const char * mode;
NMIwdNetworkSecurity security;
if (!priv->act_mode_switch)
return;
s_wireless =
(NMSettingWireless *) nm_device_get_applied_setting(device, NM_TYPE_SETTING_WIRELESS);
mode = nm_setting_wireless_get_mode(s_wireless);
if (nm_streq0(mode, NM_SETTING_WIRELESS_MODE_AP))
proxy = priv->dbus_ap_proxy;
else if (nm_streq0(mode, NM_SETTING_WIRELESS_MODE_ADHOC))
proxy = priv->dbus_adhoc_proxy;
if (!proxy)
return;
priv->act_mode_switch = FALSE;
if (!NM_IN_SET(nm_device_get_state(device), NM_DEVICE_STATE_CONFIG))
return;
if (!nm_wifi_connection_get_iwd_ssid_and_security(nm_device_get_applied_connection(device),
&ssid,
&security))
goto failed;
if (security == NM_IWD_NETWORK_SECURITY_OPEN) {
g_dbus_proxy_call(proxy,
"StartOpen",
g_variant_new("(s)", ssid),
G_DBUS_CALL_FLAGS_NONE,
G_MAXINT,
priv->cancellable,
act_start_cb,
self);
} else if (security == NM_IWD_NETWORK_SECURITY_PSK) {
NMSettingWirelessSecurity *s_wireless_sec;
const char * psk;
s_wireless_sec = (NMSettingWirelessSecurity *) nm_device_get_applied_setting(
device,
NM_TYPE_SETTING_WIRELESS_SECURITY);
psk = nm_setting_wireless_security_get_psk(s_wireless_sec);
if (!psk) {
_LOGE(LOGD_DEVICE | LOGD_WIFI, "Activation: (wifi) No PSK for '%s'.", ssid);
goto failed;
}
g_dbus_proxy_call(proxy,
"Start",
g_variant_new("(ss)", ssid, psk),
G_DBUS_CALL_FLAGS_NONE,
G_MAXINT,
priv->cancellable,
act_start_cb,
self);
} else
goto failed;
_LOGD(LOGD_DEVICE | LOGD_WIFI, "Activation: (wifi) Called Start('%s').", ssid);
return;
failed:
reset_mode(self, priv->cancellable, act_failed_cb, self);
}
static void
act_set_mode_cb(GObject *source, GAsyncResult *res, gpointer user_data)
{
NMDeviceIwd * self = user_data;
NMDeviceIwdPrivate *priv = NM_DEVICE_IWD_GET_PRIVATE(self);
NMDevice * device = NM_DEVICE(self);
gs_unref_variant GVariant *variant = NULL;
gs_free_error GError *error = NULL;
variant = g_dbus_proxy_call_finish(G_DBUS_PROXY(source), res, &error);
if (!variant) {
_LOGE(LOGD_DEVICE | LOGD_WIFI,
"Activation: (wifi) Setting Device.Mode failed: %s",
error->message);
if (nm_utils_error_is_cancelled(error))
return;
if (!NM_IN_SET(nm_device_get_state(device), NM_DEVICE_STATE_CONFIG)
|| !priv->act_mode_switch)
return;
priv->act_mode_switch = FALSE;
nm_device_queue_state(device,
NM_DEVICE_STATE_FAILED,
NM_DEVICE_STATE_REASON_SUPPLICANT_FAILED);
return;
}
_LOGD(LOGD_DEVICE | LOGD_WIFI, "Activation: (wifi) IWD Device.Mode set successfully");
act_check_interface(self);
}
static void
act_set_mode(NMDeviceIwd *self)
{
NMDeviceIwdPrivate *priv = NM_DEVICE_IWD_GET_PRIVATE(self);
NMDevice * device = NM_DEVICE(self);
const char * iwd_mode;
const char * mode;
NMSettingWireless * s_wireless;
s_wireless =
(NMSettingWireless *) nm_device_get_applied_setting(device, NM_TYPE_SETTING_WIRELESS);
mode = nm_setting_wireless_get_mode(s_wireless);
/* We need to first set interface mode (Device.Mode) to ap or ad-hoc.
* We can't directly queue a call to the Start/StartOpen method on
* the DBus interface that's going to be created after the property
* set call returns.
*/
iwd_mode = nm_streq(mode, NM_SETTING_WIRELESS_MODE_AP) ? "ap" : "ad-hoc";
if (!priv->cancellable)
priv->cancellable = g_cancellable_new();
g_dbus_proxy_call(
priv->dbus_device_proxy,
DBUS_INTERFACE_PROPERTIES ".Set",
g_variant_new("(ssv)", NM_IWD_DEVICE_INTERFACE, "Mode", g_variant_new("s", iwd_mode)),
G_DBUS_CALL_FLAGS_NONE,
2000,
priv->cancellable,
act_set_mode_cb,
self);
priv->act_mode_switch = TRUE;
}
static void
act_psk_cb(NMActRequest * req,
NMActRequestGetSecretsCallId *call_id,
NMSettingsConnection * s_connection,
GError * error,
gpointer user_data)
{
NMDeviceIwd * self = user_data;
NMDeviceIwdPrivate *priv;
NMDevice * device;
if (nm_utils_error_is_cancelled(error))
return;
priv = NM_DEVICE_IWD_GET_PRIVATE(self);
device = NM_DEVICE(self);
g_return_if_fail(priv->wifi_secrets_id == call_id);
priv->wifi_secrets_id = NULL;
g_return_if_fail(req == nm_device_get_act_request(device));
g_return_if_fail(nm_act_request_get_settings_connection(req) == s_connection);
if (nm_device_get_state(device) != NM_DEVICE_STATE_NEED_AUTH)
goto secrets_error;
if (error) {
_LOGW(LOGD_WIFI, "%s", error->message);
goto secrets_error;
}
_LOGD(LOGD_DEVICE | LOGD_WIFI, "Activation: (wifi) missing PSK request completed");
/* Change state back to what it was before NEED_AUTH */
nm_device_state_changed(device, NM_DEVICE_STATE_CONFIG, NM_DEVICE_STATE_REASON_NONE);
act_set_mode(self);
return;
secrets_error:
nm_device_state_changed(device, NM_DEVICE_STATE_FAILED, NM_DEVICE_STATE_REASON_NO_SECRETS);
cleanup_association_attempt(self, FALSE);
}
static void
set_powered(NMDeviceIwd *self, gboolean powered)
{
NMDeviceIwdPrivate *priv = NM_DEVICE_IWD_GET_PRIVATE(self);
g_dbus_proxy_call(
priv->dbus_device_proxy,
DBUS_INTERFACE_PROPERTIES ".Set",
g_variant_new("(ssv)", NM_IWD_DEVICE_INTERFACE, "Powered", g_variant_new("b", powered)),
G_DBUS_CALL_FLAGS_NONE,
2000,
NULL,
NULL,
NULL);
}
/*****************************************************************************/
static NMWifiAP *
find_ap_by_supplicant_path(NMDeviceIwd *self, const NMRefString *path)
{
NMDeviceIwdPrivate *priv = NM_DEVICE_IWD_GET_PRIVATE(self);
NMWifiAP * tmp;
c_list_for_each_entry (tmp, &priv->aps_lst_head, aps_lst)
if (nm_wifi_ap_get_supplicant_path(tmp) == path)
return tmp;
return NULL;
}
static void
assumed_connection_state_changed(NMActiveConnection *active, GParamSpec *pspec, NMDeviceIwd *self)
{
NMSettingsConnection * sett_conn = nm_active_connection_get_settings_connection(active);
NMActiveConnectionState state = nm_active_connection_get_state(active);
/* Delete the temporary connection created for an external IWD connection
* (triggered by somebody outside of NM, be it IWD autoconnect or a
* parallel client), unless it's been referenced by a Known Network
* object since, which would remove the EXTERNAL flag.
*
* Note we can't do this too early, e.g. at the same time that we're
* setting the device state to FAILED or DISCONNECTING because the
* connection shouldn't disappear while it's still being used. We do
* this on the connection's transition to DEACTIVATED same as as
* NMManager does for external activations.
*/
if (state != NM_ACTIVE_CONNECTION_STATE_DEACTIVATED)
return;
g_signal_handlers_disconnect_by_func(active, assumed_connection_state_changed, NULL);
if (sett_conn
&& NM_FLAGS_HAS(nm_settings_connection_get_flags(sett_conn),
NM_SETTINGS_CONNECTION_INT_FLAGS_EXTERNAL))
nm_settings_connection_delete(sett_conn, FALSE);
}
static void
assumed_connection_state_changed_before_managed(NMActiveConnection *active,
GParamSpec * pspec,
NMDeviceIwd * self)
{
NMDeviceIwdPrivate * priv = NM_DEVICE_IWD_GET_PRIVATE(self);
NMActiveConnectionState state = nm_active_connection_get_state(active);
gboolean disconnect;
if (state != NM_ACTIVE_CONNECTION_STATE_DEACTIVATED)
return;
/* When an assumed connection fails we always get called, even if the
* activation hasn't reached PREPARE or CONFIG, e.g. because of a policy
* or authorization problem in NMManager. .deactivate would only be
* called starting at some stage so we can't rely on that.
*
* If the error happened before PREPARE (where we set a non-NULL
* priv->current_ap) that will mean NM is somehow blocking autoconnect
* so we want to call IWD's Station.Disconnect() to block its
* autoconnect. If this happens during or after PREPARE, we just
* clean up and wait for a new attempt by IWD.
*
* cleanup_association_attempt will clear priv->assumed_ac, disconnect
* this callback from the signal and also send a Disconnect to IWD if
* needed.
*
* Note this function won't be called after IWD transitions to
* "connected" (and NMDevice to IP_CONFIG) as we disconnect from the
* signal at that point, cleanup_association_attempt() will be
* triggered by an IWD state change instead.
*/
disconnect = !priv->current_ap;
cleanup_association_attempt(self, disconnect);
}
static void
assume_connection(NMDeviceIwd *self, NMWifiAP *ap)
{
NMDeviceIwdPrivate * priv = NM_DEVICE_IWD_GET_PRIVATE(self);
NMSettingsConnection *sett_conn;
gs_unref_object NMAuthSubject *subject = NULL;
NMActiveConnection * ac;
gs_free_error GError *error = NULL;
/* We can use the .update_connection / nm_device_emit_recheck_assume
* API but we can also pass an assumed/external activation type
* directly to nm_manager_activate_connection() and skip the
* complicated process of creating a matching connection, taking
* advantage of the Known Networks pointing directly to a mirror
* connection. The only downside seems to be
* nm_manager_activate_connection() goes through the extra
* authorization.
*
* However for now we implement a similar behaviour using a normal
* "managed" activation. For one, assumed/external
* connection state is not reflected in nm_manager_get_state() until
* fully activated. Secondly setting the device state to FAILED
* is treated as ACTIVATED so we'd have to find another way to signal
* that stage2 is failing asynchronously. Thirdly the connection
* becomes "managed" only when ACTIVATED but for IWD it's really
* managed when IP_CONFIG starts.
*/
sett_conn = nm_iwd_manager_get_ap_mirror_connection(nm_iwd_manager_get(), ap);
if (!sett_conn)
goto error;
subject = nm_auth_subject_new_internal();
ac = nm_manager_activate_connection(
NM_MANAGER_GET,
sett_conn,
NULL,
nm_dbus_object_get_path(NM_DBUS_OBJECT(ap)),
NM_DEVICE(self),
subject,
NM_ACTIVATION_TYPE_MANAGED,
NM_ACTIVATION_REASON_ASSUME,
NM_ACTIVATION_STATE_FLAG_LIFETIME_BOUND_TO_PROFILE_VISIBILITY,
&error);
if (!ac) {
_LOGW(LOGD_WIFI, "Activation: (wifi) assume error: %s", error->message);
goto error;
}
/* If no Known Network existed for this AP, we generated a temporary
* NMSettingsConnection with the EXTERNAL flag. It is not referenced by
* any Known Network objects at this time so we want to delete it if the
* IWD connection ends up failing or a later part of the activation fails
* before IWD created a Known Network.
* Setting the activation type to EXTERNAL would do this by causing
* NM_ACTIVATION_STATE_FLAG_EXTERNAL to be set on the NMActiveConnection
* but we don't want the connection to be marked EXTERNAL because we
* will be assuming the ownership of it in IP_CONFIG or thereabouts.
*
* This callback stays connected forever while the second one gets
* disconnected when we reset the activation type to managed.
*/
g_signal_connect(ac,
"notify::" NM_ACTIVE_CONNECTION_STATE,
G_CALLBACK(assumed_connection_state_changed),
NULL);
g_signal_connect(ac,
"notify::" NM_ACTIVE_CONNECTION_STATE,
G_CALLBACK(assumed_connection_state_changed_before_managed),
self);
priv->assumed_ac = g_object_ref(ac);
return;
error:
send_disconnect(self);
if (sett_conn
&& NM_FLAGS_HAS(nm_settings_connection_get_flags(sett_conn),
NM_SETTINGS_CONNECTION_INT_FLAGS_EXTERNAL))
nm_settings_connection_delete(sett_conn, FALSE);
}
static void
assumed_connection_progress_to_ip_config(NMDeviceIwd *self, gboolean was_postponed)
{
NMDeviceIwdPrivate *priv = NM_DEVICE_IWD_GET_PRIVATE(self);
NMDevice * device = NM_DEVICE(self);
NMDeviceState dev_state = nm_device_get_state(device);
wifi_secrets_cancel(self);
nm_clear_g_source(&priv->assumed_ac_timeout);
/* NM takes over the activation from this point on so clear the assumed
* activation state and if we were using NM_ACTIVATION_TYPE_ASSUMED or
* _EXTERNAL we'd need to reset the activation type to _MANAGED at this
* point instead of waiting for the ACTIVATED state (as done in
* nm_active_connection_set_state).
*/
cleanup_assumed_connect(self);
if (dev_state == NM_DEVICE_STATE_NEED_AUTH)
nm_device_state_changed(NM_DEVICE(self),
NM_DEVICE_STATE_CONFIG,
NM_DEVICE_STATE_REASON_NONE);
/* If stage2 had returned NM_ACT_STAGE_RETURN_POSTPONE, we tell NMDevice
* that stage2 is done.
*/
if (was_postponed)
nm_device_activate_schedule_stage3_ip_config_start(NM_DEVICE(self));
}
static void
initial_check_assume(NMDeviceIwd *self)
{
NMDeviceIwdPrivate *priv = NM_DEVICE_IWD_GET_PRIVATE(self);
const char * network_path_str;
nm_auto_ref_string NMRefString *network_path = NULL;
NMWifiAP * ap = NULL;
gs_unref_variant GVariant *state_value =
g_dbus_proxy_get_cached_property(priv->dbus_station_proxy, "State");
gs_unref_variant GVariant *cn_value =
g_dbus_proxy_get_cached_property(priv->dbus_station_proxy, "ConnectedNetwork");
if (!NM_IN_STRSET(get_variant_state(state_value), "connecting", "connected", "roaming"))
return;
if (!priv->iwd_autoconnect) {
send_disconnect(self);
return;
}
if (!cn_value || !g_variant_is_of_type(cn_value, G_VARIANT_TYPE_OBJECT_PATH)) {
_LOGW(LOGD_DEVICE | LOGD_WIFI,
"ConnectedNetwork property not cached or not an object path");
return;
}
network_path_str = g_variant_get_string(cn_value, NULL);
network_path = nm_ref_string_new(network_path_str);
ap = find_ap_by_supplicant_path(self, network_path);
if (!ap) {
_LOGW(LOGD_DEVICE | LOGD_WIFI,
"ConnectedNetwork points to an unknown Network %s",
network_path_str);
return;
}
_LOGD(LOGD_DEVICE | LOGD_WIFI, "assuming connection in initial_check_assume");
assume_connection(self, ap);
}
static NMActStageReturn
act_stage1_prepare(NMDevice *device, NMDeviceStateReason *out_failure_reason)
{
NMDeviceIwd * self = NM_DEVICE_IWD(device);
NMDeviceIwdPrivate *priv = NM_DEVICE_IWD_GET_PRIVATE(self);
NMWifiAP * ap = NULL;
gs_unref_object NMWifiAP *ap_fake = NULL;
NMActRequest * req;
NMConnection * connection;
NMSettingWireless * s_wireless;
const char * mode;
const char * ap_path;
req = nm_device_get_act_request(device);
g_return_val_if_fail(req, NM_ACT_STAGE_RETURN_FAILURE);
connection = nm_act_request_get_applied_connection(req);
g_return_val_if_fail(connection, NM_ACT_STAGE_RETURN_FAILURE);
s_wireless = nm_connection_get_setting_wireless(connection);
g_return_val_if_fail(s_wireless, NM_ACT_STAGE_RETURN_FAILURE);
/* AP, Ad-Hoc modes never use a specific object or existing scanned AP */
mode = nm_setting_wireless_get_mode(s_wireless);
if (NM_IN_STRSET(mode, NM_SETTING_WIRELESS_MODE_AP, NM_SETTING_WIRELESS_MODE_ADHOC))
goto add_new;
ap_path = nm_active_connection_get_specific_object(NM_ACTIVE_CONNECTION(req));
ap = ap_path ? nm_wifi_ap_lookup_for_device(NM_DEVICE(self), ap_path) : NULL;
if (ap) {
set_current_ap(self, ap, TRUE);
return NM_ACT_STAGE_RETURN_SUCCESS;
}
ap = nm_wifi_aps_find_first_compatible(&priv->aps_lst_head, connection);
if (ap) {
nm_active_connection_set_specific_object(NM_ACTIVE_CONNECTION(req),
nm_dbus_object_get_path(NM_DBUS_OBJECT(ap)));
set_current_ap(self, ap, TRUE);
return NM_ACT_STAGE_RETURN_SUCCESS;
}
/* In infrastructure mode the specific object should be set by now except
* for a first-time connection to a hidden network. If a hidden network is
* a Known Network it should still have been in the AP list.
*/
if (!nm_setting_wireless_get_hidden(s_wireless) || is_connection_known_network(connection))
return NM_ACT_STAGE_RETURN_FAILURE;
add_new:
/* If the user is trying to connect to an AP that NM doesn't yet know about
* (hidden network or something) or starting a Hotspot, create a fake AP
* from the security settings in the connection. This "fake" AP gets used
* until the real one is found in the scan list (Ad-Hoc or Hidden), or until
* the device is deactivated (Ad-Hoc or Hotspot).
*/
ap_fake = nm_wifi_ap_new_fake_from_connection(connection);
if (!ap_fake)
g_return_val_if_reached(NM_ACT_STAGE_RETURN_FAILURE);
if (nm_wifi_ap_is_hotspot(ap_fake))
nm_wifi_ap_set_address(ap_fake, nm_device_get_hw_address(device));
g_object_freeze_notify(G_OBJECT(self));
ap_add_remove(self, TRUE, ap_fake, FALSE);
g_object_thaw_notify(G_OBJECT(self));
set_current_ap(self, ap_fake, FALSE);
nm_active_connection_set_specific_object(NM_ACTIVE_CONNECTION(req),
nm_dbus_object_get_path(NM_DBUS_OBJECT(ap_fake)));
return NM_ACT_STAGE_RETURN_SUCCESS;
}
static NMActStageReturn
act_stage2_config(NMDevice *device, NMDeviceStateReason *out_failure_reason)
{
NMDeviceIwd * self = NM_DEVICE_IWD(device);
NMDeviceIwdPrivate *priv = NM_DEVICE_IWD_GET_PRIVATE(self);
NMActRequest * req;
NMConnection * connection;
NMSettingWireless * s_wireless;
const char * mode;
req = nm_device_get_act_request(device);
connection = nm_act_request_get_applied_connection(req);
s_wireless = nm_connection_get_setting_wireless(connection);
g_return_val_if_fail(s_wireless, NM_ACT_STAGE_RETURN_FAILURE);
mode = nm_setting_wireless_get_mode(s_wireless);
if (NM_IN_STRSET(mode, NULL, NM_SETTING_WIRELESS_MODE_INFRA)) {
gs_unref_object GDBusProxy *network_proxy = NULL;
NMWifiAP * ap = priv->current_ap;
NMSettingWirelessSecurity * s_wireless_sec;
if (!ap) {
NM_SET_OUT(out_failure_reason, NM_DEVICE_STATE_REASON_SUPPLICANT_FAILED);
goto out_fail;
}
/* With priv->iwd_autoconnect, if we're assuming a connection because
* of a state change to "connecting", signal stage 2 is still running.
* If "connected" or "roaming", we can go right to the IP_CONFIG state
* and there's nothing left to do in CONFIG.
* If we're assuming the connection because of an agent request we
* switch to NEED_AUTH and actually send the request now that we
* have an activation request.
*
* This all assumes ConnectedNetwork hasn't changed.
*/
if (priv->assumed_ac) {
gboolean result;
if (!priv->pending_agent_request) {
gs_unref_variant GVariant *value =
g_dbus_proxy_get_cached_property(priv->dbus_station_proxy, "State");
if (nm_streq(get_variant_state(value), "connecting")) {
return NM_ACT_STAGE_RETURN_POSTPONE;
} else {
/* This basically forgets that the connection was "assumed"
* as we can treat it like any connection triggered by a
* Network.Connect() call from now on.
*/
assumed_connection_progress_to_ip_config(self, FALSE);
return NM_ACT_STAGE_RETURN_SUCCESS;
}
}
result = nm_device_iwd_agent_query(self, priv->pending_agent_request);
g_clear_object(&priv->pending_agent_request);
nm_assert(result);
return NM_ACT_STAGE_RETURN_POSTPONE;
}
/* 802.1x networks that are not IWD Known Networks will definitely
* fail, for other combinations we will let the Connect call fail
* or ask us for any missing secrets through the Agent.
*/
if (nm_connection_get_setting_802_1x(connection) && !is_ap_known_network(ap)) {
_LOGI(LOGD_DEVICE | LOGD_WIFI,
"Activation: (wifi) access point '%s' has 802.1x security but is not configured "
"in IWD.",
nm_connection_get_id(connection));
NM_SET_OUT(out_failure_reason, NM_DEVICE_STATE_REASON_NO_SECRETS);
goto out_fail;
}
priv->secrets_failed = FALSE;
if (nm_wifi_ap_get_fake(ap)) {
gs_free char *ssid = NULL;
if (!nm_setting_wireless_get_hidden(s_wireless)) {
_LOGW(LOGD_DEVICE | LOGD_WIFI,
"Activation: (wifi) target network not known to IWD but is not "
"marked hidden");
NM_SET_OUT(out_failure_reason, NM_DEVICE_STATE_REASON_SUPPLICANT_FAILED);
goto out_fail;
}
if (!nm_wifi_connection_get_iwd_ssid_and_security(connection, &ssid, NULL)) {
NM_SET_OUT(out_failure_reason, NM_DEVICE_STATE_REASON_SUPPLICANT_FAILED);
goto out_fail;
}
/* Use Station.ConnectHiddenNetwork method instead of Network proxy. */
g_dbus_proxy_call(priv->dbus_station_proxy,
"ConnectHiddenNetwork",
g_variant_new("(s)", ssid),
G_DBUS_CALL_FLAGS_NONE,
G_MAXINT,
priv->cancellable,
network_connect_cb,
self);
return NM_ACT_STAGE_RETURN_POSTPONE;
}
network_proxy = nm_iwd_manager_get_dbus_interface(
nm_iwd_manager_get(),
nm_ref_string_get_str(nm_wifi_ap_get_supplicant_path(ap)),
NM_IWD_NETWORK_INTERFACE);
if (!network_proxy) {
_LOGW(LOGD_DEVICE | LOGD_WIFI,
"Activation: (wifi) could not get Network interface proxy for %s",
nm_ref_string_get_str(nm_wifi_ap_get_supplicant_path(ap)));
NM_SET_OUT(out_failure_reason, NM_DEVICE_STATE_REASON_SUPPLICANT_FAILED);
goto out_fail;
}
if (!priv->cancellable)
priv->cancellable = g_cancellable_new();
s_wireless_sec = nm_connection_get_setting_wireless_security(connection);
if (s_wireless_sec
&& nm_streq0(nm_setting_wireless_security_get_key_mgmt(s_wireless_sec), "owe")) {
_LOGI(LOGD_WIFI,
"An OWE connection is requested but IWD may connect to either an OWE "
"or unsecured network and there won't be any indication of whether "
"encryption is in use -- proceed at your own risk!");
}
/* Call Network.Connect. No timeout because IWD already handles
* timeouts.
*/
g_dbus_proxy_call(network_proxy,
"Connect",
NULL,
G_DBUS_CALL_FLAGS_NONE,
G_MAXINT,
priv->cancellable,
network_connect_cb,
self);
return NM_ACT_STAGE_RETURN_POSTPONE;
}
if (NM_IN_STRSET(mode, NM_SETTING_WIRELESS_MODE_AP, NM_SETTING_WIRELESS_MODE_ADHOC)) {
NMSettingWirelessSecurity *s_wireless_sec;
s_wireless_sec = nm_connection_get_setting_wireless_security(connection);
if (s_wireless_sec && !nm_setting_wireless_security_get_psk(s_wireless_sec)) {
/* PSK is missing from the settings, have to request it */
wifi_secrets_cancel(self);
priv->wifi_secrets_id =
nm_act_request_get_secrets(req,
TRUE,
NM_SETTING_WIRELESS_SECURITY_SETTING_NAME,
NM_SECRET_AGENT_GET_SECRETS_FLAG_ALLOW_INTERACTION,
NM_MAKE_STRV(NM_SETTING_WIRELESS_SECURITY_PSK),
act_psk_cb,
self);
nm_device_state_changed(device, NM_DEVICE_STATE_NEED_AUTH, NM_DEVICE_STATE_REASON_NONE);
} else
act_set_mode(self);
return NM_ACT_STAGE_RETURN_POSTPONE;
}
_LOGW(LOGD_DEVICE | LOGD_WIFI, "Activation: (wifi) iwd cannot handle mode %s", mode);
NM_SET_OUT(out_failure_reason, NM_DEVICE_STATE_REASON_SUPPLICANT_FAILED);
out_fail:
cleanup_association_attempt(self, FALSE);
return NM_ACT_STAGE_RETURN_FAILURE;
}
static guint32
get_configured_mtu(NMDevice *device, NMDeviceMtuSource *out_source, gboolean *out_force)
{
return nm_device_get_configured_mtu_from_connection(device,
NM_TYPE_SETTING_WIRELESS,
out_source);
}
static gboolean
periodic_scan_timeout_cb(gpointer user_data)
{
NMDeviceIwd * self = user_data;
NMDeviceIwdPrivate *priv = NM_DEVICE_IWD_GET_PRIVATE(self);
priv->periodic_scan_id = 0;
if (priv->scanning || priv->scan_requested)
return FALSE;
g_dbus_proxy_call(priv->dbus_station_proxy,
"Scan",
NULL,
G_DBUS_CALL_FLAGS_NONE,
-1,
priv->cancellable,
scan_cb,
self);
priv->scan_requested = TRUE;
return FALSE;
}
static void
schedule_periodic_scan(NMDeviceIwd *self, gboolean initial_scan)
{
NMDeviceIwdPrivate *priv = NM_DEVICE_IWD_GET_PRIVATE(self);
guint interval;
/* Automatically start a scan after a disconnect, mode change or device UP,
* otherwise scan periodically every 10 seconds if needed for NM's
* autoconnect. There's no need to scan When using IWD's autoconnect or
* when connected, we update the AP list on UI requests.
*
* (initial_scan && disconnected && !priv->iwd_autoconnect) override
* priv->scanning below because of an IWD quirk where a device will often
* be in the autoconnect state and scanning at the time of our initial_scan,
* but our logic will then send it a Disconnect() causing IWD to exit
* autoconnect and interrupt the ongoing scan, meaning that we still want
* a new scan ASAP.
*/
if (!priv->can_scan || priv->scan_requested || priv->current_ap || priv->iwd_autoconnect)
interval = -1;
else if (initial_scan && priv->scanning)
interval = 0;
else if (priv->scanning)
interval = -1;
else if (!priv->periodic_scan_id)
interval = 10;
else
return;
nm_clear_g_source(&priv->periodic_scan_id);
if (interval != (guint) -1)
priv->periodic_scan_id = g_timeout_add_seconds(interval, periodic_scan_timeout_cb, self);
}
static void
set_can_scan(NMDeviceIwd *self, gboolean can_scan)
{
NMDeviceIwdPrivate *priv = NM_DEVICE_IWD_GET_PRIVATE(self);
if (priv->can_scan == can_scan)
return;
priv->can_scan = can_scan;
if (!priv->iwd_autoconnect)
schedule_periodic_scan(self, TRUE);
}
static void
device_state_changed(NMDevice * device,
NMDeviceState new_state,
NMDeviceState old_state,
NMDeviceStateReason reason)
{
NMDeviceIwd * self = NM_DEVICE_IWD(device);
NMDeviceIwdPrivate *priv = NM_DEVICE_IWD_GET_PRIVATE(self);
NMSettingWireless * s_wireless;
const char * mode;
switch (new_state) {
case NM_DEVICE_STATE_UNMANAGED:
break;
case NM_DEVICE_STATE_UNAVAILABLE:
/*
* If the device is enabled and the IWD manager is ready,
* transition to DISCONNECTED because the device is now
* ready to use.
*/
if (priv->enabled && priv->dbus_station_proxy) {
nm_device_queue_recheck_available(device,
NM_DEVICE_STATE_REASON_SUPPLICANT_AVAILABLE,
NM_DEVICE_STATE_REASON_SUPPLICANT_FAILED);
}
break;
case NM_DEVICE_STATE_DISCONNECTED:
if (old_state == NM_DEVICE_STATE_UNAVAILABLE)
initial_check_assume(self);
break;
case NM_DEVICE_STATE_IP_CONFIG:
s_wireless =
(NMSettingWireless *) nm_device_get_applied_setting(device, NM_TYPE_SETTING_WIRELESS);
mode = nm_setting_wireless_get_mode(s_wireless);
if (!priv->periodic_update_id
&& NM_IN_STRSET(mode,
NULL,
NM_SETTING_WIRELESS_MODE_INFRA,
NM_SETTING_WIRELESS_MODE_ADHOC)) {
priv->periodic_update_id = g_timeout_add_seconds(6, periodic_update_cb, self);
periodic_update(self);
}
break;
default:
break;
}
}
static gboolean
get_enabled(NMDevice *device)
{
return NM_DEVICE_IWD_GET_PRIVATE(device)->enabled;
}
static void
set_enabled(NMDevice *device, gboolean enabled)
{
NMDeviceIwd * self = NM_DEVICE_IWD(device);
NMDeviceIwdPrivate *priv = NM_DEVICE_IWD_GET_PRIVATE(self);
NMDeviceState state;
enabled = !!enabled;
if (priv->enabled == enabled)
return;
priv->enabled = enabled;
_LOGD(LOGD_WIFI, "device now %s", enabled ? "enabled" : "disabled");
state = nm_device_get_state(device);
if (state < NM_DEVICE_STATE_UNAVAILABLE) {
_LOGD(LOGD_WIFI, "(%s): device blocked by UNMANAGED state", enabled ? "enable" : "disable");
return;
}
if (priv->dbus_obj)
set_powered(self, enabled);
if (enabled) {
if (state != NM_DEVICE_STATE_UNAVAILABLE)
_LOGW(LOGD_CORE, "not in expected unavailable state!");
if (priv->dbus_station_proxy) {
nm_device_queue_recheck_available(device,
NM_DEVICE_STATE_REASON_SUPPLICANT_AVAILABLE,
NM_DEVICE_STATE_REASON_SUPPLICANT_FAILED);
}
} else {
nm_device_state_changed(device, NM_DEVICE_STATE_UNAVAILABLE, NM_DEVICE_STATE_REASON_NONE);
}
}
static gboolean
can_reapply_change(NMDevice * device,
const char *setting_name,
NMSetting * s_old,
NMSetting * s_new,
GHashTable *diffs,
GError ** error)
{
NMDeviceClass *device_class;
/* Only handle wireless setting here, delegate other settings to parent class */
if (nm_streq(setting_name, NM_SETTING_WIRELESS_SETTING_NAME)) {
return nm_device_hash_check_invalid_keys(
diffs,
NM_SETTING_WIRELESS_SETTING_NAME,
error,
NM_SETTING_WIRELESS_SEEN_BSSIDS, /* ignored */
NM_SETTING_WIRELESS_MTU); /* reapplied with IP config */
}
device_class = NM_DEVICE_CLASS(nm_device_iwd_parent_class);
return device_class->can_reapply_change(device, setting_name, s_old, s_new, diffs, error);
}
/*****************************************************************************/
static void
get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
{
NMDeviceIwd * self = NM_DEVICE_IWD(object);
NMDeviceIwdPrivate *priv = NM_DEVICE_IWD_GET_PRIVATE(self);
const char ** list;
switch (prop_id) {
case PROP_MODE:
if (!priv->current_ap)
g_value_set_uint(value, NM_802_11_MODE_UNKNOWN);
else if (nm_wifi_ap_is_hotspot(priv->current_ap))
g_value_set_uint(value, NM_802_11_MODE_AP);
else
g_value_set_uint(value, nm_wifi_ap_get_mode(priv->current_ap));
break;
case PROP_BITRATE:
g_value_set_uint(value, priv->rate);
break;
case PROP_CAPABILITIES:
g_value_set_uint(value, priv->capabilities);
break;
case PROP_ACCESS_POINTS:
list = nm_wifi_aps_get_paths(&priv->aps_lst_head, TRUE);
g_value_take_boxed(value, nm_utils_strv_make_deep_copied(list));
break;
case PROP_ACTIVE_ACCESS_POINT:
nm_dbus_utils_g_value_set_object_path(value, priv->current_ap);
break;
case PROP_SCANNING:
g_value_set_boolean(value, priv->scanning);
break;
case PROP_LAST_SCAN:
g_value_set_int64(
value,
priv->last_scan > 0
? nm_utils_monotonic_timestamp_as_boottime(priv->last_scan, NM_UTILS_NSEC_PER_MSEC)
: (gint64) -1);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
break;
}
}
/*****************************************************************************/
static void
state_changed(NMDeviceIwd *self, const char *new_state)
{
NMDeviceIwdPrivate *priv = NM_DEVICE_IWD_GET_PRIVATE(self);
NMDevice * device = NM_DEVICE(self);
NMDeviceState dev_state = nm_device_get_state(device);
gboolean nm_connection = priv->current_ap || priv->assumed_ac;
gboolean iwd_connection = FALSE;
NMWifiAP * ap = NULL;
gboolean can_connect = priv->nm_autoconnect;
_LOGI(LOGD_DEVICE | LOGD_WIFI, "new IWD device state is %s", new_state);
if (NM_IN_STRSET(new_state, "connecting", "connected", "roaming")) {
gs_unref_variant GVariant *value = NULL;
const char * network_path_str;
nm_auto_ref_string NMRefString *network_path = NULL;
value = g_dbus_proxy_get_cached_property(priv->dbus_station_proxy, "ConnectedNetwork");
if (!value || !g_variant_is_of_type(value, G_VARIANT_TYPE_OBJECT_PATH)) {
_LOGW(LOGD_DEVICE | LOGD_WIFI,
"ConnectedNetwork property not cached or not an object path");
return;
}
iwd_connection = TRUE;
network_path_str = g_variant_get_string(value, NULL);
network_path = nm_ref_string_new(network_path_str);
ap = find_ap_by_supplicant_path(self, network_path);
if (!ap) {
_LOGW(LOGD_DEVICE | LOGD_WIFI,
"ConnectedNetwork points to an unknown Network %s",
network_path_str);
return;
}
}
/* Don't allow scanning while connecting, disconnecting or roaming */
set_can_scan(self, NM_IN_STRSET(new_state, "connected", "disconnected"));
priv->nm_autoconnect = FALSE;
if (nm_connection && iwd_connection && priv->current_ap && ap != priv->current_ap) {
gboolean switch_ap = priv->iwd_autoconnect && priv->assumed_ac;
_LOGW(LOGD_DEVICE | LOGD_WIFI,
"IWD is connecting to the wrong AP, %s activation",
switch_ap ? "replacing" : "aborting");
cleanup_association_attempt(self, !switch_ap);
nm_device_state_changed(device,
NM_DEVICE_STATE_FAILED,
NM_DEVICE_STATE_REASON_SUPPLICANT_DISCONNECT);
if (switch_ap)
assume_connection(self, ap);
return;
}
if (priv->iwd_autoconnect && iwd_connection) {
if (dev_state < NM_DEVICE_STATE_DISCONNECTED)
return;
/* If IWD is in any state other than disconnected and the NMDevice is
* in DISCONNECTED then someone else, possibly IWD's autoconnect, has
* commanded an action and we need to update our NMDevice's state to
* match, including finding the NMSettingsConnection and NMWifiAP
* matching the network pointed to by Station.ConnectedNetwork.
*
* If IWD is in the connected state and we're in CONFIG, we only have
* to signal that the existing connection request has advanced to a new
* state. If the connection request came from NM, we must have used
* Network.Connect() so that method call's callback will update the
* connection request, otherwise we do it here.
*
* If IWD is disconnecting or just disconnected, the common code below
* (independent from priv->iwd_autoconnect) will handle this case.
* If IWD is disconnecting but we never saw a connection request in the
* first place (maybe because we're only startig up) we won't be
* setting up an NMActiveConnection just to put the NMDevice in the
* DEACTIVATING state and we ignore this case.
*
* If IWD was in the disconnected state and transitioned to
* "connecting" but we were already in NEED_AUTH because we handled an
* agent query -- IWD normally stays in "disconnected" until it has all
* the secrets -- we record this fact and remain in NEED_AUTH.
*/
if (!nm_connection) {
_LOGD(LOGD_DEVICE | LOGD_WIFI, "This is a new connection, 'assuming' it");
assume_connection(self, ap);
return;
}
if (priv->assumed_ac && dev_state >= NM_DEVICE_STATE_PREPARE
&& dev_state < NM_DEVICE_STATE_IP_CONFIG
&& NM_IN_STRSET(new_state, "connected", "roaming")) {
_LOGD(LOGD_DEVICE | LOGD_WIFI, "Updating assumed activation state");
assumed_connection_progress_to_ip_config(self, TRUE);
return;
}
if (priv->assumed_ac) {
_LOGD(LOGD_DEVICE | LOGD_WIFI, "Clearing assumed activation timeout");
nm_clear_g_source(&priv->assumed_ac_timeout);
return;
}
} else if (!priv->iwd_autoconnect && iwd_connection) {
/* If we were connecting, do nothing, the confirmation of
* a connection success is handled in the Device.Connect
* method return callback. Otherwise, IWD must have connected
* without Network Manager's will so for simplicity force a
* disconnect.
*/
if (nm_connection)
return;
_LOGW(LOGD_DEVICE | LOGD_WIFI, "Unsolicited connection, asking IWD to disconnect");
send_disconnect(self);
} else if (NM_IN_STRSET(new_state, "disconnecting", "disconnected")) {
/* If necessary, call Disconnect on the IWD device object to make sure
* it disables its autoconnect.
*/
if ((!priv->iwd_autoconnect
|| nm_device_autoconnect_blocked_get(device, NM_DEVICE_AUTOCONNECT_BLOCKED_ALL))
&& !priv->wifi_secrets_id && !priv->pending_agent_request)
send_disconnect(self);
/*
* If IWD is still handling the Connect call, let our Connect
* callback for the dbus method handle the failure. The main
* reason we don't want to handle the failure here is because the
* method callback will have more information on the specific
* failure reason.
*
* If IWD is handling an autoconnect agent call, let the agent's
* Cancel() handler take care of this.
*/
if (NM_IN_SET(dev_state, NM_DEVICE_STATE_CONFIG, NM_DEVICE_STATE_NEED_AUTH)
&& !priv->assumed_ac)
return;
if (NM_IN_SET(dev_state, NM_DEVICE_STATE_NEED_AUTH) && priv->assumed_ac)
return;
if (nm_connection) {
cleanup_association_attempt(self, FALSE);
nm_device_state_changed(device,
NM_DEVICE_STATE_FAILED,
NM_DEVICE_STATE_REASON_SUPPLICANT_DISCONNECT);
}
} else if (!nm_streq(new_state, "unknown")) {
_LOGE(LOGD_WIFI, "State %s unknown", new_state);
return;
}
/* Don't allow new connection until iwd exits disconnecting and no
* Connect callback is pending.
*/
if (!priv->iwd_autoconnect && NM_IN_STRSET(new_state, "disconnected")) {
priv->nm_autoconnect = TRUE;
if (!can_connect)
nm_device_emit_recheck_auto_activate(device);
}
}
static void
scanning_changed(NMDeviceIwd *self, gboolean new_scanning)
{
NMDeviceIwdPrivate *priv = NM_DEVICE_IWD_GET_PRIVATE(self);
if (new_scanning == priv->scanning)
return;
priv->scanning = new_scanning;
_notify(self, PROP_SCANNING);
if (!priv->scanning) {
update_aps(self);
if (!priv->scan_requested && !priv->iwd_autoconnect)
schedule_periodic_scan(self, FALSE);
}
}
static void
station_properties_changed(GDBusProxy *proxy,
GVariant * changed_properties,
GStrv invalidate_properties,
gpointer user_data)
{
NMDeviceIwd *self = user_data;
const char * new_str;
gboolean new_bool;
if (g_variant_lookup(changed_properties, "State", "&s", &new_str))
state_changed(self, new_str);
if (g_variant_lookup(changed_properties, "Scanning", "b", &new_bool))
scanning_changed(self, new_bool);
}
static void
ap_adhoc_properties_changed(GDBusProxy *proxy,
GVariant * changed_properties,
GStrv invalidate_properties,
gpointer user_data)
{
NMDeviceIwd *self = user_data;
gboolean new_bool;
if (g_variant_lookup(changed_properties, "Started", "b", &new_bool))
_LOGI(LOGD_DEVICE | LOGD_WIFI,
"IWD AP/AdHoc state is now %s",
new_bool ? "Started" : "Stopped");
}
static void
powered_changed(NMDeviceIwd *self, gboolean new_powered)
{
NMDeviceIwdPrivate *priv = NM_DEVICE_IWD_GET_PRIVATE(self);
GDBusInterface * interface;
nm_device_queue_recheck_available(NM_DEVICE(self),
NM_DEVICE_STATE_REASON_SUPPLICANT_AVAILABLE,
NM_DEVICE_STATE_REASON_SUPPLICANT_FAILED);
interface =
new_powered ? g_dbus_object_get_interface(priv->dbus_obj, NM_IWD_AP_INTERFACE) : NULL;
if (priv->dbus_ap_proxy) {
g_signal_handlers_disconnect_by_func(priv->dbus_ap_proxy,
ap_adhoc_properties_changed,
self);
g_clear_object(&priv->dbus_ap_proxy);
}
if (interface) {
priv->dbus_ap_proxy = G_DBUS_PROXY(interface);
g_signal_connect(priv->dbus_ap_proxy,
"g-properties-changed",
G_CALLBACK(ap_adhoc_properties_changed),
self);
if (priv->act_mode_switch)
act_check_interface(self);
else
reset_mode(self, NULL, NULL, NULL);
}
interface =
new_powered ? g_dbus_object_get_interface(priv->dbus_obj, NM_IWD_ADHOC_INTERFACE) : NULL;
if (priv->dbus_adhoc_proxy) {
g_signal_handlers_disconnect_by_func(priv->dbus_adhoc_proxy,
ap_adhoc_properties_changed,
self);
g_clear_object(&priv->dbus_adhoc_proxy);
}
if (interface) {
priv->dbus_adhoc_proxy = G_DBUS_PROXY(interface);
g_signal_connect(priv->dbus_adhoc_proxy,
"g-properties-changed",
G_CALLBACK(ap_adhoc_properties_changed),
self);
if (priv->act_mode_switch)
act_check_interface(self);
else
reset_mode(self, NULL, NULL, NULL);
}
/* We expect one of the three interfaces to always be present when
* device is Powered so if AP and AdHoc are not present we should
* be in station mode.
*/
if (new_powered && !priv->dbus_ap_proxy && !priv->dbus_adhoc_proxy) {
interface = g_dbus_object_get_interface(priv->dbus_obj, NM_IWD_STATION_INTERFACE);
if (!interface) {
_LOGE(LOGD_WIFI,
"Interface %s not found on obj %s",
NM_IWD_STATION_INTERFACE,
g_dbus_object_get_object_path(priv->dbus_obj));
interface = NULL;
}
} else
interface = NULL;
if (priv->dbus_station_proxy) {
g_signal_handlers_disconnect_by_func(priv->dbus_station_proxy,
station_properties_changed,
self);
g_clear_object(&priv->dbus_station_proxy);
}
if (interface) {
GVariant *value;
priv->dbus_station_proxy = G_DBUS_PROXY(interface);
g_signal_connect(priv->dbus_station_proxy,
"g-properties-changed",
G_CALLBACK(station_properties_changed),
self);
value = g_dbus_proxy_get_cached_property(priv->dbus_station_proxy, "Scanning");
priv->scanning = get_variant_boolean(value, "Scanning");
g_variant_unref(value);
value = g_dbus_proxy_get_cached_property(priv->dbus_station_proxy, "State");
state_changed(self, get_variant_state(value));
g_variant_unref(value);
update_aps(self);
/* When a device is brought UP in station mode, including after a mode
* switch, IWD re-enables autoconnect. This is unlike NM's autoconnect
* where a mode change doesn't interfere with the
* BLOCKED_MANUAL_DISCONNECT flag.
*/
if (priv->iwd_autoconnect) {
nm_device_autoconnect_blocked_unset(NM_DEVICE(self),
NM_DEVICE_AUTOCONNECT_BLOCKED_INTERNAL);
}
} else {
set_can_scan(self, FALSE);
priv->scanning = FALSE;
priv->scan_requested = FALSE;
priv->nm_autoconnect = FALSE;
cleanup_association_attempt(self, FALSE);
remove_all_aps(self);
}
}
static void
device_properties_changed(GDBusProxy *proxy,
GVariant * changed_properties,
GStrv invalidate_properties,
gpointer user_data)
{
NMDeviceIwd *self = user_data;
gboolean new_bool;
if (g_variant_lookup(changed_properties, "Powered", "b", &new_bool))
powered_changed(self, new_bool);
}
static void
config_changed(NMConfig * config,
NMConfigData * config_data,
NMConfigChangeFlags changes,
NMConfigData * old_data,
NMDeviceIwd * self)
{
NMDeviceIwdPrivate *priv = NM_DEVICE_IWD_GET_PRIVATE(self);
gboolean old_iwd_ac = priv->iwd_autoconnect;
priv->iwd_autoconnect =
nm_config_data_get_device_config_boolean(config_data,
NM_CONFIG_KEYFILE_KEY_DEVICE_WIFI_IWD_AUTOCONNECT,
NM_DEVICE(self),
TRUE,
TRUE);
if (old_iwd_ac != priv->iwd_autoconnect && priv->dbus_station_proxy && !priv->current_ap) {
gs_unref_variant GVariant *value = NULL;
if (!priv->iwd_autoconnect
&& !nm_device_autoconnect_blocked_get(NM_DEVICE(self),
NM_DEVICE_AUTOCONNECT_BLOCKED_ALL))
send_disconnect(self);
value = g_dbus_proxy_get_cached_property(priv->dbus_station_proxy, "State");
state_changed(self, get_variant_state(value));
}
}
void
nm_device_iwd_set_dbus_object(NMDeviceIwd *self, GDBusObject *object)
{
NMDeviceIwdPrivate *priv = NM_DEVICE_IWD_GET_PRIVATE(self);
GDBusInterface * interface;
gs_unref_variant GVariant *value = NULL;
gs_unref_object GDBusProxy *adapter_proxy = NULL;
GVariantIter * iter;
const char * mode;
gboolean powered;
NMDeviceWifiCapabilities capabilities;
if (!nm_g_object_ref_set(&priv->dbus_obj, object))
return;
if (priv->dbus_device_proxy) {
g_signal_handlers_disconnect_by_func(priv->dbus_device_proxy,
device_properties_changed,
self);
g_clear_object(&priv->dbus_device_proxy);
powered_changed(self, FALSE);
priv->act_mode_switch = FALSE;
g_signal_handlers_disconnect_by_func(nm_config_get(), config_changed, self);
}
if (!object)
return;
interface = g_dbus_object_get_interface(object, NM_IWD_DEVICE_INTERFACE);
if (!interface) {
_LOGE(LOGD_WIFI,
"Interface %s not found on obj %s",
NM_IWD_DEVICE_INTERFACE,
g_dbus_object_get_object_path(object));
g_clear_object(&priv->dbus_obj);
return;
}
priv->dbus_device_proxy = G_DBUS_PROXY(interface);
g_signal_connect(priv->dbus_device_proxy,
"g-properties-changed",
G_CALLBACK(device_properties_changed),
self);
/* Parse list of interface modes supported by adapter (wiphy) */
value = g_dbus_proxy_get_cached_property(priv->dbus_device_proxy, "Adapter");
if (!value || !g_variant_is_of_type(value, G_VARIANT_TYPE_OBJECT_PATH)) {
nm_log_warn(LOGD_DEVICE | LOGD_WIFI, "Adapter property not cached or not an object path");
goto error;
}
adapter_proxy = nm_iwd_manager_get_dbus_interface(nm_iwd_manager_get(),
g_variant_get_string(value, NULL),
NM_IWD_WIPHY_INTERFACE);
if (!adapter_proxy) {
nm_log_warn(LOGD_DEVICE | LOGD_WIFI, "Can't get DBus proxy for IWD Adapter for IWD Device");
goto error;
}
g_variant_unref(value);
value = g_dbus_proxy_get_cached_property(adapter_proxy, "SupportedModes");
if (!value || !g_variant_is_of_type(value, G_VARIANT_TYPE_STRING_ARRAY)) {
nm_log_warn(LOGD_DEVICE | LOGD_WIFI,
"SupportedModes property not cached or not a string array");
goto error;
}
capabilities = NM_WIFI_DEVICE_CAP_CIPHER_CCMP | NM_WIFI_DEVICE_CAP_RSN;
g_variant_get(value, "as", &iter);
while (g_variant_iter_next(iter, "&s", &mode)) {
if (nm_streq(mode, "ap"))
capabilities |= NM_WIFI_DEVICE_CAP_AP;
else if (nm_streq(mode, "ad-hoc"))
capabilities |= NM_WIFI_DEVICE_CAP_ADHOC;
}
g_variant_iter_free(iter);
if (priv->capabilities != capabilities) {
priv->capabilities = capabilities;
_notify(self, PROP_CAPABILITIES);
}
/* Update iwd_autoconnect before any state_changed call */
g_signal_connect(nm_config_get(),
NM_CONFIG_SIGNAL_CONFIG_CHANGED,
G_CALLBACK(config_changed),
self);
config_changed(NULL, NM_CONFIG_GET_DATA, 0, NULL, self);
g_variant_unref(value);
value = g_dbus_proxy_get_cached_property(priv->dbus_device_proxy, "Powered");
powered = get_variant_boolean(value, "Powered");
if (powered != priv->enabled)
set_powered(self, priv->enabled);
else if (powered)
powered_changed(self, TRUE);
return;
error:
g_signal_handlers_disconnect_by_func(priv->dbus_device_proxy, device_properties_changed, self);
g_clear_object(&priv->dbus_device_proxy);
}
gboolean
nm_device_iwd_agent_query(NMDeviceIwd *self, GDBusMethodInvocation *invocation)
{
NMDevice * device = NM_DEVICE(self);
NMDeviceIwdPrivate * priv = NM_DEVICE_IWD_GET_PRIVATE(self);
NMDeviceState state = nm_device_get_state(device);
const char * setting_name;
const char * setting_key;
gboolean replied;
NMWifiAP * ap;
NMSecretAgentGetSecretsFlags get_secret_flags =
NM_SECRET_AGENT_GET_SECRETS_FLAG_ALLOW_INTERACTION;
nm_auto_ref_string NMRefString *network_path = NULL;
if (!invocation) {
gs_unref_variant GVariant *value =
g_dbus_proxy_get_cached_property(priv->dbus_station_proxy, "State");
gboolean disconnect;
if (!priv->wifi_secrets_id && !priv->pending_agent_request)
return FALSE;
_LOGI(LOGD_WIFI, "IWD agent request is being cancelled");
wifi_secrets_cancel(self);
if (state == NM_DEVICE_STATE_NEED_AUTH)
nm_device_state_changed(device, NM_DEVICE_STATE_CONFIG, NM_DEVICE_STATE_REASON_NONE);
/* The secrets request is being cancelled. If we don't have an assumed
* connection than we've probably called Network.Connect and that method
* call's callback is going to handle the failure. And if the state was
* not "disconnected" then let the state change handler process the
* failure.
*/
if (!priv->assumed_ac)
return TRUE;
if (!nm_streq(get_variant_state(value), "disconnected"))
return TRUE;
disconnect = nm_device_autoconnect_blocked_get(device, NM_DEVICE_AUTOCONNECT_BLOCKED_ALL);
cleanup_association_attempt(self, disconnect);
nm_device_state_changed(device,
NM_DEVICE_STATE_FAILED,
NM_DEVICE_STATE_REASON_SUPPLICANT_FAILED);
return TRUE;
}
if (state > NM_DEVICE_STATE_CONFIG && state < NM_DEVICE_STATE_DEACTIVATING) {
_LOGW(LOGD_WIFI, "Can't handle the IWD agent request in current device state");
return FALSE;
}
if (priv->wifi_secrets_id || priv->pending_agent_request) {
_LOGW(LOGD_WIFI, "There's already a pending agent request for this device");
return FALSE;
}
network_path = nm_ref_string_new(get_agent_request_network_path(invocation));
ap = find_ap_by_supplicant_path(self, network_path);
if (!ap) {
_LOGW(LOGD_WIFI, "IWD Network object not found for the agent request");
return FALSE;
}
if (priv->assumed_ac) {
const char *ac_ap_path = nm_active_connection_get_specific_object(priv->assumed_ac);
if (!nm_streq(ac_ap_path, nm_dbus_object_get_path(NM_DBUS_OBJECT(ap)))) {
_LOGW(LOGD_WIFI,
"Dropping an existing assumed connection to create a new one based on the IWD "
"agent request network parameter");
if (priv->current_ap)
nm_device_state_changed(device,
NM_DEVICE_STATE_FAILED,
NM_DEVICE_STATE_REASON_SUPPLICANT_FAILED);
cleanup_association_attempt(self, FALSE);
priv->pending_agent_request = g_object_ref(invocation);
assume_connection(self, ap);
return TRUE;
}
if (state != NM_DEVICE_STATE_CONFIG) {
_LOGI(LOGD_WIFI, "IWD agent request deferred until in CONFIG");
priv->pending_agent_request = g_object_ref(invocation);
return TRUE;
}
/* Otherwise handle as usual */
} else if (!priv->current_ap) {
_LOGI(LOGD_WIFI, "IWD is asking for secrets without explicit connect request");
if (priv->iwd_autoconnect) {
priv->pending_agent_request = g_object_ref(invocation);
assume_connection(self, ap);
return TRUE;
}
send_disconnect(self);
return FALSE;
} else if (priv->current_ap) {
if (priv->current_ap != ap) {
_LOGW(LOGD_WIFI, "IWD agent request for a wrong network object");
cleanup_association_attempt(self, TRUE);
nm_device_state_changed(device,
NM_DEVICE_STATE_FAILED,
NM_DEVICE_STATE_REASON_SUPPLICANT_FAILED);
return FALSE;
}
/* Otherwise handle as usual */
}
if (!try_reply_agent_request(self,
nm_device_get_applied_connection(device),
invocation,
&setting_name,
&setting_key,
&replied)) {
priv->secrets_failed = TRUE;
return FALSE;
}
if (replied)
return TRUE;
/* Normally require new secrets every time IWD asks for them.
* IWD only queries us if it has not saved the secrets (e.g. by policy)
* or a previous attempt has failed with current secrets so it wants
* a fresh set. However if this is a new connection it may include
* all of the needed settings already so allow using these, too.
* Connection timestamp is set after activation or after first
* activation failure (to 0).
*/
if (nm_settings_connection_get_timestamp(nm_device_get_settings_connection(device), NULL))
get_secret_flags |= NM_SECRET_AGENT_GET_SECRETS_FLAG_REQUEST_NEW;
nm_device_state_changed(device, NM_DEVICE_STATE_NEED_AUTH, NM_DEVICE_STATE_REASON_NO_SECRETS);
wifi_secrets_get_one(self, setting_name, get_secret_flags, setting_key, invocation);
return TRUE;
}
void
nm_device_iwd_network_add_remove(NMDeviceIwd *self, GDBusProxy *network, bool add)
{
NMDeviceIwdPrivate *priv = NM_DEVICE_IWD_GET_PRIVATE(self);
NMWifiAP * ap = NULL;
bool recheck;
nm_auto_ref_string NMRefString *bss_path = NULL;
bss_path = nm_ref_string_new(g_dbus_proxy_get_object_path(network));
ap = find_ap_by_supplicant_path(self, bss_path);
/* We could schedule an update_aps(self) idle call here but up to IWD 1.9
* when a hidden network connection is attempted, that network is initially
* only added as a Network object but not shown in GetOrderedNetworks()
* return values, and for some corner case scenarios it's beneficial to
* have that Network reflected in our ap list so that we don't attempt
* calling ConnectHiddenNetwork() on it, as that will fail in 1.9. But we
* can skip recheck-available if we're currently scanning or in the middle
* of a GetOrderedNetworks() call as that will trigger the recheck too.
*/
recheck = priv->enabled && !priv->scanning && !priv->networks_requested;
if (!add) {
if (ap) {
ap_add_remove(self, FALSE, ap, recheck);
priv->networks_changed |= !recheck;
}
return;
}
if (!ap) {
ap = ap_from_network(self,
network,
bss_path,
nm_utils_get_monotonic_timestamp_msec(),
-10000);
if (!ap)
return;
ap_add_remove(self, TRUE, ap, recheck);
g_object_unref(ap);
priv->networks_changed |= !recheck;
return;
}
}
static void
autoconnect_changed(NMDevice *device, GParamSpec *pspec, NMDeviceIwd *self)
{
NMDeviceIwdPrivate *priv = NM_DEVICE_IWD_GET_PRIVATE(self);
gs_unref_variant GVariant *value = NULL;
/* Note IWD normally remains in "disconnected" during a secret request
* and we don't want to interrupt it by calling Station.Disconnect().
*/
if (!priv->dbus_station_proxy || !priv->iwd_autoconnect
|| !nm_device_autoconnect_blocked_get(device, NM_DEVICE_AUTOCONNECT_BLOCKED_ALL)
|| priv->wifi_secrets_id || priv->pending_agent_request)
return;
value = g_dbus_proxy_get_cached_property(priv->dbus_station_proxy, "State");
if (!nm_streq(get_variant_state(value), "disconnected"))
return;
send_disconnect(self);
}
/*****************************************************************************/
static const char *
get_type_description(NMDevice *device)
{
nm_assert(NM_IS_DEVICE_IWD(device));
return "wifi";
}
/*****************************************************************************/
static void
nm_device_iwd_init(NMDeviceIwd *self)
{
NMDeviceIwdPrivate *priv = NM_DEVICE_IWD_GET_PRIVATE(self);
c_list_init(&priv->aps_lst_head);
g_signal_connect(self, "notify::" NM_DEVICE_AUTOCONNECT, G_CALLBACK(autoconnect_changed), self);
/* Make sure the manager is running */
(void) nm_iwd_manager_get();
}
NMDevice *
nm_device_iwd_new(const char *iface)
{
return g_object_new(NM_TYPE_DEVICE_IWD,
NM_DEVICE_IFACE,
iface,
NM_DEVICE_TYPE_DESC,
"802.11 Wi-Fi",
NM_DEVICE_DEVICE_TYPE,
NM_DEVICE_TYPE_WIFI,
NM_DEVICE_LINK_TYPE,
NM_LINK_TYPE_WIFI,
NM_DEVICE_RFKILL_TYPE,
RFKILL_TYPE_WLAN,
NULL);
}
static void
dispose(GObject *object)
{
NMDeviceIwd * self = NM_DEVICE_IWD(object);
NMDeviceIwdPrivate *priv = NM_DEVICE_IWD_GET_PRIVATE(self);
nm_clear_g_cancellable(&priv->cancellable);
g_signal_handlers_disconnect_by_func(self, autoconnect_changed, self);
nm_device_iwd_set_dbus_object(self, NULL);
G_OBJECT_CLASS(nm_device_iwd_parent_class)->dispose(object);
nm_assert(c_list_is_empty(&priv->aps_lst_head));
}
static void
nm_device_iwd_class_init(NMDeviceIwdClass *klass)
{
GObjectClass * object_class = G_OBJECT_CLASS(klass);
NMDBusObjectClass *dbus_object_class = NM_DBUS_OBJECT_CLASS(klass);
NMDeviceClass * device_class = NM_DEVICE_CLASS(klass);
object_class->get_property = get_property;
object_class->dispose = dispose;
dbus_object_class->interface_infos =
NM_DBUS_INTERFACE_INFOS(&nm_interface_info_device_wireless);
device_class->connection_type_supported = NM_SETTING_WIRELESS_SETTING_NAME;
device_class->connection_type_check_compatible = NM_SETTING_WIRELESS_SETTING_NAME;
device_class->link_types = NM_DEVICE_DEFINE_LINK_TYPES(NM_LINK_TYPE_WIFI);
device_class->can_auto_connect = can_auto_connect;
device_class->is_available = is_available;
device_class->get_autoconnect_allowed = get_autoconnect_allowed;
device_class->check_connection_compatible = check_connection_compatible;
device_class->check_connection_available = check_connection_available;
device_class->complete_connection = complete_connection;
device_class->get_enabled = get_enabled;
device_class->set_enabled = set_enabled;
device_class->get_type_description = get_type_description;
device_class->act_stage1_prepare = act_stage1_prepare;
device_class->act_stage2_config = act_stage2_config;
device_class->get_configured_mtu = get_configured_mtu;
device_class->deactivate = deactivate;
device_class->deactivate_async = deactivate_async;
device_class->can_reapply_change = can_reapply_change;
/* Stage 1 needed only for the set_current_ap() call. Stage 2 is
* needed if we're assuming a connection still in the "connecting"
* state or on an agent request.
*/
device_class->act_stage1_prepare_also_for_external_or_assume = TRUE;
device_class->act_stage2_config_also_for_external_or_assume = TRUE;
device_class->state_changed = device_state_changed;
obj_properties[PROP_MODE] = g_param_spec_uint(NM_DEVICE_IWD_MODE,
"",
"",
NM_802_11_MODE_UNKNOWN,
NM_802_11_MODE_AP,
NM_802_11_MODE_INFRA,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
obj_properties[PROP_BITRATE] = g_param_spec_uint(NM_DEVICE_IWD_BITRATE,
"",
"",
0,
G_MAXUINT32,
0,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
obj_properties[PROP_ACCESS_POINTS] =
g_param_spec_boxed(NM_DEVICE_IWD_ACCESS_POINTS,
"",
"",
G_TYPE_STRV,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
obj_properties[PROP_ACTIVE_ACCESS_POINT] =
g_param_spec_string(NM_DEVICE_IWD_ACTIVE_ACCESS_POINT,
"",
"",
NULL,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
obj_properties[PROP_CAPABILITIES] =
g_param_spec_uint(NM_DEVICE_IWD_CAPABILITIES,
"",
"",
0,
G_MAXUINT32,
NM_WIFI_DEVICE_CAP_NONE,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
obj_properties[PROP_SCANNING] = g_param_spec_boolean(NM_DEVICE_IWD_SCANNING,
"",
"",
FALSE,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
obj_properties[PROP_LAST_SCAN] = g_param_spec_int64(NM_DEVICE_IWD_LAST_SCAN,
"",
"",
-1,
G_MAXINT64,
-1,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
g_object_class_install_properties(object_class, _PROPERTY_ENUMS_LAST, obj_properties);
}