/* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- */ /* * * 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, 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) 2008 - 2011 Red Hat, Inc. * */ #include #include #include #include #include #include "nm-test-helpers.h" #include #include "nm-setting-connection.h" #include "nm-setting-vpn.h" #include "nm-setting-gsm.h" #include "nm-setting-cdma.h" #include "nm-setting-wired.h" #include "nm-setting-wireless-security.h" #include "nm-setting-ip6-config.h" #include "nm-setting-ip4-config.h" #include "nm-setting-pppoe.h" #include "nm-setting-serial.h" #include "nm-setting-vlan.h" #include "nm-setting-bond.h" #include "nm-utils.h" #include "nm-dbus-glib-types.h" #include "nm-glib-compat.h" static void vpn_check_func (const char *key, const char *value, gpointer user_data) { const char *test = user_data; if (!strcmp (key, "foobar1")) { ASSERT (strcmp (value, "blahblah1") == 0, test, "unexpected vpn item '%s' / '%s'", key, value); return; } if (!strcmp (key, "foobar2")) { ASSERT (strcmp (value, "blahblah2") == 0, test, "unexpected vpn item '%s' / '%s'", key, value); return; } if (!strcmp (key, "foobar3")) { ASSERT (strcmp (value, "blahblah3") == 0, test, "unexpected vpn item '%s' / '%s'", key, value); return; } if (!strcmp (key, "foobar4")) { ASSERT (strcmp (value, "blahblah4") == 0, test, "unexpected vpn item '%s' / '%s'", key, value); return; } ASSERT (FALSE, test, "unexpected vpn item '%s'", key); } static void vpn_check_empty_func (const char *key, const char *value, gpointer user_data) { const char *test = user_data; /* We don't expect any values */ ASSERT (FALSE, test, "unexpected vpn item '%s'", key); } static void test_setting_vpn_items (void) { NMSettingVPN *s_vpn; s_vpn = (NMSettingVPN *) nm_setting_vpn_new (); ASSERT (s_vpn != NULL, "vpn-items", "error creating vpn setting"); nm_setting_vpn_add_data_item (s_vpn, "foobar1", "blahblah1"); nm_setting_vpn_add_data_item (s_vpn, "foobar2", "blahblah2"); nm_setting_vpn_add_data_item (s_vpn, "foobar3", "blahblah3"); nm_setting_vpn_add_data_item (s_vpn, "foobar4", "blahblah4"); /* Ensure that added values are all present */ nm_setting_vpn_foreach_data_item (s_vpn, vpn_check_func, "vpn-data"); nm_setting_vpn_remove_data_item (s_vpn, "foobar1"); nm_setting_vpn_remove_data_item (s_vpn, "foobar2"); nm_setting_vpn_remove_data_item (s_vpn, "foobar3"); nm_setting_vpn_remove_data_item (s_vpn, "foobar4"); nm_setting_vpn_add_secret (s_vpn, "foobar1", "blahblah1"); nm_setting_vpn_add_secret (s_vpn, "foobar2", "blahblah2"); nm_setting_vpn_add_secret (s_vpn, "foobar3", "blahblah3"); nm_setting_vpn_add_secret (s_vpn, "foobar4", "blahblah4"); /* Ensure that added values are all present */ nm_setting_vpn_foreach_secret (s_vpn, vpn_check_func, "vpn-secrets"); nm_setting_vpn_remove_secret (s_vpn, "foobar1"); nm_setting_vpn_remove_secret (s_vpn, "foobar2"); nm_setting_vpn_remove_secret (s_vpn, "foobar3"); nm_setting_vpn_remove_secret (s_vpn, "foobar4"); /* Try to add some blank values and make sure they are rejected */ nm_setting_vpn_add_data_item (s_vpn, NULL, NULL); nm_setting_vpn_add_data_item (s_vpn, "", ""); nm_setting_vpn_add_data_item (s_vpn, "foobar1", NULL); nm_setting_vpn_add_data_item (s_vpn, "foobar1", ""); nm_setting_vpn_add_data_item (s_vpn, NULL, "blahblah1"); nm_setting_vpn_add_data_item (s_vpn, "", "blahblah1"); nm_setting_vpn_foreach_data_item (s_vpn, vpn_check_empty_func, "vpn-data-empty"); /* Try to add some blank secrets and make sure they are rejected */ nm_setting_vpn_add_secret (s_vpn, NULL, NULL); nm_setting_vpn_add_secret (s_vpn, "", ""); nm_setting_vpn_add_secret (s_vpn, "foobar1", NULL); nm_setting_vpn_add_secret (s_vpn, "foobar1", ""); nm_setting_vpn_add_secret (s_vpn, NULL, "blahblah1"); nm_setting_vpn_add_secret (s_vpn, "", "blahblah1"); nm_setting_vpn_foreach_secret (s_vpn, vpn_check_empty_func, "vpn-secrets-empty"); g_object_unref (s_vpn); } static void test_setting_vpn_update_secrets (void) { NMConnection *connection; NMSettingVPN *s_vpn; GHashTable *settings, *vpn, *secrets; GValue val = G_VALUE_INIT; gboolean success; GError *error = NULL; const char *tmp; const char *key1 = "foobar"; const char *key2 = "blahblah"; const char *val1 = "value1"; const char *val2 = "value2"; connection = nm_connection_new (); ASSERT (connection != NULL, "vpn-update-secrets", "error creating connection"); s_vpn = (NMSettingVPN *) nm_setting_vpn_new (); ASSERT (s_vpn != NULL, "vpn-update-secrets", "error creating vpn setting"); nm_connection_add_setting (connection, NM_SETTING (s_vpn)); settings = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, (GDestroyNotify) g_hash_table_destroy); vpn = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, (GDestroyNotify) g_value_unset); g_hash_table_insert (settings, NM_SETTING_VPN_SETTING_NAME, vpn); secrets = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, NULL); g_value_init (&val, DBUS_TYPE_G_MAP_OF_STRING); g_value_take_boxed (&val, secrets); g_hash_table_insert (vpn, NM_SETTING_VPN_SECRETS, &val); /* Add some secrets */ g_hash_table_insert (secrets, (char *) key1, (char *) val1); g_hash_table_insert (secrets, (char *) key2, (char *) val2); success = nm_connection_update_secrets (connection, NM_SETTING_VPN_SETTING_NAME, settings, &error); ASSERT (success == TRUE, "vpn-update-secrets", "failed to update VPN secrets: %s", error->message); /* Read the secrets back out */ tmp = nm_setting_vpn_get_secret (s_vpn, key1); ASSERT (tmp != NULL, "vpn-update-secrets", "unexpected failure getting key #1"); ASSERT (strcmp (tmp, val1) == 0, "vpn-update-secrets", "unexpected key #1 value"); tmp = nm_setting_vpn_get_secret (s_vpn, key2); ASSERT (tmp != NULL, "vpn-update-secrets", "unexpected failure getting key #2"); ASSERT (strcmp (tmp, val2) == 0, "vpn-update-secrets", "unexpected key #2 value"); g_hash_table_destroy (settings); g_object_unref (connection); } #define TO_DEL_NUM 50 typedef struct { NMSettingVPN *s_vpn; char *to_del[TO_DEL_NUM]; guint called; } IterInfo; static void del_iter_func (const char *key, const char *value, gpointer user_data) { IterInfo *info = user_data; int i; /* Record how many times this function gets called; it should get called * exactly as many times as there are keys in the hash table, regardless * of what keys we delete from the table. */ info->called++; /* During the iteration, remove a bunch of stuff from the table */ if (info->called == 1) { for (i = 0; i < TO_DEL_NUM; i++) nm_setting_vpn_remove_data_item (info->s_vpn, info->to_del[i]); } } static void test_setting_vpn_modify_during_foreach (void) { NMSettingVPN *s_vpn; IterInfo info; char *key, *val; int i, u = 0; s_vpn = (NMSettingVPN *) nm_setting_vpn_new (); g_assert (s_vpn); for (i = 0; i < TO_DEL_NUM * 2; i++) { key = g_strdup_printf ("adsfasdfadf%d", i); val = g_strdup_printf ("42263236236awt%d", i); nm_setting_vpn_add_data_item (s_vpn, key, val); /* Cache some keys to delete */ if (i % 2) info.to_del[u++] = g_strdup (key); g_free (key); g_free (val); } /* Iterate over current table keys */ info.s_vpn = s_vpn; info.called = 0; nm_setting_vpn_foreach_data_item (s_vpn, del_iter_func, &info); /* Make sure all the things we removed during iteration are really gone */ for (i = 0; i < TO_DEL_NUM; i++) { g_assert_cmpstr (nm_setting_vpn_get_data_item (s_vpn, info.to_del[i]), ==, NULL); g_free (info.to_del[i]); } /* And make sure the foreach callback was called the same number of times * as there were keys in the table at the beginning of the foreach. */ g_assert_cmpint (info.called, ==, TO_DEL_NUM * 2); g_object_unref (s_vpn); } #define OLD_DBUS_TYPE_G_IP6_ADDRESS (dbus_g_type_get_struct ("GValueArray", DBUS_TYPE_G_UCHAR_ARRAY, G_TYPE_UINT, G_TYPE_INVALID)) #define OLD_DBUS_TYPE_G_ARRAY_OF_IP6_ADDRESS (dbus_g_type_get_collection ("GPtrArray", OLD_DBUS_TYPE_G_IP6_ADDRESS)) /* Test that setting the IPv6 setting's 'addresses' property using the old * IPv6 address format still works, i.e. that the GValue transformation function * from old->new is working correctly. */ static void test_setting_ip6_config_old_address_array (void) { NMSettingIP6Config *s_ip6; GPtrArray *addresses, *read_addresses; GValueArray *array, *read_array; GValue element = G_VALUE_INIT, written_value = G_VALUE_INIT, read_value = G_VALUE_INIT; GByteArray *ba; const guint8 addr[16] = { 0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11, 0x11, 0x22, 0x33, 0x44, 0x66, 0x77, 0x88, 0x99 }; const guint8 gw[16] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; guint32 prefix = 56; GValue *read_addr, *read_prefix, *read_gw; s_ip6 = (NMSettingIP6Config *) nm_setting_ip6_config_new (); ASSERT (s_ip6 != NULL, "ip6-old-addr", "error creating IP6 setting"); g_value_init (&written_value, OLD_DBUS_TYPE_G_ARRAY_OF_IP6_ADDRESS); addresses = g_ptr_array_new (); array = g_value_array_new (3); /* IP address */ g_value_init (&element, DBUS_TYPE_G_UCHAR_ARRAY); ba = g_byte_array_new (); g_byte_array_append (ba, &addr[0], sizeof (addr)); g_value_take_boxed (&element, ba); g_value_array_append (array, &element); g_value_unset (&element); /* Prefix */ g_value_init (&element, G_TYPE_UINT); g_value_set_uint (&element, prefix); g_value_array_append (array, &element); g_value_unset (&element); g_ptr_array_add (addresses, array); g_value_set_boxed (&written_value, addresses); /* Set the address array on the object */ g_object_set_property (G_OBJECT (s_ip6), NM_SETTING_IP6_CONFIG_ADDRESSES, &written_value); /* Get it back so we can compare it */ g_value_init (&read_value, DBUS_TYPE_G_ARRAY_OF_IP6_ADDRESS); g_object_get_property (G_OBJECT (s_ip6), NM_SETTING_IP6_CONFIG_ADDRESSES, &read_value); ASSERT (G_VALUE_HOLDS (&read_value, DBUS_TYPE_G_ARRAY_OF_IP6_ADDRESS), "ip6-old-addr", "wrong addresses property value type '%s'", G_VALUE_TYPE_NAME (&read_value)); read_addresses = (GPtrArray *) g_value_get_boxed (&read_value); ASSERT (read_addresses != NULL, "ip6-old-addr", "missing addresses on readback"); ASSERT (read_addresses->len == 1, "ip6-old-addr", "expected one address on readback"); read_array = (GValueArray *) g_ptr_array_index (read_addresses, 0); read_addr = g_value_array_get_nth (read_array, 0); ba = g_value_get_boxed (read_addr); ASSERT (ba->len == sizeof (addr), "ip6-old-addr", "unexpected address item length %d", ba->len); ASSERT (memcmp (ba->data, &addr[0], sizeof (addr)) == 0, "ip6-old-addr", "unexpected failure comparing addresses"); read_prefix = g_value_array_get_nth (read_array, 1); ASSERT (g_value_get_uint (read_prefix) == prefix, "ip6-old-addr", "unexpected failure comparing prefix"); /* Ensure the gateway is all zeros, which is how the 2-item to 3-item * conversion happens. */ read_gw = g_value_array_get_nth (read_array, 2); ba = g_value_get_boxed (read_gw); ASSERT (ba->len == sizeof (gw), "ip6-old-addr", "unexpected gateway item length %d", ba->len); ASSERT (memcmp (ba->data, &gw[0], sizeof (gw)) == 0, "ip6-old-addr", "unexpected failure comparing gateways"); g_value_unset (&written_value); g_value_unset (&read_value); g_object_unref (s_ip6); } static void test_setting_gsm_apn_spaces (void) { NMSettingGsm *s_gsm; const char *tmp; s_gsm = (NMSettingGsm *) nm_setting_gsm_new (); ASSERT (s_gsm != NULL, "gsm-apn-spaces", "error creating GSM setting"); /* Trailing space */ g_object_set (s_gsm, NM_SETTING_GSM_APN, "foobar ", NULL); tmp = nm_setting_gsm_get_apn (s_gsm); ASSERT (tmp != NULL, "gsm-apn-spaces", "empty APN"); ASSERT (strcmp (tmp, "foobar") == 0, "gsm-apn-spaces", "unexpected APN"); /* Leading space */ g_object_set (s_gsm, NM_SETTING_GSM_APN, " foobar", NULL); tmp = nm_setting_gsm_get_apn (s_gsm); ASSERT (tmp != NULL, "gsm-apn-spaces", "empty APN"); ASSERT (strcmp (tmp, "foobar") == 0, "gsm-apn-spaces", "unexpected APN"); } static void test_setting_gsm_apn_bad_chars (void) { NMSettingGsm *s_gsm; s_gsm = (NMSettingGsm *) nm_setting_gsm_new (); ASSERT (s_gsm != NULL, "gsm-apn-bad-chars", "error creating GSM setting"); g_object_set (s_gsm, NM_SETTING_GSM_NUMBER, "*99#", NULL); /* Make sure a valid APN works */ g_object_set (s_gsm, NM_SETTING_GSM_APN, "foobar123.-baz", NULL); ASSERT (nm_setting_verify (NM_SETTING (s_gsm), NULL, NULL) == TRUE, "gsm-apn-bad-chars", "unexpectedly invalid GSM setting"); /* Random invalid chars */ g_object_set (s_gsm, NM_SETTING_GSM_APN, "@#%$@#%@#%", NULL); ASSERT (nm_setting_verify (NM_SETTING (s_gsm), NULL, NULL) == FALSE, "gsm-apn-bad-chars", "unexpectedly valid GSM setting"); /* Spaces */ g_object_set (s_gsm, NM_SETTING_GSM_APN, "foobar baz", NULL); ASSERT (nm_setting_verify (NM_SETTING (s_gsm), NULL, NULL) == FALSE, "gsm-apn-bad-chars", "unexpectedly valid GSM setting"); /* 0 characters long */ g_object_set (s_gsm, NM_SETTING_GSM_APN, "", NULL); ASSERT (nm_setting_verify (NM_SETTING (s_gsm), NULL, NULL) == FALSE, "gsm-apn-bad-chars", "unexpectedly valid GSM setting"); /* 65-character long */ g_object_set (s_gsm, NM_SETTING_GSM_APN, "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijkl1", NULL); ASSERT (nm_setting_verify (NM_SETTING (s_gsm), NULL, NULL) == FALSE, "gsm-apn-bad-chars", "unexpectedly valid GSM setting"); } static void test_setting_gsm_apn_underscore (void) { NMSettingGsm *s_gsm; GError *error = NULL; gboolean success; s_gsm = (NMSettingGsm *) nm_setting_gsm_new (); g_assert (s_gsm); g_object_set (s_gsm, NM_SETTING_GSM_NUMBER, "*99#", NULL); /* 65-character long */ g_object_set (s_gsm, NM_SETTING_GSM_APN, "foobar_baz", NULL); success = nm_setting_verify (NM_SETTING (s_gsm), NULL, &error); g_assert_no_error (error); g_assert (success == TRUE); } static void test_setting_gsm_without_number (void) { NMSettingGsm *s_gsm; GError *error = NULL; gboolean success; s_gsm = (NMSettingGsm *) nm_setting_gsm_new (); g_assert (s_gsm); g_object_set (s_gsm, NM_SETTING_GSM_NUMBER, NULL, NULL); success = nm_setting_verify (NM_SETTING (s_gsm), NULL, &error); g_assert_no_error (error); g_assert (success == TRUE); g_object_set (s_gsm, NM_SETTING_GSM_NUMBER, "", NULL); success = nm_setting_verify (NM_SETTING (s_gsm), NULL, &error); g_assert_error (error, NM_SETTING_GSM_ERROR, NM_SETTING_GSM_ERROR_INVALID_PROPERTY); g_error_free (error); } static NMSettingWirelessSecurity * make_test_wsec_setting (const char *detail) { NMSettingWirelessSecurity *s_wsec; s_wsec = (NMSettingWirelessSecurity *) nm_setting_wireless_security_new (); ASSERT (s_wsec != NULL, detail, "error creating setting"); g_object_set (s_wsec, NM_SETTING_WIRELESS_SECURITY_KEY_MGMT, "wpa-psk", NM_SETTING_WIRELESS_SECURITY_LEAP_USERNAME, "foobarbaz", NM_SETTING_WIRELESS_SECURITY_PSK, "random psk", NM_SETTING_WIRELESS_SECURITY_WEP_KEY0, "aaaaaaaaaa", NULL); return s_wsec; } static void test_setting_to_hash_all (void) { NMSettingWirelessSecurity *s_wsec; GHashTable *hash; s_wsec = make_test_wsec_setting ("setting-to-hash-all"); hash = nm_setting_to_hash (NM_SETTING (s_wsec), NM_SETTING_HASH_FLAG_ALL); /* Make sure all keys are there */ ASSERT (g_hash_table_lookup (hash, NM_SETTING_WIRELESS_SECURITY_KEY_MGMT), "setting-to-hash-all", "unexpectedly missing " NM_SETTING_WIRELESS_SECURITY_KEY_MGMT); ASSERT (g_hash_table_lookup (hash, NM_SETTING_WIRELESS_SECURITY_LEAP_USERNAME), "setting-to-hash-all", "unexpectedly missing " NM_SETTING_WIRELESS_SECURITY_LEAP_USERNAME); ASSERT (g_hash_table_lookup (hash, NM_SETTING_WIRELESS_SECURITY_PSK), "setting-to-hash-all", "unexpectedly missing " NM_SETTING_WIRELESS_SECURITY_PSK); ASSERT (g_hash_table_lookup (hash, NM_SETTING_WIRELESS_SECURITY_WEP_KEY0), "setting-to-hash-all", "unexpectedly missing " NM_SETTING_WIRELESS_SECURITY_WEP_KEY0); g_hash_table_destroy (hash); g_object_unref (s_wsec); } static void test_setting_to_hash_no_secrets (void) { NMSettingWirelessSecurity *s_wsec; GHashTable *hash; s_wsec = make_test_wsec_setting ("setting-to-hash-no-secrets"); hash = nm_setting_to_hash (NM_SETTING (s_wsec), NM_SETTING_HASH_FLAG_NO_SECRETS); /* Make sure non-secret keys are there */ ASSERT (g_hash_table_lookup (hash, NM_SETTING_WIRELESS_SECURITY_KEY_MGMT), "setting-to-hash-no-secrets", "unexpectedly missing " NM_SETTING_WIRELESS_SECURITY_KEY_MGMT); ASSERT (g_hash_table_lookup (hash, NM_SETTING_WIRELESS_SECURITY_LEAP_USERNAME), "setting-to-hash-no-secrets", "unexpectedly missing " NM_SETTING_WIRELESS_SECURITY_LEAP_USERNAME); /* Make sure secrets are not there */ ASSERT (g_hash_table_lookup (hash, NM_SETTING_WIRELESS_SECURITY_PSK) == NULL, "setting-to-hash-no-secrets", "unexpectedly present " NM_SETTING_WIRELESS_SECURITY_PSK); ASSERT (g_hash_table_lookup (hash, NM_SETTING_WIRELESS_SECURITY_WEP_KEY0) == NULL, "setting-to-hash-no-secrets", "unexpectedly present " NM_SETTING_WIRELESS_SECURITY_WEP_KEY0); g_hash_table_destroy (hash); g_object_unref (s_wsec); } static void test_setting_to_hash_only_secrets (void) { NMSettingWirelessSecurity *s_wsec; GHashTable *hash; s_wsec = make_test_wsec_setting ("setting-to-hash-only-secrets"); hash = nm_setting_to_hash (NM_SETTING (s_wsec), NM_SETTING_HASH_FLAG_ONLY_SECRETS); /* Make sure non-secret keys are there */ ASSERT (g_hash_table_lookup (hash, NM_SETTING_WIRELESS_SECURITY_KEY_MGMT) == NULL, "setting-to-hash-only-secrets", "unexpectedly present " NM_SETTING_WIRELESS_SECURITY_KEY_MGMT); ASSERT (g_hash_table_lookup (hash, NM_SETTING_WIRELESS_SECURITY_LEAP_USERNAME) == NULL, "setting-to-hash-only-secrets", "unexpectedly present " NM_SETTING_WIRELESS_SECURITY_LEAP_USERNAME); /* Make sure secrets are not there */ ASSERT (g_hash_table_lookup (hash, NM_SETTING_WIRELESS_SECURITY_PSK), "setting-to-hash-only-secrets", "unexpectedly missing " NM_SETTING_WIRELESS_SECURITY_PSK); ASSERT (g_hash_table_lookup (hash, NM_SETTING_WIRELESS_SECURITY_WEP_KEY0), "setting-to-hash-only-secrets", "unexpectedly missing " NM_SETTING_WIRELESS_SECURITY_WEP_KEY0); g_hash_table_destroy (hash); g_object_unref (s_wsec); } static void test_connection_to_hash_setting_name (void) { NMConnection *connection; NMSettingWirelessSecurity *s_wsec; GHashTable *hash; connection = nm_connection_new (); s_wsec = make_test_wsec_setting ("connection-to-hash-setting-name"); nm_connection_add_setting (connection, NM_SETTING (s_wsec)); hash = nm_connection_to_hash (connection, NM_SETTING_HASH_FLAG_ALL); /* Make sure the keys of the first level hash are setting names, not * the GType name of the setting objects. */ ASSERT (g_hash_table_lookup (hash, NM_SETTING_WIRELESS_SECURITY_SETTING_NAME) != NULL, "connection-to-hash-setting-name", "unexpectedly missing " NM_SETTING_WIRELESS_SECURITY_SETTING_NAME); g_hash_table_destroy (hash); g_object_unref (connection); } static void test_setting_new_from_hash (void) { NMSettingWirelessSecurity *s_wsec; GHashTable *hash; s_wsec = make_test_wsec_setting ("setting-to-hash-all"); hash = nm_setting_to_hash (NM_SETTING (s_wsec), NM_SETTING_HASH_FLAG_ALL); g_object_unref (s_wsec); s_wsec = (NMSettingWirelessSecurity *) nm_setting_new_from_hash (NM_TYPE_SETTING_WIRELESS_SECURITY, hash); g_hash_table_destroy (hash); g_assert (s_wsec); g_assert_cmpstr (nm_setting_wireless_security_get_key_mgmt (s_wsec), ==, "wpa-psk"); g_assert_cmpstr (nm_setting_wireless_security_get_leap_username (s_wsec), ==, "foobarbaz"); g_assert_cmpstr (nm_setting_wireless_security_get_psk (s_wsec), ==, "random psk"); g_object_unref (s_wsec); } static NMConnection * new_test_connection (void) { NMConnection *connection; NMSetting *setting; char *uuid; guint64 timestamp = time (NULL); connection = nm_connection_new (); setting = nm_setting_connection_new (); uuid = nm_utils_uuid_generate (); g_object_set (G_OBJECT (setting), NM_SETTING_CONNECTION_ID, "foobar", NM_SETTING_CONNECTION_UUID, uuid, NM_SETTING_CONNECTION_TYPE, NM_SETTING_WIRED_SETTING_NAME, NM_SETTING_CONNECTION_TIMESTAMP, timestamp, NULL); g_free (uuid); nm_connection_add_setting (connection, setting); setting = nm_setting_wired_new (); g_object_set (G_OBJECT (setting), NM_SETTING_WIRED_MTU, 1592, NULL); nm_connection_add_setting (connection, setting); setting = nm_setting_ip4_config_new (); g_object_set (G_OBJECT (setting), NM_SETTING_IP4_CONFIG_METHOD, NM_SETTING_IP4_CONFIG_METHOD_AUTO, NM_SETTING_IP4_CONFIG_DHCP_HOSTNAME, "eyeofthetiger", NULL); nm_connection_add_setting (connection, setting); return connection; } static GValue * string_to_gvalue (const char *str) { GValue *val; val = g_slice_new0 (GValue); g_value_init (val, G_TYPE_STRING); g_value_set_string (val, str); return val; } static void destroy_gvalue (gpointer data) { g_value_unset ((GValue *) data); g_slice_free (GValue, data); } static GHashTable * new_connection_hash (char **out_uuid, const char **out_expected_id, const char **out_expected_ip6_method) { GHashTable *hash; GHashTable *setting; hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, (GDestroyNotify) g_hash_table_destroy); *out_uuid = nm_utils_uuid_generate (); *out_expected_id = "My happy connection"; *out_expected_ip6_method = NM_SETTING_IP6_CONFIG_METHOD_LINK_LOCAL; /* Connection setting */ setting = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, destroy_gvalue); g_hash_table_insert (setting, g_strdup (NM_SETTING_NAME), string_to_gvalue (NM_SETTING_CONNECTION_SETTING_NAME)); g_hash_table_insert (setting, g_strdup (NM_SETTING_CONNECTION_ID), string_to_gvalue (*out_expected_id)); g_hash_table_insert (setting, g_strdup (NM_SETTING_CONNECTION_UUID), string_to_gvalue (*out_uuid)); g_hash_table_insert (setting, g_strdup (NM_SETTING_CONNECTION_TYPE), string_to_gvalue (NM_SETTING_WIRED_SETTING_NAME)); g_hash_table_insert (hash, g_strdup (NM_SETTING_CONNECTION_SETTING_NAME), setting); /* Wired setting */ setting = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, destroy_gvalue); g_hash_table_insert (hash, g_strdup (NM_SETTING_WIRED_SETTING_NAME), setting); /* IP6 */ setting = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, destroy_gvalue); g_hash_table_insert (setting, g_strdup (NM_SETTING_IP6_CONFIG_METHOD), string_to_gvalue (*out_expected_ip6_method)); g_hash_table_insert (hash, g_strdup (NM_SETTING_IP6_CONFIG_SETTING_NAME), setting); return hash; } static void test_connection_replace_settings () { NMConnection *connection; GHashTable *new_settings; GError *error = NULL; gboolean success; NMSettingConnection *s_con; NMSettingIP6Config *s_ip6; char *uuid = NULL; const char *expected_id = NULL, *expected_method = NULL; connection = new_test_connection (); new_settings = new_connection_hash (&uuid, &expected_id, &expected_method); g_assert (new_settings); /* Replace settings and test */ success = nm_connection_replace_settings (connection, new_settings, &error); g_assert_no_error (error); g_assert (success); s_con = nm_connection_get_setting_connection (connection); g_assert (s_con); g_assert_cmpstr (nm_setting_connection_get_id (s_con), ==, expected_id); g_assert_cmpstr (nm_setting_connection_get_uuid (s_con), ==, uuid); g_assert (nm_connection_get_setting_wired (connection)); g_assert (!nm_connection_get_setting_ip4_config (connection)); s_ip6 = nm_connection_get_setting_ip6_config (connection); g_assert (s_ip6); g_assert_cmpstr (nm_setting_ip6_config_get_method (s_ip6), ==, expected_method); g_free (uuid); g_hash_table_destroy (new_settings); g_object_unref (connection); } static void test_connection_replace_settings_from_connection () { NMConnection *connection, *replacement; GError *error = NULL; gboolean success; NMSettingConnection *s_con; NMSetting *setting; GByteArray *ssid; char *uuid = NULL; const char *expected_id = "Awesome connection"; connection = new_test_connection (); g_assert (connection); replacement = nm_connection_new (); g_assert (replacement); /* New connection setting */ setting = nm_setting_connection_new (); g_assert (setting); uuid = nm_utils_uuid_generate (); g_object_set (setting, NM_SETTING_CONNECTION_ID, expected_id, NM_SETTING_CONNECTION_UUID, uuid, NM_SETTING_CONNECTION_TYPE, NM_SETTING_WIRELESS_SETTING_NAME, NULL); nm_connection_add_setting (replacement, setting); /* New wifi setting */ setting = nm_setting_wireless_new (); g_assert (setting); ssid = g_byte_array_new (); g_byte_array_append (ssid, (const guint8 *) "1234567", 7); g_object_set (setting, NM_SETTING_WIRELESS_SSID, ssid, NM_SETTING_WIRELESS_MODE, "infrastructure", NULL); g_byte_array_free (ssid, TRUE); nm_connection_add_setting (replacement, setting); /* Replace settings and test */ success = nm_connection_replace_settings_from_connection (connection, replacement, &error); g_assert_no_error (error); g_assert (success); s_con = nm_connection_get_setting_connection (connection); g_assert (s_con); g_assert_cmpstr (nm_setting_connection_get_id (s_con), ==, expected_id); g_assert_cmpstr (nm_setting_connection_get_uuid (s_con), ==, uuid); g_assert (!nm_connection_get_setting_wired (connection)); g_assert (!nm_connection_get_setting_ip6_config (connection)); g_assert (nm_connection_get_setting_wireless (connection)); g_free (uuid); g_object_unref (replacement); g_object_unref (connection); } static void test_connection_new_from_hash () { NMConnection *connection; GHashTable *new_settings; GError *error = NULL; NMSettingConnection *s_con; NMSettingIP6Config *s_ip6; char *uuid = NULL; const char *expected_id = NULL, *expected_method = NULL; new_settings = new_connection_hash (&uuid, &expected_id, &expected_method); g_assert (new_settings); /* Replace settings and test */ connection = nm_connection_new_from_hash (new_settings, &error); g_assert_no_error (error); g_assert (connection); s_con = nm_connection_get_setting_connection (connection); g_assert (s_con); g_assert_cmpstr (nm_setting_connection_get_id (s_con), ==, expected_id); g_assert_cmpstr (nm_setting_connection_get_uuid (s_con), ==, uuid); g_assert (nm_connection_get_setting_wired (connection)); g_assert (!nm_connection_get_setting_ip4_config (connection)); s_ip6 = nm_connection_get_setting_ip6_config (connection); g_assert (s_ip6); g_assert_cmpstr (nm_setting_ip6_config_get_method (s_ip6), ==, expected_method); g_free (uuid); g_hash_table_destroy (new_settings); g_object_unref (connection); } static void check_permission (NMSettingConnection *s_con, guint32 idx, const char *expected_uname, const char *tag) { gboolean success; const char *ptype = NULL, *pitem = NULL, *detail = NULL; success = nm_setting_connection_get_permission (s_con, 0, &ptype, &pitem, &detail); ASSERT (success == TRUE, tag, "unexpected failure getting added permission"); /* Permission type */ ASSERT (ptype != NULL, tag, "unexpected failure getting permission type"); ASSERT (strcmp (ptype, "user") == 0, tag, "retrieved unexpected permission type"); /* Permission item */ ASSERT (pitem != NULL, tag, "unexpected failure getting permission item"); ASSERT (strcmp (pitem, expected_uname) == 0, tag, "retrieved unexpected permission item"); ASSERT (detail == NULL, tag, "unexpected success getting permission detail"); } #define TEST_UNAME "asdfasfasdf" static void test_setting_connection_permissions_helpers (void) { NMSettingConnection *s_con; gboolean success; char buf[9] = { 0x61, 0x62, 0x63, 0xff, 0xfe, 0xfd, 0x23, 0x01, 0x00 }; GSList *list = NULL; const char *expected_perm = "user:" TEST_UNAME ":"; s_con = NM_SETTING_CONNECTION (nm_setting_connection_new ()); /* Ensure a bad [type] is rejected */ success = nm_setting_connection_add_permission (s_con, "foobar", "blah", NULL); ASSERT (success == FALSE, "setting-connection-permissions-helpers", "unexpected success adding bad permission type #1"); /* Ensure a bad [type] is rejected */ success = nm_setting_connection_add_permission (s_con, NULL, "blah", NULL); ASSERT (success == FALSE, "setting-connection-permissions-helpers", "unexpected success adding bad permission type #2"); /* Ensure a bad [item] is rejected */ success = nm_setting_connection_add_permission (s_con, "user", NULL, NULL); ASSERT (success == FALSE, "setting-connection-permissions-helpers", "unexpected success adding bad permission item #1"); /* Ensure a bad [item] is rejected */ success = nm_setting_connection_add_permission (s_con, "user", "", NULL); ASSERT (success == FALSE, "setting-connection-permissions-helpers", "unexpected success adding bad permission item #2"); /* Ensure an [item] with ':' is rejected */ success = nm_setting_connection_add_permission (s_con, "user", "ad:asdf", NULL); ASSERT (success == FALSE, "setting-connection-permissions-helpers", "unexpected success adding bad permission item #3"); /* Ensure a non-UTF-8 [item] is rejected */ success = nm_setting_connection_add_permission (s_con, "user", buf, NULL); ASSERT (success == FALSE, "setting-connection-permissions-helpers", "unexpected success adding bad permission item #4"); /* Ensure a non-NULL [detail] is rejected */ success = nm_setting_connection_add_permission (s_con, "user", "dafasdf", "asdf"); ASSERT (success == FALSE, "setting-connection-permissions-helpers", "unexpected success adding bad detail"); /* Ensure a valid call results in success */ success = nm_setting_connection_add_permission (s_con, "user", TEST_UNAME, NULL); ASSERT (success == TRUE, "setting-connection-permissions-helpers", "unexpected failure adding valid user permisson"); ASSERT (nm_setting_connection_get_num_permissions (s_con) == 1, "setting-connection-permissions-helpers", "unexpected failure getting number of permissions"); check_permission (s_con, 0, TEST_UNAME, "setting-connection-permissions-helpers"); /* Check the actual GObject property just to be paranoid */ g_object_get (G_OBJECT (s_con), NM_SETTING_CONNECTION_PERMISSIONS, &list, NULL); ASSERT (list != NULL, "setting-connection-permissions-helpers", "unexpected failure getting permissions list"); ASSERT (g_slist_length (list) == 1, "setting-connection-permissions-helpers", "unexpected failure getting number of permissions in list"); ASSERT (strcmp (list->data, expected_perm) == 0, "setting-connection-permissions-helpers", "unexpected permission property data"); g_slist_free_full (list, g_free); /* Now remove that permission and ensure we have 0 permissions */ nm_setting_connection_remove_permission (s_con, 0); ASSERT (nm_setting_connection_get_num_permissions (s_con) == 0, "setting-connection-permissions-helpers", "unexpected failure removing permission"); g_object_unref (s_con); } static void add_permission_property (NMSettingConnection *s_con, const char *ptype, const char *pitem, int pitem_len, const char *detail) { GString *str; GSList *list = NULL; str = g_string_sized_new (50); if (ptype) g_string_append (str, ptype); g_string_append_c (str, ':'); if (pitem) { if (pitem_len >= 0) g_string_append_len (str, pitem, pitem_len); else g_string_append (str, pitem); } g_string_append_c (str, ':'); if (detail) g_string_append (str, detail); list = g_slist_append (list, str->str); g_object_set (G_OBJECT (s_con), NM_SETTING_CONNECTION_PERMISSIONS, list, NULL); g_string_free (str, TRUE); g_slist_free (list); } static void test_setting_connection_permissions_property (void) { NMSettingConnection *s_con; gboolean success; char buf[9] = { 0x61, 0x62, 0x63, 0xff, 0xfe, 0xfd, 0x23, 0x01, 0x00 }; s_con = NM_SETTING_CONNECTION (nm_setting_connection_new ()); /* Ensure a bad [type] is rejected */ add_permission_property (s_con, "foobar", "blah", -1, NULL); ASSERT (nm_setting_connection_get_num_permissions (s_con) == 0, "setting-connection-permissions-property", "unexpected success adding bad permission type #1"); /* Ensure a bad [type] is rejected */ add_permission_property (s_con, NULL, "blah", -1, NULL); ASSERT (nm_setting_connection_get_num_permissions (s_con) == 0, "setting-connection-permissions-property", "unexpected success adding bad permission type #2"); /* Ensure a bad [item] is rejected */ add_permission_property (s_con, "user", NULL, -1, NULL); ASSERT (nm_setting_connection_get_num_permissions (s_con) == 0, "setting-connection-permissions-property", "unexpected success adding bad permission item #1"); /* Ensure a bad [item] is rejected */ add_permission_property (s_con, "user", "", -1, NULL); ASSERT (nm_setting_connection_get_num_permissions (s_con) == 0, "setting-connection-permissions-property", "unexpected success adding bad permission item #2"); /* Ensure an [item] with ':' in the middle is rejected */ add_permission_property (s_con, "user", "ad:asdf", -1, NULL); ASSERT (nm_setting_connection_get_num_permissions (s_con) == 0, "setting-connection-permissions-property", "unexpected success adding bad permission item #3"); /* Ensure an [item] with ':' at the end is rejected */ add_permission_property (s_con, "user", "adasdfaf:", -1, NULL); ASSERT (nm_setting_connection_get_num_permissions (s_con) == 0, "setting-connection-permissions-property", "unexpected success adding bad permission item #4"); /* Ensure a non-UTF-8 [item] is rejected */ add_permission_property (s_con, "user", buf, (int) sizeof (buf), NULL); ASSERT (nm_setting_connection_get_num_permissions (s_con) == 0, "setting-connection-permissions-property", "unexpected success adding bad permission item #5"); /* Ensure a non-NULL [detail] is rejected */ add_permission_property (s_con, "user", "dafasdf", -1, "asdf"); ASSERT (nm_setting_connection_get_num_permissions (s_con) == 0, "setting-connection-permissions-property", "unexpected success adding bad detail"); /* Ensure a valid call results in success */ success = nm_setting_connection_add_permission (s_con, "user", TEST_UNAME, NULL); ASSERT (nm_setting_connection_get_num_permissions (s_con) == 1, "setting-connection-permissions-property", "unexpected failure adding valid user permisson"); check_permission (s_con, 0, TEST_UNAME, "setting-connection-permissions-property"); /* Now remove that permission and ensure we have 0 permissions */ nm_setting_connection_remove_permission (s_con, 0); ASSERT (nm_setting_connection_get_num_permissions (s_con) == 0, "setting-connection-permissions-property", "unexpected failure removing permission"); g_object_unref (s_con); } static void test_connection_compare_same (void) { NMConnection *a, *b; a = new_test_connection (); b = nm_connection_duplicate (a); g_assert (nm_connection_compare (a, b, NM_SETTING_COMPARE_FLAG_EXACT)); g_object_unref (a); g_object_unref (b); } static void test_connection_compare_key_only_in_a (void) { NMConnection *a, *b; NMSettingConnection *s_con; a = new_test_connection (); b = nm_connection_duplicate (a); s_con = (NMSettingConnection *) nm_connection_get_setting (b, NM_TYPE_SETTING_CONNECTION); g_assert (s_con); g_object_set (s_con, NM_SETTING_CONNECTION_TIMESTAMP, (gulong) 0, NULL); g_assert (!nm_connection_compare (a, b, NM_SETTING_COMPARE_FLAG_EXACT)); g_object_unref (a); g_object_unref (b); } static void test_connection_compare_setting_only_in_a (void) { NMConnection *a, *b; a = new_test_connection (); b = nm_connection_duplicate (a); nm_connection_remove_setting (b, NM_TYPE_SETTING_IP4_CONFIG); g_assert (!nm_connection_compare (a, b, NM_SETTING_COMPARE_FLAG_EXACT)); g_object_unref (a); g_object_unref (b); } static void test_connection_compare_key_only_in_b (void) { NMConnection *a, *b; NMSettingConnection *s_con; a = new_test_connection (); b = nm_connection_duplicate (a); s_con = (NMSettingConnection *) nm_connection_get_setting (b, NM_TYPE_SETTING_CONNECTION); g_assert (s_con); g_object_set (s_con, NM_SETTING_CONNECTION_TIMESTAMP, (gulong) 0, NULL); g_assert (!nm_connection_compare (a, b, NM_SETTING_COMPARE_FLAG_EXACT)); g_object_unref (a); g_object_unref (b); } static void test_connection_compare_setting_only_in_b (void) { NMConnection *a, *b; a = new_test_connection (); b = nm_connection_duplicate (a); nm_connection_remove_setting (a, NM_TYPE_SETTING_IP4_CONFIG); g_assert (!nm_connection_compare (a, b, NM_SETTING_COMPARE_FLAG_EXACT)); g_object_unref (a); g_object_unref (b); } typedef struct { const char *key_name; guint32 result; } DiffKey; typedef struct { const char *name; DiffKey keys[30]; } DiffSetting; #define ARRAY_LEN(a) (sizeof (a) / sizeof (a[0])) static void ensure_diffs (GHashTable *diffs, const DiffSetting *check, gsize n_check) { guint i; g_assert (g_hash_table_size (diffs) == n_check); /* Loop through the settings */ for (i = 0; i < n_check; i++) { GHashTable *setting_hash; guint z = 0; setting_hash = g_hash_table_lookup (diffs, check[i].name); g_assert (setting_hash); /* Get the number of keys to check */ while (check[i].keys[z].key_name) z++; g_assert (g_hash_table_size (setting_hash) == z); /* Now compare the actual keys */ for (z = 0; check[i].keys[z].key_name; z++) { NMSettingDiffResult result; result = GPOINTER_TO_UINT (g_hash_table_lookup (setting_hash, check[i].keys[z].key_name)); g_assert (result == check[i].keys[z].result); } } } static void test_connection_diff_a_only (void) { NMConnection *connection; GHashTable *out_diffs = NULL; gboolean same; const DiffSetting settings[] = { { NM_SETTING_CONNECTION_SETTING_NAME, { { NM_SETTING_CONNECTION_ID, NM_SETTING_DIFF_RESULT_IN_A }, { NM_SETTING_CONNECTION_UUID, NM_SETTING_DIFF_RESULT_IN_A }, { NM_SETTING_CONNECTION_INTERFACE_NAME, NM_SETTING_DIFF_RESULT_IN_A }, { NM_SETTING_CONNECTION_TYPE, NM_SETTING_DIFF_RESULT_IN_A }, { NM_SETTING_CONNECTION_TIMESTAMP, NM_SETTING_DIFF_RESULT_IN_A }, { NM_SETTING_CONNECTION_AUTOCONNECT, NM_SETTING_DIFF_RESULT_IN_A }, { NM_SETTING_CONNECTION_READ_ONLY, NM_SETTING_DIFF_RESULT_IN_A }, { NM_SETTING_CONNECTION_PERMISSIONS, NM_SETTING_DIFF_RESULT_IN_A }, { NM_SETTING_CONNECTION_ZONE, NM_SETTING_DIFF_RESULT_IN_A }, { NM_SETTING_CONNECTION_MASTER, NM_SETTING_DIFF_RESULT_IN_A }, { NM_SETTING_CONNECTION_SLAVE_TYPE, NM_SETTING_DIFF_RESULT_IN_A }, { NM_SETTING_CONNECTION_SECONDARIES, NM_SETTING_DIFF_RESULT_IN_A }, { NM_SETTING_CONNECTION_GATEWAY_PING_TIMEOUT, NM_SETTING_DIFF_RESULT_IN_A }, { NULL, NM_SETTING_DIFF_RESULT_UNKNOWN } } }, { NM_SETTING_WIRED_SETTING_NAME, { { NM_SETTING_WIRED_PORT, NM_SETTING_DIFF_RESULT_IN_A }, { NM_SETTING_WIRED_SPEED, NM_SETTING_DIFF_RESULT_IN_A }, { NM_SETTING_WIRED_DUPLEX, NM_SETTING_DIFF_RESULT_IN_A }, { NM_SETTING_WIRED_AUTO_NEGOTIATE, NM_SETTING_DIFF_RESULT_IN_A }, { NM_SETTING_WIRED_MAC_ADDRESS, NM_SETTING_DIFF_RESULT_IN_A }, { NM_SETTING_WIRED_CLONED_MAC_ADDRESS, NM_SETTING_DIFF_RESULT_IN_A }, { NM_SETTING_WIRED_MAC_ADDRESS_BLACKLIST, NM_SETTING_DIFF_RESULT_IN_A }, { NM_SETTING_WIRED_MTU, NM_SETTING_DIFF_RESULT_IN_A }, { NM_SETTING_WIRED_S390_SUBCHANNELS, NM_SETTING_DIFF_RESULT_IN_A }, { NM_SETTING_WIRED_S390_NETTYPE, NM_SETTING_DIFF_RESULT_IN_A }, { NM_SETTING_WIRED_S390_OPTIONS, NM_SETTING_DIFF_RESULT_IN_A }, { NULL, NM_SETTING_DIFF_RESULT_UNKNOWN }, } }, { NM_SETTING_IP4_CONFIG_SETTING_NAME, { { NM_SETTING_IP4_CONFIG_METHOD, NM_SETTING_DIFF_RESULT_IN_A }, { NM_SETTING_IP4_CONFIG_DNS, NM_SETTING_DIFF_RESULT_IN_A }, { NM_SETTING_IP4_CONFIG_DNS_SEARCH, NM_SETTING_DIFF_RESULT_IN_A }, { NM_SETTING_IP4_CONFIG_ADDRESSES, NM_SETTING_DIFF_RESULT_IN_A }, { NM_SETTING_IP4_CONFIG_ROUTES, NM_SETTING_DIFF_RESULT_IN_A }, { NM_SETTING_IP4_CONFIG_IGNORE_AUTO_ROUTES, NM_SETTING_DIFF_RESULT_IN_A }, { NM_SETTING_IP4_CONFIG_IGNORE_AUTO_DNS, NM_SETTING_DIFF_RESULT_IN_A }, { NM_SETTING_IP4_CONFIG_DHCP_CLIENT_ID, NM_SETTING_DIFF_RESULT_IN_A }, { NM_SETTING_IP4_CONFIG_DHCP_SEND_HOSTNAME, NM_SETTING_DIFF_RESULT_IN_A }, { NM_SETTING_IP4_CONFIG_DHCP_HOSTNAME, NM_SETTING_DIFF_RESULT_IN_A }, { NM_SETTING_IP4_CONFIG_NEVER_DEFAULT, NM_SETTING_DIFF_RESULT_IN_A }, { NM_SETTING_IP4_CONFIG_MAY_FAIL, NM_SETTING_DIFF_RESULT_IN_A }, { NULL, NM_SETTING_DIFF_RESULT_UNKNOWN }, } }, }; connection = new_test_connection (); same = nm_connection_diff (connection, NULL, NM_SETTING_COMPARE_FLAG_EXACT, &out_diffs); g_assert (same == FALSE); g_assert (out_diffs != NULL); g_assert (g_hash_table_size (out_diffs) > 0); ensure_diffs (out_diffs, settings, ARRAY_LEN (settings)); g_hash_table_destroy (out_diffs); g_object_unref (connection); } static void test_connection_diff_same (void) { NMConnection *a, *b; GHashTable *out_diffs = NULL; gboolean same; a = new_test_connection (); b = nm_connection_duplicate (a); same = nm_connection_diff (a, b, NM_SETTING_COMPARE_FLAG_EXACT, &out_diffs); g_assert (same == TRUE); g_assert (out_diffs == NULL); g_object_unref (a); g_object_unref (b); } static void test_connection_diff_different (void) { NMConnection *a, *b; GHashTable *out_diffs = NULL; NMSettingIP4Config *s_ip4; gboolean same; const DiffSetting settings[] = { { NM_SETTING_IP4_CONFIG_SETTING_NAME, { { NM_SETTING_IP4_CONFIG_METHOD, NM_SETTING_DIFF_RESULT_IN_A | NM_SETTING_DIFF_RESULT_IN_B }, { NULL, NM_SETTING_DIFF_RESULT_UNKNOWN }, } }, }; a = new_test_connection (); b = nm_connection_duplicate (a); s_ip4 = nm_connection_get_setting_ip4_config (a); g_assert (s_ip4); g_object_set (G_OBJECT (s_ip4), NM_SETTING_IP4_CONFIG_METHOD, NM_SETTING_IP4_CONFIG_METHOD_MANUAL, NULL); same = nm_connection_diff (a, b, NM_SETTING_COMPARE_FLAG_EXACT, &out_diffs); g_assert (same == FALSE); g_assert (out_diffs != NULL); g_assert (g_hash_table_size (out_diffs) > 0); ensure_diffs (out_diffs, settings, ARRAY_LEN (settings)); g_hash_table_destroy (out_diffs); g_object_unref (a); g_object_unref (b); } static void test_connection_diff_no_secrets (void) { NMConnection *a, *b; GHashTable *out_diffs = NULL; NMSetting *s_pppoe; gboolean same; const DiffSetting settings[] = { { NM_SETTING_PPPOE_SETTING_NAME, { { NM_SETTING_PPPOE_PASSWORD, NM_SETTING_DIFF_RESULT_IN_B }, { NULL, NM_SETTING_DIFF_RESULT_UNKNOWN }, } }, }; a = new_test_connection (); s_pppoe = nm_setting_pppoe_new (); g_object_set (G_OBJECT (s_pppoe), NM_SETTING_PPPOE_USERNAME, "thomas", NULL); nm_connection_add_setting (a, s_pppoe); b = nm_connection_duplicate (a); /* Add a secret to B */ s_pppoe = NM_SETTING (nm_connection_get_setting_pppoe (b)); g_assert (s_pppoe); g_object_set (G_OBJECT (s_pppoe), NM_SETTING_PPPOE_PASSWORD, "secretpassword", NULL); /* Make sure the diff returns no results as secrets are ignored */ same = nm_connection_diff (a, b, NM_SETTING_COMPARE_FLAG_IGNORE_SECRETS, &out_diffs); g_assert (same == TRUE); g_assert (out_diffs == NULL); /* Now make sure the diff returns results if secrets are not ignored */ same = nm_connection_diff (a, b, NM_SETTING_COMPARE_FLAG_EXACT, &out_diffs); g_assert (same == FALSE); g_assert (out_diffs != NULL); g_assert (g_hash_table_size (out_diffs) > 0); ensure_diffs (out_diffs, settings, ARRAY_LEN (settings)); g_hash_table_destroy (out_diffs); g_object_unref (a); g_object_unref (b); } static void add_generic_settings (NMConnection *connection, const char *ctype) { NMSetting *setting; char *uuid; uuid = nm_utils_uuid_generate (); setting = nm_setting_connection_new (); g_object_set (setting, NM_SETTING_CONNECTION_ID, "asdfasdfadf", NM_SETTING_CONNECTION_TYPE, ctype, NM_SETTING_CONNECTION_UUID, uuid, NULL); nm_connection_add_setting (connection, setting); g_free (uuid); setting = nm_setting_ip4_config_new (); g_object_set (setting, NM_SETTING_IP4_CONFIG_METHOD, NM_SETTING_IP4_CONFIG_METHOD_AUTO, NULL); nm_connection_add_setting (connection, setting); setting = nm_setting_ip6_config_new (); g_object_set (setting, NM_SETTING_IP6_CONFIG_METHOD, NM_SETTING_IP6_CONFIG_METHOD_AUTO, NULL); nm_connection_add_setting (connection, setting); } static void test_connection_good_base_types (void) { NMConnection *connection; NMSetting *setting; gboolean success; GError *error = NULL; GByteArray *array; const guint8 bdaddr[] = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66 }; /* Try a basic wired connection */ connection = nm_connection_new (); add_generic_settings (connection, NM_SETTING_WIRED_SETTING_NAME); setting = nm_setting_wired_new (); nm_connection_add_setting (connection, setting); success = nm_connection_verify (connection, &error); g_assert_no_error (error); g_assert (success); g_object_unref (connection); /* Try a wired PPPoE connection */ connection = nm_connection_new (); add_generic_settings (connection, NM_SETTING_PPPOE_SETTING_NAME); setting = nm_setting_pppoe_new (); g_object_set (setting, NM_SETTING_PPPOE_USERNAME, "bob smith", NULL); nm_connection_add_setting (connection, setting); success = nm_connection_verify (connection, &error); g_assert_no_error (error); g_assert (success); g_object_unref (connection); /* Wifi connection */ connection = nm_connection_new (); add_generic_settings (connection, NM_SETTING_WIRELESS_SETTING_NAME); setting = nm_setting_wireless_new (); array = g_byte_array_new (); g_byte_array_append (array, (const guint8 *) "1234567", 7); g_object_set (setting, NM_SETTING_WIRELESS_SSID, array, NM_SETTING_WIRELESS_MODE, "infrastructure", NULL); g_byte_array_free (array, TRUE); nm_connection_add_setting (connection, setting); success = nm_connection_verify (connection, &error); g_assert_no_error (error); g_assert (success); g_object_unref (connection); /* Bluetooth connection */ connection = nm_connection_new (); add_generic_settings (connection, NM_SETTING_BLUETOOTH_SETTING_NAME); setting = nm_setting_bluetooth_new (); array = g_byte_array_new (); g_byte_array_append (array, bdaddr, sizeof (bdaddr)); g_object_set (setting, NM_SETTING_BLUETOOTH_BDADDR, array, NM_SETTING_CONNECTION_TYPE, NM_SETTING_BLUETOOTH_TYPE_PANU, NULL); g_byte_array_free (array, TRUE); nm_connection_add_setting (connection, setting); success = nm_connection_verify (connection, &error); g_assert_no_error (error); g_assert (success); g_object_unref (connection); /* WiMAX connection */ connection = nm_connection_new (); add_generic_settings (connection, NM_SETTING_WIMAX_SETTING_NAME); setting = nm_setting_wimax_new (); g_object_set (setting, NM_SETTING_WIMAX_NETWORK_NAME, "CLEAR", NULL); nm_connection_add_setting (connection, setting); success = nm_connection_verify (connection, &error); g_assert_no_error (error); g_assert (success); g_object_unref (connection); /* GSM connection */ connection = nm_connection_new (); add_generic_settings (connection, NM_SETTING_GSM_SETTING_NAME); setting = nm_setting_gsm_new (); g_object_set (setting, NM_SETTING_GSM_NUMBER, "*99#", NM_SETTING_GSM_APN, "metered.billing.sucks", NULL); nm_connection_add_setting (connection, setting); /* CDMA connection */ connection = nm_connection_new (); add_generic_settings (connection, NM_SETTING_CDMA_SETTING_NAME); setting = nm_setting_cdma_new (); g_object_set (setting, NM_SETTING_CDMA_NUMBER, "#777", NM_SETTING_CDMA_USERNAME, "foobar@vzw.com", NULL); nm_connection_add_setting (connection, setting); success = nm_connection_verify (connection, &error); g_assert_no_error (error); g_assert (success); g_object_unref (connection); } static void test_connection_bad_base_types (void) { NMConnection *connection; NMSetting *setting; gboolean success; GError *error = NULL; /* Test various non-base connection types to make sure they are rejected; * using a fake 'wired' connection so the rest of it verifies */ /* Connection setting */ connection = nm_connection_new (); add_generic_settings (connection, NM_SETTING_CONNECTION_SETTING_NAME); setting = nm_setting_wired_new (); nm_connection_add_setting (connection, setting); success = nm_connection_verify (connection, &error); g_assert_error (error, NM_CONNECTION_ERROR, NM_CONNECTION_ERROR_CONNECTION_TYPE_INVALID); g_assert (success == FALSE); g_object_unref (connection); g_clear_error (&error); /* PPP setting */ connection = nm_connection_new (); add_generic_settings (connection, NM_SETTING_PPP_SETTING_NAME); setting = nm_setting_wired_new (); nm_connection_add_setting (connection, setting); setting = nm_setting_ppp_new (); nm_connection_add_setting (connection, setting); success = nm_connection_verify (connection, &error); g_assert_error (error, NM_CONNECTION_ERROR, NM_CONNECTION_ERROR_CONNECTION_TYPE_INVALID); g_assert (success == FALSE); g_object_unref (connection); g_clear_error (&error); /* Serial setting */ connection = nm_connection_new (); add_generic_settings (connection, NM_SETTING_SERIAL_SETTING_NAME); setting = nm_setting_wired_new (); nm_connection_add_setting (connection, setting); setting = nm_setting_serial_new (); nm_connection_add_setting (connection, setting); success = nm_connection_verify (connection, &error); g_assert_error (error, NM_CONNECTION_ERROR, NM_CONNECTION_ERROR_CONNECTION_TYPE_INVALID); g_assert (success == FALSE); g_object_unref (connection); g_clear_error (&error); /* IP4 setting */ connection = nm_connection_new (); add_generic_settings (connection, NM_SETTING_IP4_CONFIG_SETTING_NAME); setting = nm_setting_wired_new (); nm_connection_add_setting (connection, setting); success = nm_connection_verify (connection, &error); g_assert_error (error, NM_CONNECTION_ERROR, NM_CONNECTION_ERROR_CONNECTION_TYPE_INVALID); g_assert (success == FALSE); g_object_unref (connection); g_clear_error (&error); /* IP6 setting */ connection = nm_connection_new (); add_generic_settings (connection, NM_SETTING_IP6_CONFIG_SETTING_NAME); setting = nm_setting_wired_new (); nm_connection_add_setting (connection, setting); success = nm_connection_verify (connection, &error); g_assert_error (error, NM_CONNECTION_ERROR, NM_CONNECTION_ERROR_CONNECTION_TYPE_INVALID); g_assert (success == FALSE); g_object_unref (connection); g_clear_error (&error); } static void test_setting_compare_id (void) { NMSetting *old, *new; gboolean success; old = nm_setting_connection_new (); g_object_set (old, NM_SETTING_CONNECTION_ID, "really awesome cool connection", NM_SETTING_CONNECTION_UUID, "fbbd59d5-acab-4e30-8f86-258d272617e7", NM_SETTING_CONNECTION_AUTOCONNECT, FALSE, NULL); new = nm_setting_duplicate (old); g_object_set (new, NM_SETTING_CONNECTION_ID, "some different connection id", NULL); /* First make sure they are different */ success = nm_setting_compare (old, new, NM_SETTING_COMPARE_FLAG_EXACT); g_assert (success == FALSE); success = nm_setting_compare (old, new, NM_SETTING_COMPARE_FLAG_IGNORE_ID); g_assert (success); } static void test_setting_compare_secrets (NMSettingSecretFlags secret_flags, NMSettingCompareFlags comp_flags, gboolean remove_secret) { NMSetting *old, *new; gboolean success; /* Make sure that a connection with transient/unsaved secrets compares * successfully to the same connection without those secrets. */ old = nm_setting_wireless_security_new (); g_object_set (old, NM_SETTING_WIRELESS_SECURITY_KEY_MGMT, "wpa-psk", NM_SETTING_WIRELESS_SECURITY_PSK, "really cool psk", NULL); nm_setting_set_secret_flags (old, NM_SETTING_WIRELESS_SECURITY_PSK, secret_flags, NULL); /* Clear the PSK from the duplicated setting */ new = nm_setting_duplicate (old); if (remove_secret) { g_object_set (new, NM_SETTING_WIRELESS_SECURITY_PSK, NULL, NULL); success = nm_setting_compare (old, new, NM_SETTING_COMPARE_FLAG_EXACT); g_assert (success == FALSE); } success = nm_setting_compare (old, new, comp_flags); g_assert (success); } static void test_setting_compare_vpn_secrets (NMSettingSecretFlags secret_flags, NMSettingCompareFlags comp_flags, gboolean remove_secret) { NMSetting *old, *new; gboolean success; /* Make sure that a connection with transient/unsaved secrets compares * successfully to the same connection without those secrets. */ old = nm_setting_vpn_new (); nm_setting_vpn_add_secret (NM_SETTING_VPN (old), "foobarbaz", "really secret password"); nm_setting_vpn_add_secret (NM_SETTING_VPN (old), "asdfasdfasdf", "really adfasdfasdfasdf"); nm_setting_vpn_add_secret (NM_SETTING_VPN (old), "0123456778", "abcdefghijklmnpqrstuvqxyz"); nm_setting_vpn_add_secret (NM_SETTING_VPN (old), "borkbork", "yet another really secret password"); nm_setting_set_secret_flags (old, "borkbork", secret_flags, NULL); /* Clear "borkbork" from the duplicated setting */ new = nm_setting_duplicate (old); if (remove_secret) { nm_setting_vpn_remove_secret (NM_SETTING_VPN (new), "borkbork"); /* First make sure they are different */ success = nm_setting_compare (old, new, NM_SETTING_COMPARE_FLAG_EXACT); g_assert (success == FALSE); } success = nm_setting_compare (old, new, comp_flags); g_assert (success); } static void test_hwaddr_aton_ether_normal (void) { guint8 buf[100]; guint8 expected[ETH_ALEN] = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55 }; g_assert (nm_utils_hwaddr_aton ("00:11:22:33:44:55", ARPHRD_ETHER, buf) != NULL); g_assert (memcmp (buf, expected, sizeof (expected)) == 0); } static void test_hwaddr_aton_ib_normal (void) { guint8 buf[100]; const char *source = "00:11:22:33:44:55:66:77:88:99:01:12:23:34:45:56:67:78:89:90"; guint8 expected[INFINIBAND_ALEN] = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0x01, 0x12, 0x23, 0x34, 0x45, 0x56, 0x67, 0x78, 0x89, 0x90 }; g_assert (nm_utils_hwaddr_aton (source, ARPHRD_INFINIBAND, buf) != NULL); g_assert (memcmp (buf, expected, sizeof (expected)) == 0); } static void test_hwaddr_aton_no_leading_zeros (void) { guint8 buf[100]; guint8 expected[ETH_ALEN] = { 0x00, 0x1A, 0x2B, 0x03, 0x44, 0x05 }; g_assert (nm_utils_hwaddr_aton ("0:1a:2B:3:44:5", ARPHRD_ETHER, buf) != NULL); g_assert (memcmp (buf, expected, sizeof (expected)) == 0); } static void test_hwaddr_aton_malformed (void) { guint8 buf[100]; g_assert (nm_utils_hwaddr_aton ("0:1a:2B:3:a@%%", ARPHRD_ETHER, buf) == NULL); } static void test_connection_changed_cb (NMConnection *connection, gboolean *data) { *data = TRUE; } #define ASSERT_CHANGED(statement) \ { \ changed = FALSE; \ statement; \ g_assert (changed); \ } #define ASSERT_UNCHANGED(statement) \ { \ changed = FALSE; \ statement; \ g_assert (!changed); \ } static void test_connection_changed_signal (void) { NMConnection *connection; gboolean changed = FALSE; connection = new_test_connection (); g_signal_connect (connection, NM_CONNECTION_CHANGED, (GCallback) test_connection_changed_cb, &changed); /* Add new setting */ ASSERT_CHANGED (nm_connection_add_setting (connection, nm_setting_vlan_new ())); /* Remove existing setting */ ASSERT_CHANGED (nm_connection_remove_setting (connection, NM_TYPE_SETTING_VLAN)); /* Remove non-existing setting */ ASSERT_UNCHANGED (nm_connection_remove_setting (connection, NM_TYPE_SETTING_VLAN)); g_object_unref (connection); } static void test_setting_connection_changed_signal (void) { NMConnection *connection; gboolean changed = FALSE; NMSettingConnection *s_con; char *uuid; connection = nm_connection_new (); g_signal_connect (connection, NM_CONNECTION_CHANGED, (GCallback) test_connection_changed_cb, &changed); s_con = (NMSettingConnection *) nm_setting_connection_new (); nm_connection_add_setting (connection, NM_SETTING (s_con)); ASSERT_CHANGED (g_object_set (s_con, NM_SETTING_CONNECTION_ID, "adfadfasdfaf", NULL)); ASSERT_CHANGED (nm_setting_connection_add_permission (s_con, "user", "billsmith", NULL)); ASSERT_CHANGED (nm_setting_connection_remove_permission (s_con, 0)); ASSERT_UNCHANGED (nm_setting_connection_remove_permission (s_con, 1)); uuid = nm_utils_uuid_generate (); ASSERT_CHANGED (nm_setting_connection_add_secondary (s_con, uuid)); ASSERT_CHANGED (nm_setting_connection_remove_secondary (s_con, 0)); ASSERT_UNCHANGED (nm_setting_connection_remove_secondary (s_con, 1)); g_object_unref (connection); } static void test_setting_bond_changed_signal (void) { NMConnection *connection; gboolean changed = FALSE; NMSettingBond *s_bond; connection = nm_connection_new (); g_signal_connect (connection, NM_CONNECTION_CHANGED, (GCallback) test_connection_changed_cb, &changed); s_bond = (NMSettingBond *) nm_setting_bond_new (); nm_connection_add_setting (connection, NM_SETTING (s_bond)); ASSERT_CHANGED (nm_setting_bond_add_option (s_bond, NM_SETTING_BOND_OPTION_DOWNDELAY, "10")); ASSERT_CHANGED (nm_setting_bond_remove_option (s_bond, NM_SETTING_BOND_OPTION_DOWNDELAY)); ASSERT_UNCHANGED (nm_setting_bond_remove_option (s_bond, NM_SETTING_BOND_OPTION_UPDELAY)); g_object_unref (connection); } static void test_setting_ip4_changed_signal (void) { NMConnection *connection; gboolean changed = FALSE; NMSettingIP4Config *s_ip4; NMIP4Address *addr; NMIP4Route *route; connection = nm_connection_new (); g_signal_connect (connection, NM_CONNECTION_CHANGED, (GCallback) test_connection_changed_cb, &changed); s_ip4 = (NMSettingIP4Config *) nm_setting_ip4_config_new (); nm_connection_add_setting (connection, NM_SETTING (s_ip4)); ASSERT_CHANGED (nm_setting_ip4_config_add_dns (s_ip4, 0x1122)); ASSERT_CHANGED (nm_setting_ip4_config_remove_dns (s_ip4, 0)); ASSERT_UNCHANGED (nm_setting_ip4_config_remove_dns (s_ip4, 1)); nm_setting_ip4_config_add_dns (s_ip4, 0x3344); ASSERT_CHANGED (nm_setting_ip4_config_clear_dns (s_ip4)); ASSERT_CHANGED (nm_setting_ip4_config_add_dns_search (s_ip4, "foobar.com")); ASSERT_CHANGED (nm_setting_ip4_config_remove_dns_search (s_ip4, 0)); ASSERT_UNCHANGED (nm_setting_ip4_config_remove_dns_search (s_ip4, 1)); ASSERT_CHANGED (nm_setting_ip4_config_add_dns_search (s_ip4, "foobar.com")); ASSERT_CHANGED (nm_setting_ip4_config_clear_dns_searches (s_ip4)); addr = nm_ip4_address_new (); nm_ip4_address_set_address (addr, 0x2233); nm_ip4_address_set_prefix (addr, 24); ASSERT_CHANGED (nm_setting_ip4_config_add_address (s_ip4, addr)); ASSERT_CHANGED (nm_setting_ip4_config_remove_address (s_ip4, 0)); ASSERT_UNCHANGED (nm_setting_ip4_config_remove_address (s_ip4, 1)); nm_setting_ip4_config_add_address (s_ip4, addr); ASSERT_CHANGED (nm_setting_ip4_config_clear_addresses (s_ip4)); route = nm_ip4_route_new (); nm_ip4_route_set_dest (route, 0x2233); nm_ip4_route_set_prefix (route, 24); ASSERT_CHANGED (nm_setting_ip4_config_add_route (s_ip4, route)); ASSERT_CHANGED (nm_setting_ip4_config_remove_route (s_ip4, 0)); ASSERT_UNCHANGED (nm_setting_ip4_config_remove_route (s_ip4, 1)); nm_setting_ip4_config_add_route (s_ip4, route); ASSERT_CHANGED (nm_setting_ip4_config_clear_routes (s_ip4)); nm_ip4_address_unref (addr); nm_ip4_route_unref (route); g_object_unref (connection); } static void test_setting_ip6_changed_signal (void) { NMConnection *connection; gboolean changed = FALSE; NMSettingIP6Config *s_ip6; NMIP6Address *addr; NMIP6Route *route; const struct in6_addr t = { { { 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15 } } }; connection = nm_connection_new (); g_signal_connect (connection, NM_CONNECTION_CHANGED, (GCallback) test_connection_changed_cb, &changed); s_ip6 = (NMSettingIP6Config *) nm_setting_ip6_config_new (); nm_connection_add_setting (connection, NM_SETTING (s_ip6)); ASSERT_CHANGED (nm_setting_ip6_config_add_dns (s_ip6, &t)); ASSERT_CHANGED (nm_setting_ip6_config_remove_dns (s_ip6, 0)); ASSERT_UNCHANGED (nm_setting_ip6_config_remove_dns (s_ip6, 1)); nm_setting_ip6_config_add_dns (s_ip6, &t); ASSERT_CHANGED (nm_setting_ip6_config_clear_dns (s_ip6)); ASSERT_CHANGED (nm_setting_ip6_config_add_dns_search (s_ip6, "foobar.com")); ASSERT_CHANGED (nm_setting_ip6_config_remove_dns_search (s_ip6, 0)); ASSERT_UNCHANGED (nm_setting_ip6_config_remove_dns_search (s_ip6, 1)); nm_setting_ip6_config_add_dns_search (s_ip6, "foobar.com"); ASSERT_CHANGED (nm_setting_ip6_config_clear_dns_searches (s_ip6)); addr = nm_ip6_address_new (); nm_ip6_address_set_address (addr, &t); nm_ip6_address_set_prefix (addr, 64); ASSERT_CHANGED (nm_setting_ip6_config_add_address (s_ip6, addr)); ASSERT_CHANGED (nm_setting_ip6_config_remove_address (s_ip6, 0)); ASSERT_UNCHANGED (nm_setting_ip6_config_remove_address (s_ip6, 1)); nm_setting_ip6_config_add_address (s_ip6, addr); ASSERT_CHANGED (nm_setting_ip6_config_clear_addresses (s_ip6)); route = nm_ip6_route_new (); nm_ip6_route_set_dest (route, &t); nm_ip6_route_set_prefix (route, 128); ASSERT_CHANGED (nm_setting_ip6_config_add_route (s_ip6, route)); ASSERT_CHANGED (nm_setting_ip6_config_remove_route (s_ip6, 0)); ASSERT_UNCHANGED (nm_setting_ip6_config_remove_route (s_ip6, 1)); nm_setting_ip6_config_add_route (s_ip6, route); ASSERT_CHANGED (nm_setting_ip6_config_clear_routes (s_ip6)); nm_ip6_address_unref (addr); nm_ip6_route_unref (route); g_object_unref (connection); } static void test_setting_vlan_changed_signal (void) { NMConnection *connection; gboolean changed = FALSE; NMSettingVlan *s_vlan; connection = nm_connection_new (); g_signal_connect (connection, NM_CONNECTION_CHANGED, (GCallback) test_connection_changed_cb, &changed); s_vlan = (NMSettingVlan *) nm_setting_vlan_new (); nm_connection_add_setting (connection, NM_SETTING (s_vlan)); ASSERT_CHANGED (nm_setting_vlan_add_priority (s_vlan, NM_VLAN_INGRESS_MAP, 1, 3)); ASSERT_CHANGED (nm_setting_vlan_remove_priority (s_vlan, NM_VLAN_INGRESS_MAP, 0)); ASSERT_UNCHANGED (nm_setting_vlan_remove_priority (s_vlan, NM_VLAN_INGRESS_MAP, 1)); ASSERT_CHANGED (nm_setting_vlan_add_priority_str (s_vlan, NM_VLAN_INGRESS_MAP, "1:3")); ASSERT_CHANGED (nm_setting_vlan_clear_priorities (s_vlan, NM_VLAN_INGRESS_MAP)); ASSERT_CHANGED (nm_setting_vlan_add_priority (s_vlan, NM_VLAN_EGRESS_MAP, 1, 3)); ASSERT_CHANGED (nm_setting_vlan_remove_priority (s_vlan, NM_VLAN_EGRESS_MAP, 0)); ASSERT_UNCHANGED (nm_setting_vlan_remove_priority (s_vlan, NM_VLAN_EGRESS_MAP, 1)); ASSERT_CHANGED (nm_setting_vlan_add_priority_str (s_vlan, NM_VLAN_EGRESS_MAP, "1:3")); ASSERT_CHANGED (nm_setting_vlan_clear_priorities (s_vlan, NM_VLAN_EGRESS_MAP)); g_object_unref (connection); } static void test_setting_vpn_changed_signal (void) { NMConnection *connection; gboolean changed = FALSE; NMSettingVPN *s_vpn; connection = nm_connection_new (); g_signal_connect (connection, NM_CONNECTION_CHANGED, (GCallback) test_connection_changed_cb, &changed); s_vpn = (NMSettingVPN *) nm_setting_vpn_new (); nm_connection_add_setting (connection, NM_SETTING (s_vpn)); ASSERT_CHANGED (nm_setting_vpn_add_data_item (s_vpn, "foobar", "baz")); ASSERT_CHANGED (nm_setting_vpn_remove_data_item (s_vpn, "foobar")); ASSERT_UNCHANGED (nm_setting_vpn_remove_data_item (s_vpn, "not added")); ASSERT_CHANGED (nm_setting_vpn_add_secret (s_vpn, "foobar", "baz")); ASSERT_CHANGED (nm_setting_vpn_remove_secret (s_vpn, "foobar")); ASSERT_UNCHANGED (nm_setting_vpn_remove_secret (s_vpn, "not added")); g_object_unref (connection); } static void test_setting_wired_changed_signal (void) { NMConnection *connection; gboolean changed = FALSE; NMSettingWired *s_wired; connection = nm_connection_new (); g_signal_connect (connection, NM_CONNECTION_CHANGED, (GCallback) test_connection_changed_cb, &changed); s_wired = (NMSettingWired *) nm_setting_wired_new (); nm_connection_add_setting (connection, NM_SETTING (s_wired)); ASSERT_CHANGED (nm_setting_wired_add_s390_option (s_wired, "portno", "1")); ASSERT_CHANGED (nm_setting_wired_remove_s390_option (s_wired, "portno")); ASSERT_UNCHANGED (nm_setting_wired_remove_s390_option (s_wired, "layer2")); g_object_unref (connection); } static void test_setting_wireless_changed_signal (void) { NMConnection *connection; gboolean changed = FALSE; NMSettingWireless *s_wifi; connection = nm_connection_new (); g_signal_connect (connection, NM_CONNECTION_CHANGED, (GCallback) test_connection_changed_cb, &changed); s_wifi = (NMSettingWireless *) nm_setting_wireless_new (); nm_connection_add_setting (connection, NM_SETTING (s_wifi)); ASSERT_CHANGED (nm_setting_wireless_add_seen_bssid (s_wifi, "00:11:22:33:44:55")); g_object_unref (connection); } static void test_setting_wireless_security_changed_signal (void) { NMConnection *connection; gboolean changed = FALSE; NMSettingWirelessSecurity *s_wsec; connection = nm_connection_new (); g_signal_connect (connection, NM_CONNECTION_CHANGED, (GCallback) test_connection_changed_cb, &changed); s_wsec = (NMSettingWirelessSecurity *) nm_setting_wireless_security_new (); nm_connection_add_setting (connection, NM_SETTING (s_wsec)); /* Protos */ ASSERT_CHANGED (nm_setting_wireless_security_add_proto (s_wsec, "wpa")); ASSERT_CHANGED (nm_setting_wireless_security_remove_proto (s_wsec, 0)); ASSERT_UNCHANGED (nm_setting_wireless_security_remove_proto (s_wsec, 1)); nm_setting_wireless_security_add_proto (s_wsec, "wep"); ASSERT_CHANGED (nm_setting_wireless_security_clear_protos (s_wsec)); /* Pairwise ciphers */ ASSERT_CHANGED (nm_setting_wireless_security_add_pairwise (s_wsec, "tkip")); ASSERT_CHANGED (nm_setting_wireless_security_remove_pairwise (s_wsec, 0)); ASSERT_UNCHANGED (nm_setting_wireless_security_remove_pairwise (s_wsec, 1)); nm_setting_wireless_security_add_pairwise (s_wsec, "tkip"); ASSERT_CHANGED (nm_setting_wireless_security_clear_pairwise (s_wsec)); /* Group ciphers */ ASSERT_CHANGED (nm_setting_wireless_security_add_group (s_wsec, "ccmp")); ASSERT_CHANGED (nm_setting_wireless_security_remove_group (s_wsec, 0)); ASSERT_UNCHANGED (nm_setting_wireless_security_remove_group (s_wsec, 1)); nm_setting_wireless_security_add_group (s_wsec, "tkip"); ASSERT_CHANGED (nm_setting_wireless_security_clear_groups (s_wsec)); /* WEP key secret flags */ ASSERT_CHANGED (g_assert (nm_setting_set_secret_flags (NM_SETTING (s_wsec), "wep-key0", NM_SETTING_SECRET_FLAG_AGENT_OWNED, NULL))); ASSERT_CHANGED (g_assert (nm_setting_set_secret_flags (NM_SETTING (s_wsec), "wep-key1", NM_SETTING_SECRET_FLAG_AGENT_OWNED, NULL))); ASSERT_CHANGED (g_assert (nm_setting_set_secret_flags (NM_SETTING (s_wsec), "wep-key2", NM_SETTING_SECRET_FLAG_AGENT_OWNED, NULL))); ASSERT_CHANGED (g_assert (nm_setting_set_secret_flags (NM_SETTING (s_wsec), "wep-key3", NM_SETTING_SECRET_FLAG_AGENT_OWNED, NULL))); g_object_unref (connection); } static void test_setting_802_1x_changed_signal (void) { NMConnection *connection; gboolean changed = FALSE; NMSetting8021x *s_8021x; connection = nm_connection_new (); g_signal_connect (connection, NM_CONNECTION_CHANGED, (GCallback) test_connection_changed_cb, &changed); s_8021x = (NMSetting8021x *) nm_setting_802_1x_new (); nm_connection_add_setting (connection, NM_SETTING (s_8021x)); /* EAP methods */ ASSERT_CHANGED (nm_setting_802_1x_add_eap_method (s_8021x, "tls")); ASSERT_CHANGED (nm_setting_802_1x_remove_eap_method (s_8021x, 0)); ASSERT_UNCHANGED (nm_setting_802_1x_remove_eap_method (s_8021x, 1)); nm_setting_802_1x_add_eap_method (s_8021x, "ttls"); ASSERT_CHANGED (nm_setting_802_1x_clear_eap_methods (s_8021x)); /* alternate subject matches */ ASSERT_CHANGED (nm_setting_802_1x_add_altsubject_match (s_8021x, "EMAIL:server@example.com")); ASSERT_CHANGED (nm_setting_802_1x_remove_altsubject_match (s_8021x, 0)); ASSERT_UNCHANGED (nm_setting_802_1x_remove_altsubject_match (s_8021x, 1)); nm_setting_802_1x_add_altsubject_match (s_8021x, "EMAIL:server@example.com"); ASSERT_CHANGED (nm_setting_802_1x_clear_altsubject_matches (s_8021x)); /* phase2 alternate subject matches */ ASSERT_CHANGED (nm_setting_802_1x_add_phase2_altsubject_match (s_8021x, "EMAIL:server@example.com")); ASSERT_CHANGED (nm_setting_802_1x_remove_phase2_altsubject_match (s_8021x, 0)); ASSERT_UNCHANGED (nm_setting_802_1x_remove_phase2_altsubject_match (s_8021x, 1)); nm_setting_802_1x_add_phase2_altsubject_match (s_8021x, "EMAIL:server@example.com"); ASSERT_CHANGED (nm_setting_802_1x_clear_phase2_altsubject_matches (s_8021x)); g_object_unref (connection); } static void test_setting_old_uuid (void) { GError *error = NULL; NMSetting *setting; gboolean success; /* NetworkManager-0.9.4.0 generated 40-character UUIDs with no dashes, * like this one. Test that we maintain compatibility. */ const char *uuid = "f43bec2cdd60e5da381ebb1eb1fa39f3cc52660c"; setting = nm_setting_connection_new (); g_object_set (G_OBJECT (setting), NM_SETTING_CONNECTION_ID, "uuidtest", NM_SETTING_CONNECTION_UUID, uuid, NM_SETTING_CONNECTION_TYPE, NM_SETTING_WIRED_SETTING_NAME, NULL); success = nm_setting_verify (NM_SETTING (setting), NULL, &error); g_assert_no_error (error); g_assert (success == TRUE); } int main (int argc, char **argv) { GError *error = NULL; char *base; g_type_init (); if (!nm_utils_init (&error)) FAIL ("nm-utils-init", "failed to initialize libnm-util: %s", error->message); /* The tests */ test_setting_vpn_items (); test_setting_vpn_update_secrets (); test_setting_vpn_modify_during_foreach (); test_setting_ip6_config_old_address_array (); test_setting_gsm_apn_spaces (); test_setting_gsm_apn_bad_chars (); test_setting_gsm_apn_underscore (); test_setting_gsm_without_number (); test_setting_to_hash_all (); test_setting_to_hash_no_secrets (); test_setting_to_hash_only_secrets (); test_setting_compare_id (); test_setting_compare_secrets (NM_SETTING_SECRET_FLAG_AGENT_OWNED, NM_SETTING_COMPARE_FLAG_IGNORE_AGENT_OWNED_SECRETS, TRUE); test_setting_compare_secrets (NM_SETTING_SECRET_FLAG_NOT_SAVED, NM_SETTING_COMPARE_FLAG_IGNORE_NOT_SAVED_SECRETS, TRUE); test_setting_compare_secrets (NM_SETTING_SECRET_FLAG_NONE, NM_SETTING_COMPARE_FLAG_IGNORE_SECRETS, TRUE); test_setting_compare_secrets (NM_SETTING_SECRET_FLAG_NONE, NM_SETTING_COMPARE_FLAG_EXACT, FALSE); test_setting_compare_vpn_secrets (NM_SETTING_SECRET_FLAG_AGENT_OWNED, NM_SETTING_COMPARE_FLAG_IGNORE_AGENT_OWNED_SECRETS, TRUE); test_setting_compare_vpn_secrets (NM_SETTING_SECRET_FLAG_NOT_SAVED, NM_SETTING_COMPARE_FLAG_IGNORE_NOT_SAVED_SECRETS, TRUE); test_setting_compare_vpn_secrets (NM_SETTING_SECRET_FLAG_NONE, NM_SETTING_COMPARE_FLAG_IGNORE_SECRETS, TRUE); test_setting_compare_vpn_secrets (NM_SETTING_SECRET_FLAG_NONE, NM_SETTING_COMPARE_FLAG_EXACT, FALSE); test_setting_old_uuid (); test_connection_to_hash_setting_name (); test_setting_new_from_hash (); test_connection_replace_settings (); test_connection_replace_settings_from_connection (); test_connection_new_from_hash (); test_setting_connection_permissions_helpers (); test_setting_connection_permissions_property (); test_connection_compare_same (); test_connection_compare_key_only_in_a (); test_connection_compare_setting_only_in_a (); test_connection_compare_key_only_in_b (); test_connection_compare_setting_only_in_b (); test_connection_diff_a_only (); test_connection_diff_same (); test_connection_diff_different (); test_connection_diff_no_secrets (); test_connection_good_base_types (); test_connection_bad_base_types (); test_hwaddr_aton_ether_normal (); test_hwaddr_aton_ib_normal (); test_hwaddr_aton_no_leading_zeros (); test_hwaddr_aton_malformed (); test_connection_changed_signal (); test_setting_connection_changed_signal (); test_setting_bond_changed_signal (); test_setting_ip4_changed_signal (); test_setting_ip6_changed_signal (); test_setting_vlan_changed_signal (); test_setting_vpn_changed_signal (); test_setting_wired_changed_signal (); test_setting_wireless_changed_signal (); test_setting_wireless_security_changed_signal (); test_setting_802_1x_changed_signal (); base = g_path_get_basename (argv[0]); fprintf (stdout, "%s: SUCCESS\n", base); g_free (base); return 0; }