system/NetworkManager
system/NetworkManager
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/NetworkManager/NetworkManager synced 2024-10-14 20:18:39 +00:00
Code Issues Packages Projects Releases Wiki Activity

supplicant: convert interface/config to GDBus

Browse source
This commit is contained in:
Dan Williams 2015-02-02 02:31:30 -06:00
parent 47fe1b3196
commit 59c8192b22
8 changed files with 912 additions and 1120 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -165,7 +165,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,
@ -1830,7 +1830,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);

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);

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

File diff suppressed because it is too large Load diff

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

@ -85,8 +85,11 @@ nm_supplicant_manager_iface_get (NMSupplicantManager * self,
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);
}
@ -188,12 +191,13 @@ static void
availability_changed (NMSupplicantManager *self, gboolean available)
{
NMSupplicantManagerPrivate *priv = NM_SUPPLICANT_MANAGER_GET_PRIVATE (self);
NMSupplicantInterface *iface;
GHashTableIter iter;
GList *ifaces, *iter;
g_hash_table_iter_init (&iter, priv->ifaces);
while (g_hash_table_iter_next (&iter, NULL, (gpointer) &iface))
nm_supplicant_interface_set_supplicant_available (iface, available);
/* 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);
}
static gboolean
@ -319,7 +323,7 @@ nm_supplicant_manager_init (NMSupplicantManager *self)
{
NMSupplicantManagerPrivate *priv = NM_SUPPLICANT_MANAGER_GET_PRIVATE (self);
priv->ifaces = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_object_unref);
priv->ifaces = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, g_object_unref);
priv->cancellable = g_cancellable_new ();
g_dbus_proxy_new_for_bus (G_BUS_TYPE_SYSTEM,

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 ();
}