fdo-mirrors/NetworkManager
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/NetworkManager/NetworkManager.git synced 2025-12-30 13:10:11 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

merge: replace usage of dbus-glib in supplicant code with GDBus (bgo #744598)

Browse source 
(cherry picked from commit 19c0de8b88)
This commit is contained in:
Dan Williams 2015-03-03 15:00:14 -06:00 • committed by Thomas Haller
commit 98c310ea8b
14 changed files with 1043 additions and 1488 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/Makefile.am
View file

@ -269,8 +269,6 @@ nm_sources = \
supplicant-manager/nm-supplicant-settings-verify.c \
supplicant-manager/nm-supplicant-settings-verify.h \
supplicant-manager/nm-supplicant-types.h \
supplicant-manager/nm-call-store.c \
supplicant-manager/nm-call-store.h \
\
vpn-manager/nm-vpn-connection.c \
vpn-manager/nm-vpn-connection.h \

4
src/devices/wifi/nm-device-wifi.c
View file

@ -156,7 +156,7 @@ static void supplicant_iface_state_cb (NMSupplicantInterface *iface,
static void supplicant_iface_new_bss_cb (NMSupplicantInterface * iface,
const char *object_path,
GHashTable *properties,
GVariant *properties,
NMDeviceWifi * self);
static void supplicant_iface_bss_updated_cb (NMSupplicantInterface *iface,
@ -1832,7 +1832,7 @@ schedule_scanlist_cull (NMDeviceWifi *self)
static void
supplicant_iface_new_bss_cb (NMSupplicantInterface *iface,
const char *object_path,
GHashTable *properties,
GVariant *properties,
NMDeviceWifi *self)
{
NMDeviceState state;

241
src/devices/wifi/nm-wifi-ap.c
View file

@ -30,6 +30,7 @@
#include "nm-utils.h"
#include "nm-logging.h"
#include "nm-dbus-manager.h"
#include "nm-core-internal.h"
#include "nm-setting-wireless.h"
#include "nm-glib-compat.h"
@ -330,163 +331,131 @@ nm_ap_new (void)
}
static NM80211ApSecurityFlags
pair_to_flags (const char *str)
security_from_vardict (GVariant *security)
{
g_return_val_if_fail (str != NULL, NM_802_11_AP_SEC_NONE);
if (strcmp (str, "tkip") == 0)
return NM_802_11_AP_SEC_PAIR_TKIP;
if (strcmp (str, "ccmp") == 0)
return NM_802_11_AP_SEC_PAIR_CCMP;
return NM_802_11_AP_SEC_NONE;
}
static NM80211ApSecurityFlags
group_to_flags (const char *str)
{
g_return_val_if_fail (str != NULL, NM_802_11_AP_SEC_NONE);
if (strcmp (str, "wep40") == 0)
return NM_802_11_AP_SEC_GROUP_WEP40;
if (strcmp (str, "wep104") == 0)
return NM_802_11_AP_SEC_GROUP_WEP104;
if (strcmp (str, "tkip") == 0)
return NM_802_11_AP_SEC_GROUP_TKIP;
if (strcmp (str, "ccmp") == 0)
return NM_802_11_AP_SEC_GROUP_CCMP;
return NM_802_11_AP_SEC_NONE;
}
static NM80211ApSecurityFlags
security_from_dict (GHashTable *security)
{
GValue *value;
NM80211ApSecurityFlags flags = NM_802_11_AP_SEC_NONE;
const char **items, **iter;
const char **array, *tmp;
value = g_hash_table_lookup (security, "KeyMgmt");
if (value) {
items = g_value_get_boxed (value);
for (iter = items; iter && *iter; iter++) {
if (strcmp (*iter, "wpa-psk") == 0)
flags |= NM_802_11_AP_SEC_KEY_MGMT_PSK;
else if (strcmp (*iter, "wpa-eap") == 0)
flags |= NM_802_11_AP_SEC_KEY_MGMT_802_1X;
}
g_return_val_if_fail (g_variant_is_of_type (security, G_VARIANT_TYPE_VARDICT), NM_802_11_AP_SEC_NONE);
if (g_variant_lookup (security, "KeyMgmt", "^a&s", &array)) {
if (_nm_utils_string_in_list ("wpa-psk", array))
flags |= NM_802_11_AP_SEC_KEY_MGMT_PSK;
if (_nm_utils_string_in_list ("wpa-eap", array))
flags |= NM_802_11_AP_SEC_KEY_MGMT_802_1X;
g_free (array);
}
value = g_hash_table_lookup (security, "Pairwise");
if (value) {
items = g_value_get_boxed (value);
for (iter = items; iter && *iter; iter++)
flags |= pair_to_flags (*iter);
if (g_variant_lookup (security, "Pairwise", "^a&s", &array)) {
if (_nm_utils_string_in_list ("tkip", array))
flags |= NM_802_11_AP_SEC_PAIR_TKIP;
if (_nm_utils_string_in_list ("ccmp", array))
flags |= NM_802_11_AP_SEC_PAIR_CCMP;
g_free (array);
}
value = g_hash_table_lookup (security, "Group");
if (value)
flags |= group_to_flags (g_value_get_string (value));
if (g_variant_lookup (security, "Group", "&s", &tmp)) {
if (strcmp (tmp, "wep40") == 0)
flags |= NM_802_11_AP_SEC_GROUP_WEP40;
if (strcmp (tmp, "wep104") == 0)
flags |= NM_802_11_AP_SEC_GROUP_WEP104;
if (strcmp (tmp, "tkip") == 0)
flags |= NM_802_11_AP_SEC_GROUP_TKIP;
if (strcmp (tmp, "ccmp") == 0)
flags |= NM_802_11_AP_SEC_GROUP_CCMP;
}
return flags;
}
static void
foreach_property_cb (gpointer key, gpointer value, gpointer user_data)
{
GValue *variant = (GValue *) value;
NMAccessPoint *ap = (NMAccessPoint *) user_data;
if (G_VALUE_HOLDS_BOXED (variant)) {
GArray *array = g_value_get_boxed (variant);
if (!strcmp (key, "SSID")) {
guint32 len = MIN (32, array->len);
/* Stupid ieee80211 layer uses <hidden> */
if (((len == 8) || (len == 9))
&& (memcmp (array->data, "<hidden>", 8) == 0))
return;
if (nm_utils_is_empty_ssid ((const guint8 *) array->data, len))
return;
nm_ap_set_ssid (ap, (const guint8 *) array->data, len);
} else if (!strcmp (key, "BSSID")) {
char *addr;
if (array->len != ETH_ALEN)
return;
addr = nm_utils_hwaddr_ntoa (array->data, array->len);
nm_ap_set_address (ap, addr);
g_free (addr);
} else if (!strcmp (key, "Rates")) {
guint32 maxrate = 0;
int i;
/* Find the max AP rate */
for (i = 0; i < array->len; i++) {
guint32 r = g_array_index (array, guint32, i);
if (r > maxrate) {
maxrate = r;
nm_ap_set_max_bitrate (ap, r / 1000);
}
}
} else if (!strcmp (key, "WPA")) {
NM80211ApSecurityFlags flags = nm_ap_get_wpa_flags (ap);
flags |= security_from_dict (g_value_get_boxed (variant));
nm_ap_set_wpa_flags (ap, flags);
} else if (!strcmp (key, "RSN")) {
NM80211ApSecurityFlags flags = nm_ap_get_rsn_flags (ap);
flags |= security_from_dict (g_value_get_boxed (variant));
nm_ap_set_rsn_flags (ap, flags);
}
} else if (G_VALUE_HOLDS_UINT (variant)) {
guint32 val = g_value_get_uint (variant);
if (!strcmp (key, "Frequency"))
nm_ap_set_freq (ap, val);
} else if (G_VALUE_HOLDS_INT (variant)) {
gint val = g_value_get_int (variant);
if (!strcmp (key, "Signal"))
nm_ap_set_strength (ap, nm_ap_utils_level_to_quality (val));
} else if (G_VALUE_HOLDS_STRING (variant)) {
const char *val = g_value_get_string (variant);
if (val && !strcmp (key, "Mode")) {
if (strcmp (val, "infrastructure") == 0)
nm_ap_set_mode (ap, NM_802_11_MODE_INFRA);
else if (strcmp (val, "ad-hoc") == 0)
nm_ap_set_mode (ap, NM_802_11_MODE_ADHOC);
}
} else if (G_VALUE_HOLDS_BOOLEAN (variant)) {
gboolean val = g_value_get_boolean (variant);
if (strcmp (key, "Privacy") == 0) {
if (val) {
NM80211ApFlags flags = nm_ap_get_flags (ap);
nm_ap_set_flags (ap, flags | NM_802_11_AP_FLAGS_PRIVACY);
}
}
}
}
NMAccessPoint *
nm_ap_new_from_properties (const char *supplicant_path, GHashTable *properties)
nm_ap_new_from_properties (const char *supplicant_path, GVariant *properties)
{
NMAccessPoint *ap;
const char *addr;
const char bad_bssid1[ETH_ALEN] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
const char bad_bssid2[ETH_ALEN] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
const char *addr;
const guint8 *bytes;
NMAccessPoint *ap;
GVariant *v;
gsize len;
gboolean b = FALSE;
const char *s;
gint16 i16;
guint16 u16;
g_return_val_if_fail (properties != NULL, NULL);
ap = nm_ap_new ();
g_object_freeze_notify (G_OBJECT (ap));
g_hash_table_foreach (properties, foreach_property_cb, ap);
if (g_variant_lookup (properties, "Privacy", "b", &b) && b)
nm_ap_set_flags (ap, nm_ap_get_flags (ap) | NM_802_11_AP_FLAGS_PRIVACY);
if (g_variant_lookup (properties, "Mode", "&s", &s)) {
if (!g_strcmp0 (s, "infrastructure"))
nm_ap_set_mode (ap, NM_802_11_MODE_INFRA);
else if (!g_strcmp0 (s, "ad-hoc"))
nm_ap_set_mode (ap, NM_802_11_MODE_ADHOC);
}
if (g_variant_lookup (properties, "Signal", "n", &i16))
nm_ap_set_strength (ap, nm_ap_utils_level_to_quality (i16));
if (g_variant_lookup (properties, "Frequency", "q", &u16))
nm_ap_set_freq (ap, u16);
v = g_variant_lookup_value (properties, "SSID", G_VARIANT_TYPE_BYTESTRING);
if (v) {
bytes = g_variant_get_fixed_array (v, &len, 1);
len = MIN (32, len);
/* Stupid ieee80211 layer uses <hidden> */
if ( bytes && len
&& !(((len == 8) || (len == 9)) && !memcmp (bytes, "<hidden>", 8))
&& !nm_utils_is_empty_ssid (bytes, len))
nm_ap_set_ssid (ap, bytes, len);
g_variant_unref (v);
}
v = g_variant_lookup_value (properties, "BSSID", G_VARIANT_TYPE_BYTESTRING);
if (v) {
bytes = g_variant_get_fixed_array (v, &len, 1);
if (len == ETH_ALEN) {
addr = nm_utils_hwaddr_ntoa (bytes, len);
nm_ap_set_address (ap, addr);
}
g_variant_unref (v);
}
v = g_variant_lookup_value (properties, "Rates", G_VARIANT_TYPE ("au"));
if (v) {
const guint32 *rates = g_variant_get_fixed_array (v, &len, sizeof (guint32));
guint32 maxrate = 0;
int i;
/* Find the max AP rate */
for (i = 0; i < len; i++) {
if (rates[i] > maxrate) {
maxrate = rates[i];
nm_ap_set_max_bitrate (ap, rates[i] / 1000);
}
}
g_variant_unref (v);
}
v = g_variant_lookup_value (properties, "WPA", G_VARIANT_TYPE_VARDICT);
if (v) {
nm_ap_set_wpa_flags (ap, nm_ap_get_wpa_flags (ap) | security_from_vardict (v));
g_variant_unref (v);
}
v = g_variant_lookup_value (properties, "RSN", G_VARIANT_TYPE_VARDICT);
if (v) {
nm_ap_set_wpa_flags (ap, nm_ap_get_rsn_flags (ap) | security_from_vardict (v));
g_variant_unref (v);
}
nm_ap_set_supplicant_path (ap, supplicant_path);

2
src/devices/wifi/nm-wifi-ap.h
View file

@ -56,7 +56,7 @@ typedef struct {
GType nm_ap_get_type (void);
NMAccessPoint * nm_ap_new_from_properties (const char *supplicant_path,
GHashTable *properties);
GVariant *properties);
NMAccessPoint * nm_ap_new_fake_from_connection (NMConnection *connection);
void nm_ap_export_to_dbus (NMAccessPoint *ap);

119
src/supplicant-manager/nm-call-store.c
View file

@ -1,119 +0,0 @@
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- */
/* NetworkManager -- Network link manager
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Copyright (C) 2007 Novell, Inc.
* Copyright (C) 2010 Red Hat, Inc.
*/
#include "config.h"
#include "nm-call-store.h"
#include "nm-logging.h"
NMCallStore *
nm_call_store_new (void)
{
/* Maps { DBusGProxy :: GHashTable { DBusGProxyCall :: NULL } } */
return g_hash_table_new_full (NULL, NULL, NULL, (GDestroyNotify) g_hash_table_destroy);
}
static void
proxy_destroyed_cb (gpointer data, GObject *proxy)
{
g_hash_table_remove ((NMCallStore *) data, proxy);
}
void
nm_call_store_add (NMCallStore *store,
DBusGProxy *proxy,
DBusGProxyCall *call)
{
GHashTable *calls;
g_return_if_fail (store != NULL);
g_return_if_fail (proxy != NULL);
if (!call) {
/* Allow calling nm_call_store_add() with NULL @call for convenience.
* This way you can pass the result of dbus_g_proxy_begin_call() directly
* to nm_call_store_add() without checking for NULL. */
return;
}
calls = g_hash_table_lookup (store, proxy);
if (!calls) {
calls = g_hash_table_new (NULL, NULL);
g_hash_table_insert (store, proxy, calls);
g_object_weak_ref (G_OBJECT (proxy), proxy_destroyed_cb, store);
}
g_hash_table_add (calls, call);
}
void
nm_call_store_remove (NMCallStore *store,
DBusGProxy *proxy,
DBusGProxyCall *call)
{
GHashTable *calls;
g_return_if_fail (store != NULL);
g_return_if_fail (proxy != NULL);
g_return_if_fail (call != NULL);
calls = g_hash_table_lookup (store, proxy);
if (!calls)
return;
g_hash_table_remove (calls, call);
if (g_hash_table_size (calls) == 0) {
g_hash_table_remove (store, proxy);
g_object_weak_unref (G_OBJECT (proxy), proxy_destroyed_cb, store);
}
}
void
nm_call_store_clear (NMCallStore *store)
{
DBusGProxy *proxy;
GHashTable *calls;
GHashTableIter proxies_iter;
g_return_if_fail (store != NULL);
g_hash_table_iter_init (&proxies_iter, store);
while (g_hash_table_iter_next (&proxies_iter, (gpointer) &proxy, (gpointer) &calls)) {
GHashTableIter calls_iter;
DBusGProxyCall *call;
g_hash_table_iter_init (&calls_iter, calls);
while (g_hash_table_iter_next (&calls_iter, (gpointer) &call, NULL)) {
dbus_g_proxy_cancel_call (proxy, call);
g_hash_table_iter_remove (&calls_iter);
}
g_object_weak_unref (G_OBJECT (proxy), proxy_destroyed_cb, store);
g_hash_table_iter_remove (&proxies_iter);
}
g_assert_cmpint (g_hash_table_size (store), ==, 0);
}
void
nm_call_store_destroy (NMCallStore *store)
{
g_return_if_fail (store);
g_hash_table_destroy (store);
}

41
src/supplicant-manager/nm-call-store.h
View file

@ -1,41 +0,0 @@
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- */
/* NetworkManager -- Network link manager
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*
* (C) Copyright 2007 Novell, Inc.
*/
#ifndef __NETWORKMANAGER_CALLBACK_STORE_H__
#define __NETWORKMANAGER_CALLBACK_STORE_H__
#include <glib-object.h>
#include <dbus/dbus-glib.h>
typedef GHashTable NMCallStore;
NMCallStore *nm_call_store_new (void);
void nm_call_store_add (NMCallStore *store,
DBusGProxy *proxy,
DBusGProxyCall *call);
void nm_call_store_remove (NMCallStore *store,
DBusGProxy *proxy,
DBusGProxyCall *call);
void nm_call_store_clear (NMCallStore *store);
void nm_call_store_destroy (NMCallStore *store);
#endif /* __NETWORKMANAGER_CALLBACK_STORE_H__ */

85
src/supplicant-manager/nm-supplicant-config.c
View file

@ -260,65 +260,44 @@ nm_supplicant_config_fast_required (NMSupplicantConfig *self)
return NM_SUPPLICANT_CONFIG_GET_PRIVATE (self)->fast_required;
}
static void
get_hash_cb (gpointer key, gpointer value, gpointer user_data)
{
ConfigOption *opt = (ConfigOption *) value;
GValue *variant;
GByteArray *array;
variant = g_slice_new0 (GValue);
switch (opt->type) {
case TYPE_INT:
g_value_init (variant, G_TYPE_INT);
g_value_set_int (variant, atoi (opt->value));
break;
case TYPE_BYTES:
case TYPE_UTF8:
array = g_byte_array_sized_new (opt->len);
g_byte_array_append (array, (const guint8 *) opt->value, opt->len);
g_value_init (variant, DBUS_TYPE_G_UCHAR_ARRAY);
g_value_set_boxed (variant, array);
g_byte_array_free (array, TRUE);
break;
case TYPE_KEYWORD:
case TYPE_STRING:
g_value_init (variant, G_TYPE_STRING);
g_value_set_string (variant, opt->value);
break;
default:
g_slice_free (GValue, variant);
return;
}
g_hash_table_insert ((GHashTable *) user_data, g_strdup (key), variant);
}
static void
destroy_hash_value (gpointer data)
{
GValue *value = (GValue *) data;
g_value_unset (value);
g_slice_free (GValue, value);
}
GHashTable *
nm_supplicant_config_get_hash (NMSupplicantConfig * self)
GVariant *
nm_supplicant_config_to_variant (NMSupplicantConfig *self)
{
NMSupplicantConfigPrivate *priv;
GHashTable *hash;
GVariantBuilder builder;
GHashTableIter iter;
ConfigOption *option;
const char *key;
g_return_val_if_fail (NM_IS_SUPPLICANT_CONFIG (self), NULL);
hash = g_hash_table_new_full (g_str_hash, g_str_equal,
(GDestroyNotify) g_free,
destroy_hash_value);
priv = NM_SUPPLICANT_CONFIG_GET_PRIVATE (self);
g_hash_table_foreach (priv->config, get_hash_cb, hash);
return hash;
g_variant_builder_init (&builder, G_VARIANT_TYPE_VARDICT);
g_hash_table_iter_init (&iter, priv->config);
while (g_hash_table_iter_next (&iter, (gpointer) &key, (gpointer) &option)) {
switch (option->type) {
case TYPE_INT:
g_variant_builder_add (&builder, "{sv}", key, g_variant_new_int32 (atoi (option->value)));
break;
case TYPE_BYTES:
case TYPE_UTF8:
g_variant_builder_add (&builder, "{sv}",
key,
g_variant_new_fixed_array (G_VARIANT_TYPE_BYTE,
option->value, option->len, 1));
break;
case TYPE_KEYWORD:
case TYPE_STRING:
g_variant_builder_add (&builder, "{sv}", key, g_variant_new_string (option->value));
break;
default:
break;
}
}
return g_variant_builder_end (&builder);
}
GHashTable *

2
src/supplicant-manager/nm-supplicant-config.h
View file

@ -59,7 +59,7 @@ void nm_supplicant_config_set_ap_scan (NMSupplicantConfig *self,
gboolean nm_supplicant_config_fast_required (NMSupplicantConfig *self);
GHashTable *nm_supplicant_config_get_hash (NMSupplicantConfig *self);
GVariant *nm_supplicant_config_to_variant (NMSupplicantConfig *self);
GHashTable *nm_supplicant_config_get_blobs (NMSupplicantConfig *self);

1530
src/supplicant-manager/nm-supplicant-interface.c
View file

File diff suppressed because it is too large Load diff

6
src/supplicant-manager/nm-supplicant-interface.h
View file

@ -119,13 +119,15 @@ typedef struct {
GType nm_supplicant_interface_get_type (void);
NMSupplicantInterface * nm_supplicant_interface_new (NMSupplicantManager * smgr,
const char *ifname,
NMSupplicantInterface * nm_supplicant_interface_new (const char *ifname,
gboolean is_wireless,
gboolean fast_supported,
ApSupport ap_support,
gboolean start_now);
void nm_supplicant_interface_set_supplicant_available (NMSupplicantInterface *self,
gboolean available);
gboolean nm_supplicant_interface_set_config (NMSupplicantInterface * iface,
NMSupplicantConfig * cfg);

259
src/supplicant-manager/nm-supplicant-manager.c
View file

@ -29,9 +29,8 @@
#include "nm-supplicant-manager.h"
#include "nm-supplicant-interface.h"
#include "nm-dbus-manager.h"
#include "nm-logging.h"
#include "nm-dbus-glib-types.h"
#include "nm-core-internal.h"
#define NM_SUPPLICANT_MANAGER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), \
NM_TYPE_SUPPLICANT_MANAGER, \
@ -39,25 +38,16 @@
G_DEFINE_TYPE (NMSupplicantManager, nm_supplicant_manager, G_TYPE_OBJECT)
/* Properties */
enum {
PROP_0 = 0,
PROP_AVAILABLE,
LAST_PROP
};
typedef struct {
NMDBusManager * dbus_mgr;
guint name_owner_id;
DBusGProxy * proxy;
DBusGProxy * props_proxy;
gboolean running;
GDBusProxy * proxy;
GCancellable * cancellable;
gboolean running;
GHashTable * ifaces;
gboolean fast_supported;
ApSupport ap_support;
guint die_count_reset_id;
guint die_count;
gboolean disposed;
} NMSupplicantManagerPrivate;
/********************************************************************/
@ -92,14 +82,16 @@ nm_supplicant_manager_iface_get (NMSupplicantManager * self,
start_now = !die_count_exceeded (priv->die_count);
nm_log_dbg (LOGD_SUPPLICANT, "(%s): creating new supplicant interface", ifname);
iface = nm_supplicant_interface_new (self,
ifname,
iface = nm_supplicant_interface_new (ifname,
is_wireless,
priv->fast_supported,
priv->ap_support,
start_now);
if (iface)
g_hash_table_insert (priv->ifaces, g_strdup (ifname), iface);
if (iface) {
g_hash_table_insert (priv->ifaces,
(char *) nm_supplicant_interface_get_ifname (iface),
iface);
}
} else {
nm_log_dbg (LOGD_SUPPLICANT, "(%s): returning existing supplicant interface", ifname);
}
@ -127,35 +119,27 @@ nm_supplicant_manager_iface_release (NMSupplicantManager *self,
/* Ask wpa_supplicant to remove this interface */
op = nm_supplicant_interface_get_object_path (iface);
if (priv->running && priv->proxy && op) {
dbus_g_proxy_call_no_reply (priv->proxy, "RemoveInterface",
DBUS_TYPE_G_OBJECT_PATH, op,
G_TYPE_INVALID);
g_dbus_proxy_call (priv->proxy,
"RemoveInterface",
g_variant_new ("(o)", op),
G_DBUS_CALL_FLAGS_NONE,
3000,
NULL,
NULL,
NULL);
}
g_hash_table_remove (priv->ifaces, ifname);
}
static void
get_capabilities_cb (DBusGProxy *proxy, DBusGProxyCall *call_id, gpointer user_data)
update_capabilities (NMSupplicantManager *self)
{
NMSupplicantManager *self = NM_SUPPLICANT_MANAGER (user_data);
NMSupplicantManagerPrivate *priv = NM_SUPPLICANT_MANAGER_GET_PRIVATE (self);
NMSupplicantInterface *iface;
GHashTableIter hash_iter;
GError *error = NULL;
GHashTable *props = NULL;
GValue *value;
char **iter;
if (!dbus_g_proxy_end_call (proxy, call_id, &error,
DBUS_TYPE_G_MAP_OF_VARIANT, &props,
G_TYPE_INVALID)) {
nm_log_warn (LOGD_CORE, "Unexpected error requesting supplicant properties: (%d) %s",
error ? error->code : -1,
error && error->message ? error->message : "(unknown)");
g_clear_error (&error);
return;
}
const char **array;
GVariant *value;
/* The supplicant only advertises global capabilities if the following
* commit has been applied:
@ -167,13 +151,17 @@ get_capabilities_cb (DBusGProxy *proxy, DBusGProxyCall *call_id, gpointer user_
* dbus: Add global capabilities property
*/
priv->ap_support = AP_SUPPORT_UNKNOWN;
value = g_hash_table_lookup (props, "Capabilities");
if (value && G_VALUE_HOLDS (value, G_TYPE_STRV)) {
priv->ap_support = AP_SUPPORT_NO;
for (iter = g_value_get_boxed (value); iter && *iter; iter++) {
if (strcasecmp (*iter, "ap") == 0)
value = g_dbus_proxy_get_cached_property (priv->proxy, "Capabilities");
if (value) {
if (g_variant_is_of_type (value, G_VARIANT_TYPE_STRING_ARRAY)) {
array = g_variant_get_strv (value, NULL);
priv->ap_support = AP_SUPPORT_NO;
if (_nm_utils_string_in_list ("ap", array))
priv->ap_support = AP_SUPPORT_YES;
g_free (array);
}
g_variant_unref (value);
}
/* Tell all interfaces about results of the AP check */
@ -187,32 +175,35 @@ get_capabilities_cb (DBusGProxy *proxy, DBusGProxyCall *call_id, gpointer user_
/* EAP-FAST */
priv->fast_supported = FALSE;
value = g_hash_table_lookup (props, "EapMethods");
if (value && G_VALUE_HOLDS (value, G_TYPE_STRV)) {
for (iter = g_value_get_boxed (value); iter && *iter; iter++) {
if (strcasecmp (*iter, "fast") == 0)
value = g_dbus_proxy_get_cached_property (priv->proxy, "EapMethods");
if (value) {
if (g_variant_is_of_type (value, G_VARIANT_TYPE_STRING_ARRAY)) {
array = g_variant_get_strv (value, NULL);
if (_nm_utils_string_in_list ("fast", array))
priv->fast_supported = TRUE;
g_free (array);
}
g_variant_unref (value);
}
nm_log_dbg (LOGD_SUPPLICANT, "EAP-FAST is %ssupported", priv->fast_supported ? "" : "not ");
g_hash_table_unref (props);
}
static void
check_capabilities (NMSupplicantManager *self)
availability_changed (NMSupplicantManager *self, gboolean available)
{
NMSupplicantManagerPrivate *priv = NM_SUPPLICANT_MANAGER_GET_PRIVATE (self);
GList *ifaces, *iter;
dbus_g_proxy_begin_call (priv->props_proxy, "GetAll",
get_capabilities_cb, self, NULL,
G_TYPE_STRING, WPAS_DBUS_INTERFACE,
G_TYPE_INVALID);
/* priv->ifaces may be modified if availability changes; can't use GHashTableIter */
ifaces = g_hash_table_get_values (priv->ifaces);
for (iter = ifaces; iter; iter = iter->next)
nm_supplicant_interface_set_supplicant_available (NM_SUPPLICANT_INTERFACE (iter->data), available);
g_list_free (ifaces);
}
gboolean
nm_supplicant_manager_available (NMSupplicantManager *self)
static gboolean
is_available (NMSupplicantManager *self)
{
g_return_val_if_fail (NM_IS_SUPPLICANT_MANAGER (self), FALSE);
@ -225,22 +216,26 @@ static void
set_running (NMSupplicantManager *self, gboolean now_running)
{
NMSupplicantManagerPrivate *priv = NM_SUPPLICANT_MANAGER_GET_PRIVATE (self);
gboolean old_available = nm_supplicant_manager_available (self);
gboolean old_available = is_available (self);
gboolean new_available;
priv->running = now_running;
if (old_available != nm_supplicant_manager_available (self))
g_object_notify (G_OBJECT (self), NM_SUPPLICANT_MANAGER_AVAILABLE);
new_available = is_available (self);
if (old_available != new_available)
availability_changed (self, new_available);
}
static void
set_die_count (NMSupplicantManager *self, guint new_die_count)
{
NMSupplicantManagerPrivate *priv = NM_SUPPLICANT_MANAGER_GET_PRIVATE (self);
gboolean old_available = nm_supplicant_manager_available (self);
gboolean old_available = is_available (self);
gboolean new_available;
priv->die_count = new_die_count;
if (old_available != nm_supplicant_manager_available (self))
g_object_notify (G_OBJECT (self), NM_SUPPLICANT_MANAGER_AVAILABLE);
new_available = is_available (self);
if (old_available != new_available)
availability_changed (self, new_available);
}
static gboolean
@ -257,28 +252,21 @@ wpas_die_count_reset_cb (gpointer user_data)
}
static void
name_owner_changed (NMDBusManager *dbus_mgr,
const char *name,
const char *old_owner,
const char *new_owner,
gpointer user_data)
name_owner_cb (GDBusProxy *proxy, GParamSpec *pspec, gpointer user_data)
{
NMSupplicantManager *self = NM_SUPPLICANT_MANAGER (user_data);
NMSupplicantManagerPrivate *priv = NM_SUPPLICANT_MANAGER_GET_PRIVATE (self);
gboolean old_owner_good = (old_owner && strlen (old_owner));
gboolean new_owner_good = (new_owner && strlen (new_owner));
char *owner;
/* We only care about the supplicant here */
if (strcmp (WPAS_DBUS_SERVICE, name) != 0)
return;
g_return_if_fail (proxy == priv->proxy);
if (!old_owner_good && new_owner_good) {
nm_log_info (LOGD_SUPPLICANT, "wpa_supplicant started");
owner = g_dbus_proxy_get_name_owner (proxy);
nm_log_info (LOGD_SUPPLICANT, "wpa_supplicant %s", owner ? "running" : "stopped");
if (owner) {
set_running (self, TRUE);
check_capabilities (self);
} else if (old_owner_good && !new_owner_good) {
nm_log_info (LOGD_SUPPLICANT, "wpa_supplicant stopped");
update_capabilities (self);
} else if (priv->running) {
/* Reschedule the die count reset timeout. Every time the supplicant
* dies we wait 10 seconds before resetting the counter. If the
* supplicant died more than twice before the timer is reset, then
@ -299,6 +287,33 @@ name_owner_changed (NMDBusManager *dbus_mgr,
priv->fast_supported = FALSE;
}
g_free (owner);
}
static void
on_proxy_acquired (GObject *object, GAsyncResult *result, gpointer user_data)
{
NMSupplicantManager *self;
NMSupplicantManagerPrivate *priv;
GError *error = NULL;
GDBusProxy *proxy;
proxy = g_dbus_proxy_new_for_bus_finish (result, &error);
if (!proxy) {
nm_log_warn (LOGD_SUPPLICANT,
"Failed to acquire wpa_supplicant proxy: Wi-Fi and 802.1x will not be available (%s)",
error->message);
g_clear_error (&error);
return;
}
self = NM_SUPPLICANT_MANAGER (user_data);
priv = NM_SUPPLICANT_MANAGER_GET_PRIVATE (self);
priv->proxy = proxy;
g_signal_connect (priv->proxy, "notify::g-name-owner", G_CALLBACK (name_owner_cb), self);
name_owner_cb (priv->proxy, NULL, self);
}
/*******************************************************************/
@ -321,50 +336,19 @@ static void
nm_supplicant_manager_init (NMSupplicantManager *self)
{
NMSupplicantManagerPrivate *priv = NM_SUPPLICANT_MANAGER_GET_PRIVATE (self);
DBusGConnection *bus;
priv->dbus_mgr = nm_dbus_manager_get ();
priv->name_owner_id = g_signal_connect (priv->dbus_mgr,
NM_DBUS_MANAGER_NAME_OWNER_CHANGED,
G_CALLBACK (name_owner_changed),
self);
priv->running = nm_dbus_manager_name_has_owner (priv->dbus_mgr, WPAS_DBUS_SERVICE);
priv->ifaces = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, g_object_unref);
bus = nm_dbus_manager_get_connection (priv->dbus_mgr);
priv->proxy = dbus_g_proxy_new_for_name (bus,
WPAS_DBUS_SERVICE,
WPAS_DBUS_PATH,
WPAS_DBUS_INTERFACE);
priv->props_proxy = dbus_g_proxy_new_for_name (bus,
WPAS_DBUS_SERVICE,
WPAS_DBUS_PATH,
DBUS_INTERFACE_PROPERTIES);
priv->ifaces = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_object_unref);
/* Check generic supplicant capabilities */
if (priv->running)
check_capabilities (self);
}
static void
set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
{
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
static void
get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
{
switch (prop_id) {
case PROP_AVAILABLE:
g_value_set_boolean (value, nm_supplicant_manager_available (NM_SUPPLICANT_MANAGER (object)));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
priv->cancellable = g_cancellable_new ();
g_dbus_proxy_new_for_bus (G_BUS_TYPE_SYSTEM,
G_DBUS_PROXY_FLAGS_NONE,
NULL,
WPAS_DBUS_SERVICE,
WPAS_DBUS_PATH,
WPAS_DBUS_INTERFACE,
priv->cancellable,
(GAsyncReadyCallback) on_proxy_acquired,
self);
}
static void
@ -372,29 +356,19 @@ dispose (GObject *object)
{
NMSupplicantManagerPrivate *priv = NM_SUPPLICANT_MANAGER_GET_PRIVATE (object);
if (priv->disposed)
goto out;
priv->disposed = TRUE;
if (priv->die_count_reset_id)
if (priv->die_count_reset_id) {
g_source_remove (priv->die_count_reset_id);
if (priv->dbus_mgr) {
if (priv->name_owner_id)
g_signal_handler_disconnect (priv->dbus_mgr, priv->name_owner_id);
priv->dbus_mgr = NULL;
priv->die_count_reset_id = 0;
}
g_hash_table_destroy (priv->ifaces);
if (priv->cancellable) {
g_cancellable_cancel (priv->cancellable);
g_clear_object (&priv->cancellable);
}
if (priv->proxy)
g_object_unref (priv->proxy);
g_clear_pointer (&priv->ifaces, g_hash_table_unref);
g_clear_object (&priv->proxy);
if (priv->props_proxy)
g_object_unref (priv->props_proxy);
out:
/* Chain up to the parent class */
G_OBJECT_CLASS (nm_supplicant_manager_parent_class)->dispose (object);
}
@ -405,15 +379,6 @@ nm_supplicant_manager_class_init (NMSupplicantManagerClass *klass)
g_type_class_add_private (object_class, sizeof (NMSupplicantManagerPrivate));
object_class->get_property = get_property;
object_class->set_property = set_property;
object_class->dispose = dispose;
g_object_class_install_property
(object_class, PROP_AVAILABLE,
g_param_spec_boolean (NM_SUPPLICANT_MANAGER_AVAILABLE, "", "",
FALSE,
G_PARAM_READABLE |
G_PARAM_STATIC_STRINGS));
}

9
src/supplicant-manager/nm-supplicant-manager.h
View file

@ -26,11 +26,6 @@
#include "nm-supplicant-types.h"
#include "nm-device.h"
#define WPAS_DBUS_SERVICE "fi.w1.wpa_supplicant1"
#define WPAS_DBUS_PATH "/fi/w1/wpa_supplicant1"
#define WPAS_DBUS_INTERFACE "fi.w1.wpa_supplicant1"
G_BEGIN_DECLS
#define NM_TYPE_SUPPLICANT_MANAGER (nm_supplicant_manager_get_type ())
@ -40,8 +35,6 @@ G_BEGIN_DECLS
#define NM_IS_SUPPLICANT_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), NM_TYPE_SUPPLICANT_MANAGER))
#define NM_SUPPLICANT_MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), NM_TYPE_SUPPLICANT_MANAGER, NMSupplicantManagerClass))
#define NM_SUPPLICANT_MANAGER_AVAILABLE "available"
struct _NMSupplicantManager
{
GObject parent;
@ -63,6 +56,4 @@ NMSupplicantInterface *nm_supplicant_manager_iface_get (NMSupplicantManager *mgr
void nm_supplicant_manager_iface_release (NMSupplicantManager *mgr,
NMSupplicantInterface *iface);
gboolean nm_supplicant_manager_available (NMSupplicantManager *mgr);
#endif /* __NETWORKMANAGER_SUPPLICANT_MANAGER_H__ */

4
src/supplicant-manager/nm-supplicant-types.h
View file

@ -21,6 +21,10 @@
#ifndef __NETWORKMANAGER_SUPPLICANT_TYPES_H__
#define __NETWORKMANAGER_SUPPLICANT_TYPES_H__
#define WPAS_DBUS_SERVICE "fi.w1.wpa_supplicant1"
#define WPAS_DBUS_PATH "/fi/w1/wpa_supplicant1"
#define WPAS_DBUS_INTERFACE "fi.w1.wpa_supplicant1"
typedef struct _NMSupplicantManager NMSupplicantManager;
typedef struct _NMSupplicantInterface NMSupplicantInterface;
typedef struct _NMSupplicantConfig NMSupplicantConfig;

227
src/supplicant-manager/tests/test-supplicant-config.c
View file

@ -41,78 +41,67 @@
static gboolean
validate_opt (const char *detail,
GHashTable *hash,
GVariant *config,
const char *key,
OptType val_type,
gconstpointer expected,
size_t expected_len)
{
GValue *value;
gint int_val;
GByteArray *array;
char *config_key;
GVariant *config_value;
gboolean found = FALSE;
const guint8 *bytes;
gsize len;
const char *s;
const unsigned char *expected_array = expected;
int result;
GVariantIter iter;
ASSERT (hash != NULL, detail, "hash was NULL");
g_assert (g_variant_is_of_type (config, G_VARIANT_TYPE_VARDICT));
value = g_hash_table_lookup (hash, key);
ASSERT (value != NULL,
detail, "option '%s' expected but not found in config hash.");
switch (val_type) {
case TYPE_INT:
ASSERT (G_VALUE_HOLDS_INT (value),
detail, "config hash item '%s' was not TYPE_INT.", key);
int_val = g_value_get_int (value);
ASSERT (int_val == GPOINTER_TO_INT (expected),
detail, "unexpected config hash item '%s' value %d (expected %d)",
key, int_val, GPOINTER_TO_INT (expected));
break;
case TYPE_BYTES:
ASSERT (G_VALUE_HOLDS (value, DBUS_TYPE_G_UCHAR_ARRAY),
detail, "config hash item '%s' was not TYPE_BYTES.", key);
array = g_value_get_boxed (value);
ASSERT (array->len == expected_len,
detail, "unexpected config hash item '%s' length %d (expected %d)",
key, array->len, expected_len);
result = memcmp (array->data, expected_array, expected_len);
ASSERT (result == 0, detail, "unexpected config hash item '%s' value", key);
break;
case TYPE_KEYWORD:
case TYPE_STRING:
ASSERT (G_VALUE_HOLDS_STRING (value),
detail, "config hash item '%s' was not TYPE_STRING or TYPE_KEYWORD.", key);
if (expected_len == -1)
expected_len = strlen ((const char *) expected);
s = g_value_get_string (value);
ASSERT (s != NULL, detail, "unexpected NULL config hash string item '%s'.", key);
ASSERT (strlen (s) == expected_len,
detail, "unexpected config hash string item '%s' length %d (expected %d)",
key, strlen (s), expected_len);
result = strcmp (s, (const char *) expected);
ASSERT (result == 0,
detail, "unexpected config hash string item '%s' value '%s' (expected '%s')",
key, s, (const char *) expected);
break;
default:
g_warning ("unknown supplicant config hash item '%s' option type %d",
key, val_type);
return FALSE;
g_variant_iter_init (&iter, config);
while (g_variant_iter_next (&iter, "{&sv}", (gpointer) &config_key, (gpointer) &config_value)) {
if (!strcmp (key, config_key)) {
found = TRUE;
switch (val_type) {
case TYPE_INT:
g_assert (g_variant_is_of_type (config_value, G_VARIANT_TYPE_INT32));
g_assert_cmpint (g_variant_get_int32 (config_value), ==, GPOINTER_TO_INT (expected));
break;
case TYPE_BYTES:
g_assert (g_variant_is_of_type (config_value, G_VARIANT_TYPE_BYTESTRING));
bytes = g_variant_get_fixed_array (config_value, &len, 1);
g_assert_cmpint (len, ==, expected_len);
g_assert (memcmp (bytes, expected_array, expected_len) == 0);
break;
case TYPE_KEYWORD:
case TYPE_STRING:
g_assert (g_variant_is_of_type (config_value, G_VARIANT_TYPE_STRING));
if (expected_len == -1)
expected_len = strlen ((const char *) expected);
s = g_variant_get_string (config_value, NULL);
g_assert_cmpint (strlen (s), ==, expected_len);
g_assert_cmpstr (s, ==, expected);
break;
default:
g_assert_not_reached ();
break;
}
}
g_variant_unref (config_value);
}
return TRUE;
return found;
}
static void
test_wifi_open (void)
{
NMConnection *connection;
gs_unref_object NMConnection *connection = NULL;
gs_unref_object NMSupplicantConfig *config = NULL;
gs_unref_variant GVariant *config_dict = NULL;
NMSettingConnection *s_con;
NMSettingWireless *s_wifi;
NMSettingIPConfig *s_ip4;
gs_unref_object NMSupplicantConfig *config = NULL;
GHashTable *hash;
char *uuid;
gboolean success;
GError *error = NULL;
@ -156,9 +145,9 @@ test_wifi_open (void)
g_object_set (s_ip4, NM_SETTING_IP_CONFIG_METHOD, NM_SETTING_IP4_CONFIG_METHOD_AUTO, NULL);
ASSERT (nm_connection_verify (connection, &error) == TRUE,
"wifi-open", "failed to verify connection: %s",
(error && error->message) ? error->message : "(unknown)");
success = nm_connection_verify (connection, &error);
g_assert_no_error (error);
g_assert (success);
config = nm_supplicant_config_new ();
@ -170,29 +159,21 @@ test_wifi_open (void)
"*added 'bssid' value '11:22:33:44:55:66'*");
g_test_expect_message ("NetworkManager", G_LOG_LEVEL_MESSAGE,
"*added 'freq_list' value *");
success = nm_supplicant_config_add_setting_wireless (config, s_wifi, 0);
ASSERT (success == TRUE,
"wifi-open", "failed to add wireless setting to supplicant config.");
g_assert (nm_supplicant_config_add_setting_wireless (config, s_wifi, 0));
g_test_assert_expected_messages ();
g_test_expect_message ("NetworkManager", G_LOG_LEVEL_MESSAGE,
"*added 'key_mgmt' value 'NONE'");
success = nm_supplicant_config_add_no_security (config);
ASSERT (success == TRUE,
"wifi-open", "failed to add wireless security to supplicant config.");
g_assert (nm_supplicant_config_add_no_security (config));
g_test_assert_expected_messages ();
hash = nm_supplicant_config_get_hash (config);
ASSERT (hash != NULL,
"wifi-open", "failed to hash supplicant config options.");
config_dict = nm_supplicant_config_to_variant (config);
g_assert (config_dict);
validate_opt ("wifi-open", hash, "scan_ssid", TYPE_INT, GINT_TO_POINTER (1), -1);
validate_opt ("wifi-open", hash, "ssid", TYPE_BYTES, ssid_data, sizeof (ssid_data));
validate_opt ("wifi-open", hash, "bssid", TYPE_KEYWORD, bssid_str, -1);
validate_opt ("wifi-open", hash, "key_mgmt", TYPE_KEYWORD, "NONE", -1);
g_hash_table_unref (hash);
g_object_unref (connection);
validate_opt ("wifi-open", config_dict, "scan_ssid", TYPE_INT, GINT_TO_POINTER (1), -1);
validate_opt ("wifi-open", config_dict, "ssid", TYPE_BYTES, ssid_data, sizeof (ssid_data));
validate_opt ("wifi-open", config_dict, "bssid", TYPE_KEYWORD, bssid_str, -1);
validate_opt ("wifi-open", config_dict, "key_mgmt", TYPE_KEYWORD, "NONE", -1);
}
static void
@ -202,13 +183,13 @@ test_wifi_wep_key (const char *detail,
const unsigned char *expected,
size_t expected_size)
{
NMConnection *connection;
gs_unref_object NMConnection *connection = NULL;
gs_unref_object NMSupplicantConfig *config = NULL;
gs_unref_variant GVariant *config_dict = NULL;
NMSettingConnection *s_con;
NMSettingWireless *s_wifi;
NMSettingWirelessSecurity *s_wsec;
NMSettingIPConfig *s_ip4;
gs_unref_object NMSupplicantConfig *config = NULL;
GHashTable *hash;
char *uuid;
gboolean success;
GError *error = NULL;
@ -262,9 +243,9 @@ test_wifi_wep_key (const char *detail,
g_object_set (s_ip4, NM_SETTING_IP_CONFIG_METHOD, NM_SETTING_IP4_CONFIG_METHOD_AUTO, NULL);
ASSERT (nm_connection_verify (connection, &error) == TRUE,
detail, "failed to verify connection: %s",
(error && error->message) ? error->message : "(unknown)");
success = nm_connection_verify (connection, &error);
g_assert_no_error (error);
g_assert (success);
config = nm_supplicant_config_new ();
@ -276,9 +257,7 @@ test_wifi_wep_key (const char *detail,
"*added 'bssid' value '11:22:33:44:55:66'*");
g_test_expect_message ("NetworkManager", G_LOG_LEVEL_MESSAGE,
"*added 'freq_list' value *");
success = nm_supplicant_config_add_setting_wireless (config, s_wifi, 0);
ASSERT (success == TRUE,
detail, "failed to add wireless setting to supplicant config.");
g_assert (nm_supplicant_config_add_setting_wireless (config, s_wifi, 0));
g_test_assert_expected_messages ();
g_test_expect_message ("NetworkManager", G_LOG_LEVEL_MESSAGE,
@ -287,27 +266,21 @@ test_wifi_wep_key (const char *detail,
"*added 'wep_key0' value *");
g_test_expect_message ("NetworkManager", G_LOG_LEVEL_MESSAGE,
"*added 'wep_tx_keyidx' value '0'");
success = nm_supplicant_config_add_setting_wireless_security (config,
g_assert (nm_supplicant_config_add_setting_wireless_security (config,
s_wsec,
NULL,
"376aced7-b28c-46be-9a62-fcdf072571da");
ASSERT (success == TRUE,
detail, "failed to add wireless security to supplicant config.");
"376aced7-b28c-46be-9a62-fcdf072571da"));
g_test_assert_expected_messages ();
hash = nm_supplicant_config_get_hash (config);
ASSERT (hash != NULL,
detail, "failed to hash supplicant config options.");
config_dict = nm_supplicant_config_to_variant (config);
g_assert (config_dict);
validate_opt (detail, hash, "scan_ssid", TYPE_INT, GINT_TO_POINTER (1), -1);
validate_opt (detail, hash, "ssid", TYPE_BYTES, ssid_data, sizeof (ssid_data));
validate_opt (detail, hash, "bssid", TYPE_KEYWORD, bssid_str, -1);
validate_opt (detail, hash, "key_mgmt", TYPE_KEYWORD, "NONE", -1);
validate_opt (detail, hash, "wep_tx_keyidx", TYPE_INT, GINT_TO_POINTER (0), -1);
validate_opt (detail, hash, "wep_key0", TYPE_BYTES, expected, expected_size);
g_hash_table_unref (hash);
g_object_unref (connection);
validate_opt (detail, config_dict, "scan_ssid", TYPE_INT, GINT_TO_POINTER (1), -1);
validate_opt (detail, config_dict, "ssid", TYPE_BYTES, ssid_data, sizeof (ssid_data));
validate_opt (detail, config_dict, "bssid", TYPE_KEYWORD, bssid_str, -1);
validate_opt (detail, config_dict, "key_mgmt", TYPE_KEYWORD, "NONE", -1);
validate_opt (detail, config_dict, "wep_tx_keyidx", TYPE_INT, GINT_TO_POINTER (0), -1);
validate_opt (detail, config_dict, "wep_key0", TYPE_BYTES, expected, expected_size);
}
static void
@ -340,13 +313,13 @@ test_wifi_wpa_psk (const char *detail,
const unsigned char *expected,
size_t expected_size)
{
NMConnection *connection;
gs_unref_object NMConnection *connection = NULL;
gs_unref_object NMSupplicantConfig *config = NULL;
gs_unref_variant GVariant *config_dict = NULL;
NMSettingConnection *s_con;
NMSettingWireless *s_wifi;
NMSettingWirelessSecurity *s_wsec;
NMSettingIPConfig *s_ip4;
gs_unref_object NMSupplicantConfig *config = NULL;
GHashTable *hash;
char *uuid;
gboolean success;
GError *error = NULL;
@ -406,9 +379,9 @@ test_wifi_wpa_psk (const char *detail,
g_object_set (s_ip4, NM_SETTING_IP_CONFIG_METHOD, NM_SETTING_IP4_CONFIG_METHOD_AUTO, NULL);
ASSERT (nm_connection_verify (connection, &error) == TRUE,
detail, "failed to verify connection: %s",
(error && error->message) ? error->message : "(unknown)");
success = nm_connection_verify (connection, &error);
g_assert_no_error (error);
g_assert (success);
config = nm_supplicant_config_new ();
@ -420,9 +393,7 @@ test_wifi_wpa_psk (const char *detail,
"*added 'bssid' value '11:22:33:44:55:66'*");
g_test_expect_message ("NetworkManager", G_LOG_LEVEL_MESSAGE,
"*added 'freq_list' value *");
success = nm_supplicant_config_add_setting_wireless (config, s_wifi, 0);
ASSERT (success == TRUE,
detail, "failed to add wireless setting to supplicant config.");
g_assert (nm_supplicant_config_add_setting_wireless (config, s_wifi, 0));
g_test_assert_expected_messages ();
g_test_expect_message ("NetworkManager", G_LOG_LEVEL_MESSAGE,
@ -435,29 +406,23 @@ test_wifi_wpa_psk (const char *detail,
"*added 'pairwise' value 'TKIP CCMP'");
g_test_expect_message ("NetworkManager", G_LOG_LEVEL_MESSAGE,
"*added 'group' value 'TKIP CCMP'");
success = nm_supplicant_config_add_setting_wireless_security (config,
g_assert (nm_supplicant_config_add_setting_wireless_security (config,
s_wsec,
NULL,
"376aced7-b28c-46be-9a62-fcdf072571da");
ASSERT (success == TRUE,
detail, "failed to add wireless security to supplicant config.");
"376aced7-b28c-46be-9a62-fcdf072571da"));
g_test_assert_expected_messages ();
hash = nm_supplicant_config_get_hash (config);
ASSERT (hash != NULL,
detail, "failed to hash supplicant config options.");
config_dict = nm_supplicant_config_to_variant (config);
g_assert (config_dict);
validate_opt (detail, hash, "scan_ssid", TYPE_INT, GINT_TO_POINTER (1), -1);
validate_opt (detail, hash, "ssid", TYPE_BYTES, ssid_data, sizeof (ssid_data));
validate_opt (detail, hash, "bssid", TYPE_KEYWORD, bssid_str, -1);
validate_opt (detail, hash, "key_mgmt", TYPE_KEYWORD, "WPA-PSK", -1);
validate_opt (detail, hash, "proto", TYPE_KEYWORD, "WPA RSN", -1);
validate_opt (detail, hash, "pairwise", TYPE_KEYWORD, "TKIP CCMP", -1);
validate_opt (detail, hash, "group", TYPE_KEYWORD, "TKIP CCMP", -1);
validate_opt (detail, hash, "psk", key_type, expected, expected_size);
g_hash_table_unref (hash);
g_object_unref (connection);
validate_opt (detail, config_dict, "scan_ssid", TYPE_INT, GINT_TO_POINTER (1), -1);
validate_opt (detail, config_dict, "ssid", TYPE_BYTES, ssid_data, sizeof (ssid_data));
validate_opt (detail, config_dict, "bssid", TYPE_KEYWORD, bssid_str, -1);
validate_opt (detail, config_dict, "key_mgmt", TYPE_KEYWORD, "WPA-PSK", -1);
validate_opt (detail, config_dict, "proto", TYPE_KEYWORD, "WPA RSN", -1);
validate_opt (detail, config_dict, "pairwise", TYPE_KEYWORD, "TKIP CCMP", -1);
validate_opt (detail, config_dict, "group", TYPE_KEYWORD, "TKIP CCMP", -1);
validate_opt (detail, config_dict, "psk", key_type, expected, expected_size);
}
static void
@ -478,18 +443,12 @@ NMTST_DEFINE ();
int main (int argc, char **argv)
{
char *base;
nmtst_init (&argc, &argv, TRUE);
/* The tests */
test_wifi_open ();
test_wifi_wep ();
test_wifi_wpa_psk_types ();
g_test_add_func ("/supplicant-config/wifi-open", test_wifi_open);
g_test_add_func ("/supplicant-config/wifi-wep", test_wifi_wep);
g_test_add_func ("/supplicant-config/wifi-wpa-psk-types", test_wifi_wpa_psk_types);
base = g_path_get_basename (argv[0]);
fprintf (stdout, "%s: SUCCESS\n", base);
g_free (base);
return 0;
return g_test_run ();
}