system/NetworkManager
system/NetworkManager
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/NetworkManager/NetworkManager synced 2024-07-23 03:04:18 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

libnm-core: change all mac-address properties to G_TYPE_STRING

Browse source 
Make all mac-address properties (including NMSettingBluetooth:bdaddr,
NMSettingOlpcMesh:dhcp-anycast-addr, and NMSettingWireless:bssid) be
strings, using _nm_setting_class_transform_property() to handle
translating to/from binary form when dealing with D-Bus.

Update everything accordingly for the change, and also add a test for
transformed setting properties to test-general.
This commit is contained in:
Dan Winship 2014-07-30 10:57:45 -04:00
parent f4957eb0b7
commit 3a54d05098
71 changed files with 867 additions and 1278 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

125
clients/cli/connections.c
View file

@ -2456,34 +2456,23 @@ is_setting_mandatory (NMConnection *connection, NMSetting *setting)
/*----------------------------------------------------------------------------*/
static gboolean
check_and_convert_mac (const char *mac,
GByteArray **mac_array,
int type,
const char *keyword,
GError **error)
check_mac (const char *mac,
int type,
const char *keyword,
GError **error)
{
GByteArray *local_mac_array = NULL;
g_return_val_if_fail (mac_array == NULL || *mac_array == NULL, FALSE);
g_return_val_if_fail (type == ARPHRD_ETHER || type == ARPHRD_INFINIBAND, FALSE);
if (!mac)
return TRUE;
local_mac_array = nm_utils_hwaddr_atoba (mac, nm_utils_hwaddr_len (type));
if (!local_mac_array) {
if (!nm_utils_hwaddr_valid (mac, type)) {
g_set_error (error, NMCLI_ERROR, NMC_RESULT_ERROR_USER_INPUT,
_("Error: '%s': '%s' is not a valid %s MAC address."),
keyword, mac, type == ARPHRD_INFINIBAND ? _("InfiniBand") : _("Ethernet"));
return FALSE;
}
if (mac_array)
*mac_array = local_mac_array;
else
if (local_mac_array)
g_byte_array_free (local_mac_array, TRUE);
return TRUE;
}
@ -2879,7 +2868,7 @@ do_questionnaire_ethernet (gboolean ethernet, char **mtu, char **mac, char **clo
if (!*mac) {
do {
*mac = nmc_readline (_("MAC [none]: "));
once_more = !check_and_convert_mac (*mac, NULL, ARPHRD_ETHER, "mac", &error);
once_more = !check_mac (*mac, ARPHRD_ETHER, "mac", &error);
if (once_more) {
printf ("%s\n", error->message);
g_clear_error (&error);
@ -2890,7 +2879,7 @@ do_questionnaire_ethernet (gboolean ethernet, char **mtu, char **mac, char **clo
if (!*cloned_mac) {
do {
*cloned_mac = nmc_readline (_("Cloned MAC [none]: "));
once_more = !check_and_convert_mac (*cloned_mac, NULL, ARPHRD_ETHER, "cloned-mac", &error);
once_more = !check_mac (*cloned_mac, ARPHRD_ETHER, "cloned-mac", &error);
if (once_more) {
printf ("%s\n", error->message);
g_clear_error (&error);
@ -2927,7 +2916,7 @@ do_questionnaire_infiniband (char **mtu, char **mac, char **mode, char **parent,
if (!*mac) {
do {
*mac = nmc_readline (_("MAC [none]: "));
once_more = !check_and_convert_mac (*mac, NULL, ARPHRD_INFINIBAND, "mac", &error);
once_more = !check_mac (*mac, ARPHRD_INFINIBAND, "mac", &error);
if (once_more) {
printf ("%s\n", error->message);
g_clear_error (&error);
@ -2997,7 +2986,7 @@ do_questionnaire_wimax (char **mac)
if (!*mac) {
do {
*mac = nmc_readline (_("MAC [none]: "));
once_more = !check_and_convert_mac (*mac, NULL, ARPHRD_ETHER, "mac", &error);
once_more = !check_mac (*mac, ARPHRD_ETHER, "mac", &error);
if (once_more) {
printf ("%s\n", error->message);
g_clear_error (&error);
@ -3036,7 +3025,7 @@ do_questionnaire_pppoe (char **password, char **service, char **mtu, char **mac)
if (!*mac) {
do {
*mac = nmc_readline (_("MAC [none]: "));
once_more = !check_and_convert_mac (*mac, NULL, ARPHRD_ETHER, "mac", &error);
once_more = !check_mac (*mac, ARPHRD_ETHER, "mac", &error);
if (once_more) {
printf ("%s\n", error->message);
g_clear_error (&error);
@ -3391,7 +3380,7 @@ do_questionnaire_bridge (char **stp, char **priority, char **fwd_delay, char **h
if (!*mac) {
do {
*mac = nmc_get_user_input (_("MAC [none]: "));
once_more = !check_and_convert_mac (*mac, NULL, ARPHRD_ETHER, "mac", &error);
once_more = !check_mac (*mac, ARPHRD_ETHER, "mac", &error);
if (once_more) {
printf ("%s\n", error->message);
g_clear_error (&error);
@ -3490,7 +3479,7 @@ do_questionnaire_olpc (char **channel, char **dhcp_anycast)
if (!*dhcp_anycast) {
do {
*dhcp_anycast = nmc_readline (_("DHCP anycast MAC address [none]: "));
once_more = !check_and_convert_mac (*dhcp_anycast, NULL, ARPHRD_ETHER, "dhcp-anycast", &error);
once_more = !check_mac (*dhcp_anycast, ARPHRD_ETHER, "dhcp-anycast", &error);
if (once_more) {
printf ("%s\n", error->message);
g_clear_error (&error);
@ -3635,8 +3624,6 @@ complete_connection_by_type (NMConnection *connection,
char *mac = NULL;
const char *cloned_mac_c = NULL;
char *cloned_mac = NULL;
GByteArray *array = NULL;
GByteArray *cloned_array = NULL;
nmc_arg_t exp_args[] = { {"mtu", TRUE, &mtu_c, FALSE},
{"mac", TRUE, &mac_c, FALSE},
{"cloned-mac", TRUE, &cloned_mac_c, FALSE},
@ -3654,9 +3641,9 @@ complete_connection_by_type (NMConnection *connection,
if (!check_and_convert_mtu (mtu, &mtu_int, error))
goto cleanup_wired;
if (!check_and_convert_mac (mac, &array, ARPHRD_ETHER, "mac", error))
if (!check_mac (mac, ARPHRD_ETHER, "mac", error))
goto cleanup_wired;
if (!check_and_convert_mac (cloned_mac, &cloned_array, ARPHRD_ETHER, "cloned-mac", error))
if (!check_mac (cloned_mac, ARPHRD_ETHER, "cloned-mac", error))
goto cleanup_wired;
/* Add ethernet setting */
@ -3665,20 +3652,16 @@ complete_connection_by_type (NMConnection *connection,
if (mtu)
g_object_set (s_wired, NM_SETTING_WIRED_MTU, mtu_int, NULL);
if (array)
g_object_set (s_wired, NM_SETTING_WIRED_MAC_ADDRESS, array, NULL);
if (cloned_array)
g_object_set (s_wired, NM_SETTING_WIRED_CLONED_MAC_ADDRESS, cloned_array, NULL);
if (mac)
g_object_set (s_wired, NM_SETTING_WIRED_MAC_ADDRESS, mac, NULL);
if (cloned_mac)
g_object_set (s_wired, NM_SETTING_WIRED_CLONED_MAC_ADDRESS, cloned_mac, NULL);
success = TRUE;
cleanup_wired:
g_free (mtu);
g_free (mac);
g_free (cloned_mac);
if (array)
g_byte_array_free (array, TRUE);
if (cloned_array)
g_byte_array_free (cloned_array, TRUE);
if (!success)
return FALSE;
@ -3690,7 +3673,6 @@ cleanup_wired:
guint32 mtu_int = 0;
const char *mac_c = NULL;
char *mac = NULL;
GByteArray *array = NULL;
const char *mode_c = NULL;
char *mode = NULL;
const char *parent_c = NULL;
@ -3719,7 +3701,7 @@ cleanup_wired:
if (!check_and_convert_mtu (mtu, &mtu_int, error))
goto cleanup_ib;
if (!check_and_convert_mac (mac, &array, ARPHRD_INFINIBAND, "mac", error))
if (!check_mac (mac, ARPHRD_INFINIBAND, "mac", error))
goto cleanup_ib;
if (!check_infiniband_mode (&mode, error))
goto cleanup_ib;
@ -3741,10 +3723,8 @@ cleanup_wired:
g_object_set (s_infiniband, NM_SETTING_INFINIBAND_TRANSPORT_MODE, mode ? mode : "datagram", NULL);
if (mtu)
g_object_set (s_infiniband, NM_SETTING_INFINIBAND_MTU, mtu_int, NULL);
if (array) {
g_object_set (s_infiniband, NM_SETTING_INFINIBAND_MAC_ADDRESS, array, NULL);
g_byte_array_free (array, TRUE);
}
if (mac)
g_object_set (s_infiniband, NM_SETTING_INFINIBAND_MAC_ADDRESS, mac, NULL);
if (p_key)
g_object_set (s_infiniband, NM_SETTING_INFINIBAND_P_KEY, p_key_int, NULL);
if (parent)
@ -3772,10 +3752,8 @@ cleanup_ib:
guint32 mtu_int = 0;
const char *mac_c = NULL;
char *mac = NULL;
GByteArray *mac_array = NULL;
const char *cloned_mac_c = NULL;
char *cloned_mac = NULL;
GByteArray *cloned_mac_array = NULL;
nmc_arg_t exp_args[] = { {"ssid", TRUE, &ssid, !ask},
{"mtu", TRUE, &mtu_c, FALSE},
{"mac", TRUE, &mac_c, FALSE},
@ -3802,9 +3780,9 @@ cleanup_ib:
if (!check_and_convert_mtu (mtu, &mtu_int, error))
goto cleanup_wifi;
if (!check_and_convert_mac (mac, &mac_array, ARPHRD_ETHER, "mac", error))
if (!check_mac (mac, ARPHRD_ETHER, "mac", error))
goto cleanup_wifi;
if (!check_and_convert_mac (cloned_mac, &cloned_mac_array, ARPHRD_ETHER, "cloned-mac", error))
if (!check_mac (cloned_mac, ARPHRD_ETHER, "cloned-mac", error))
goto cleanup_wifi;
/* Add wifi setting */
@ -3817,10 +3795,10 @@ cleanup_ib:
if (mtu)
g_object_set (s_wifi, NM_SETTING_WIRELESS_MTU, mtu_int, NULL);
if (mac_array)
g_object_set (s_wifi, NM_SETTING_WIRELESS_MAC_ADDRESS, mac_array, NULL);
if (cloned_mac_array)
g_object_set (s_wifi, NM_SETTING_WIRELESS_CLONED_MAC_ADDRESS, cloned_mac_array, NULL);
if (mac)
g_object_set (s_wifi, NM_SETTING_WIRELESS_MAC_ADDRESS, mac, NULL);
if (cloned_mac)
g_object_set (s_wifi, NM_SETTING_WIRELESS_CLONED_MAC_ADDRESS, cloned_mac, NULL);
success = TRUE;
cleanup_wifi:
@ -3830,10 +3808,6 @@ cleanup_wifi:
g_free (cloned_mac);
if (ssid_arr)
g_byte_array_free (ssid_arr, TRUE);
if (mac_array)
g_byte_array_free (mac_array, TRUE);
if (cloned_mac_array)
g_byte_array_free (cloned_mac_array, TRUE);
if (!success)
return FALSE;
@ -3844,7 +3818,6 @@ cleanup_wifi:
char *nsp_name_ask = NULL;
const char *mac_c = NULL;
char *mac = NULL;
GByteArray *mac_array = NULL;
nmc_arg_t exp_args[] = { {"nsp", TRUE, &nsp_name, !ask},
{"mac", TRUE, &mac_c, FALSE},
{NULL} };
@ -3865,7 +3838,7 @@ cleanup_wifi:
if (ask)
do_questionnaire_wimax (&mac);
if (!check_and_convert_mac (mac, &mac_array, ARPHRD_ETHER, "mac", error))
if (!check_mac (mac, ARPHRD_ETHER, "mac", error))
goto cleanup_wimax;
/* Add 'wimax' setting */
@ -3873,10 +3846,8 @@ cleanup_wifi:
nm_connection_add_setting (connection, NM_SETTING (s_wimax));
g_object_set (s_wimax, NM_SETTING_WIMAX_NETWORK_NAME, nsp_name, NULL);
if (mac_array) {
g_object_set (s_wimax, NM_SETTING_WIMAX_MAC_ADDRESS, mac_array, NULL);
g_byte_array_free (mac_array, TRUE);
}
if (mac)
g_object_set (s_wimax, NM_SETTING_WIMAX_MAC_ADDRESS, mac, NULL);
success = TRUE;
cleanup_wimax:
@ -3899,7 +3870,6 @@ cleanup_wimax:
guint32 mtu_int = 0;
const char *mac_c = NULL;
char *mac = NULL;
GByteArray *mac_array = NULL;
nmc_arg_t exp_args[] = { {"username", TRUE, &username, !ask},
{"password", TRUE, &password_c, FALSE},
{"service", TRUE, &service_c, FALSE},
@ -3928,7 +3898,7 @@ cleanup_wimax:
if (!check_and_convert_mtu (mtu, &mtu_int, error))
goto cleanup_pppoe;
if (!check_and_convert_mac (mac, &mac_array, ARPHRD_ETHER, "mac", error))
if (!check_mac (mac, ARPHRD_ETHER, "mac", error))
goto cleanup_pppoe;
/* Add 'pppoe' setting */
@ -3943,8 +3913,8 @@ cleanup_wimax:
nm_connection_add_setting (connection, NM_SETTING (s_wired));
if (mtu)
g_object_set (s_wired, NM_SETTING_WIRED_MTU, mtu_int, NULL);
if (mac_array)
g_object_set (s_wired, NM_SETTING_WIRED_MAC_ADDRESS, mac_array, NULL);
if (mac)
g_object_set (s_wired, NM_SETTING_WIRED_MAC_ADDRESS, mac, NULL);
success = TRUE;
cleanup_pppoe:
@ -3953,8 +3923,6 @@ cleanup_pppoe:
g_free (service);
g_free (mtu);
g_free (mac);
if (mac_array)
g_byte_array_free (mac_array, TRUE);
if (!success)
return FALSE;
@ -4038,7 +4006,6 @@ cleanup_mobile:
char *addr_ask = NULL;
const char *bt_type_c = NULL;
char *bt_type = NULL;
GByteArray *array = NULL;
nmc_arg_t exp_args[] = { {"addr", TRUE, &addr, !ask},
{"bt-type", TRUE, &bt_type_c, FALSE},
{NULL} };
@ -4053,7 +4020,7 @@ cleanup_mobile:
_("Error: 'addr' is required."));
return FALSE;
}
if (!check_and_convert_mac (addr, &array, ARPHRD_ETHER, "addr", error))
if (!check_mac (addr, ARPHRD_ETHER, "addr", error))
goto cleanup_bt;
/* Also ask for all optional arguments if '--ask' is specified. */
@ -4069,10 +4036,8 @@ cleanup_mobile:
s_bt = (NMSettingBluetooth *) nm_setting_bluetooth_new ();
nm_connection_add_setting (connection, NM_SETTING (s_bt));
if (array) {
g_object_set (s_bt, NM_SETTING_BLUETOOTH_BDADDR, array, NULL);
g_byte_array_free (array, TRUE);
}
if (addr)
g_object_set (s_bt, NM_SETTING_BLUETOOTH_BDADDR, addr, NULL);
/* 'dun' type requires adding 'gsm' or 'cdma' setting */
if ( !strcmp (bt_type, NM_SETTING_BLUETOOTH_TYPE_DUN)
@ -4517,7 +4482,6 @@ cleanup_team_slave:
max_age_int, ageing_time_int;
const char *mac_c = NULL;
char *mac = NULL;
GByteArray *mac_array = NULL;
nmc_arg_t exp_args[] = { {"stp", TRUE, &stp_c, FALSE},
{"priority", TRUE, &priority_c, FALSE},
{"forward-delay", TRUE, &fwd_delay_c, FALSE},
@ -4588,7 +4552,7 @@ cleanup_team_slave:
if (!bridge_prop_string_to_uint (ageing_time, "ageing-time", NM_TYPE_SETTING_BRIDGE,
NM_SETTING_BRIDGE_AGEING_TIME, &ageing_time_int, error))
goto cleanup_bridge;
if (!check_and_convert_mac (mac, &mac_array, ARPHRD_ETHER, "mac", error))
if (!check_mac (mac, ARPHRD_ETHER, "mac", error))
goto cleanup_bridge;
/* Set bridge options */
@ -4604,8 +4568,8 @@ cleanup_team_slave:
g_object_set (s_bridge, NM_SETTING_BRIDGE_MAX_AGE, max_age_int, NULL);
if (ageing_time)
g_object_set (s_bridge, NM_SETTING_BRIDGE_AGEING_TIME, ageing_time_int, NULL);
if (mac_array)
g_object_set (s_bridge, NM_SETTING_BRIDGE_MAC_ADDRESS, mac_array, NULL);
if (mac)
g_object_set (s_bridge, NM_SETTING_BRIDGE_MAC_ADDRESS, mac, NULL);
success = TRUE;
cleanup_bridge:
@ -4616,8 +4580,6 @@ cleanup_bridge:
g_free (max_age);
g_free (ageing_time);
g_free (mac);
if (mac_array)
g_byte_array_free (mac_array, TRUE);
if (!success)
return FALSE;
@ -4785,7 +4747,6 @@ cleanup_vpn:
unsigned long chan;
const char *dhcp_anycast_c = NULL;
char *dhcp_anycast = NULL;
GByteArray *array = NULL;
nmc_arg_t exp_args[] = { {"ssid", TRUE, &ssid, !ask},
{"channel", TRUE, &channel_c, FALSE},
{"dhcp-anycast", TRUE, &dhcp_anycast_c, FALSE},
@ -4816,7 +4777,7 @@ cleanup_vpn:
goto cleanup_olpc;
}
}
if (!check_and_convert_mac (dhcp_anycast, &array, ARPHRD_ETHER, "dhcp-anycast", error))
if (!check_mac (dhcp_anycast, ARPHRD_ETHER, "dhcp-anycast", error))
goto cleanup_olpc;
/* Add OLPC mesh setting */
@ -4830,10 +4791,8 @@ cleanup_vpn:
g_object_set (s_olpc_mesh, NM_SETTING_OLPC_MESH_CHANNEL, chan, NULL);
else
g_object_set (s_olpc_mesh, NM_SETTING_OLPC_MESH_CHANNEL, 1, NULL);
if (array) {
g_object_set (s_olpc_mesh, NM_SETTING_OLPC_MESH_DHCP_ANYCAST_ADDRESS, array, NULL);
g_byte_array_free (array, TRUE);
}
if (dhcp_anycast)
g_object_set (s_olpc_mesh, NM_SETTING_OLPC_MESH_DHCP_ANYCAST_ADDRESS, dhcp_anycast, NULL);
g_byte_array_free (ssid_arr, TRUE);
success = TRUE;

52
clients/cli/settings.c
View file

@ -810,22 +810,6 @@ vpn_data_item (const char *key, const char *value, gpointer user_data)
return secret_flags_to_string (v); \
}
#define DEFINE_HWADDR_GETTER(func_name, property_name) \
static char * \
func_name (NMSetting *setting) \
{ \
GValue val = G_VALUE_INIT; \
GArray *array; \
char *hwaddr = NULL; \
g_value_init (&val, DBUS_TYPE_G_UCHAR_ARRAY); \
g_object_get_property (G_OBJECT (setting), property_name, &val); \
array = g_value_get_boxed (&val); \
if (array && array->len) \
hwaddr = nm_utils_hwaddr_ntoa (array->data, array->len); \
g_value_unset (&val); \
return hwaddr; \
}
/* --- NM_SETTING_802_1X_SETTING_NAME property get functions --- */
DEFINE_GETTER (nmc_property_802_1X_get_eap, NM_SETTING_802_1X_EAP)
DEFINE_GETTER (nmc_property_802_1X_get_identity, NM_SETTING_802_1X_IDENTITY)
@ -966,7 +950,7 @@ DEFINE_GETTER (nmc_property_adsl_get_vpi, NM_SETTING_ADSL_VPI)
DEFINE_GETTER (nmc_property_adsl_get_vci, NM_SETTING_ADSL_VCI)
/* --- NM_SETTING_BLUETOOTH_SETTING_NAME property get functions --- */
DEFINE_HWADDR_GETTER (nmc_property_bluetooth_get_bdaddr, NM_SETTING_BLUETOOTH_BDADDR)
DEFINE_GETTER (nmc_property_bluetooth_get_bdaddr, NM_SETTING_BLUETOOTH_BDADDR)
DEFINE_GETTER (nmc_property_bluetooth_get_type, NM_SETTING_BLUETOOTH_TYPE)
static char *
@ -989,7 +973,7 @@ nmc_property_bond_get_options (NMSetting *setting)
}
/* --- NM_SETTING_BRIDGE_SETTING_NAME property get functions --- */
DEFINE_HWADDR_GETTER (nmc_property_bridge_get_mac_address, NM_SETTING_BRIDGE_MAC_ADDRESS)
DEFINE_GETTER (nmc_property_bridge_get_mac_address, NM_SETTING_BRIDGE_MAC_ADDRESS)
DEFINE_GETTER (nmc_property_bridge_get_stp, NM_SETTING_BRIDGE_STP)
DEFINE_GETTER (nmc_property_bridge_get_priority, NM_SETTING_BRIDGE_PRIORITY)
DEFINE_GETTER (nmc_property_bridge_get_forward_delay, NM_SETTING_BRIDGE_FORWARD_DELAY)
@ -1181,7 +1165,7 @@ DEFINE_SECRET_FLAGS_GETTER (nmc_property_gsm_get_pin_flags, NM_SETTING_GSM_PIN_F
DEFINE_GETTER (nmc_property_gsm_get_home_only, NM_SETTING_GSM_HOME_ONLY)
/* --- NM_SETTING_INFINIBAND_SETTING_NAME property get functions --- */
DEFINE_HWADDR_GETTER (nmc_property_ib_get_mac_address, NM_SETTING_INFINIBAND_MAC_ADDRESS)
DEFINE_GETTER (nmc_property_ib_get_mac_address, NM_SETTING_INFINIBAND_MAC_ADDRESS)
DEFINE_GETTER (nmc_property_ib_get_transport_mode, NM_SETTING_INFINIBAND_TRANSPORT_MODE)
static char *
@ -1247,7 +1231,7 @@ nmc_property_ipv6_get_ip6_privacy (NMSetting *setting)
/* --- NM_SETTING_OLPC_MESH_SETTING_NAME property get functions --- */
DEFINE_GETTER (nmc_property_olpc_get_channel, NM_SETTING_OLPC_MESH_CHANNEL)
DEFINE_HWADDR_GETTER (nmc_property_olpc_get_anycast_address, NM_SETTING_OLPC_MESH_DHCP_ANYCAST_ADDRESS)
DEFINE_GETTER (nmc_property_olpc_get_anycast_address, NM_SETTING_OLPC_MESH_DHCP_ANYCAST_ADDRESS)
static char *
nmc_property_olpc_get_ssid (NMSetting *setting)
@ -1352,15 +1336,15 @@ nmc_property_vpn_get_secrets (NMSetting *setting)
/* --- NM_SETTING_WIMAX_SETTING_NAME property get functions --- */
DEFINE_GETTER (nmc_property_wimax_get_network_name, NM_SETTING_WIMAX_NETWORK_NAME)
DEFINE_HWADDR_GETTER (nmc_property_wimax_get_mac_address, NM_SETTING_WIMAX_MAC_ADDRESS)
DEFINE_GETTER (nmc_property_wimax_get_mac_address, NM_SETTING_WIMAX_MAC_ADDRESS)
/* --- NM_SETTING_WIRED_SETTING_NAME property get functions --- */
DEFINE_GETTER (nmc_property_wired_get_port, NM_SETTING_WIRED_PORT)
DEFINE_GETTER (nmc_property_wired_get_speed, NM_SETTING_WIRED_SPEED)
DEFINE_GETTER (nmc_property_wired_get_duplex, NM_SETTING_WIRED_DUPLEX)
DEFINE_GETTER (nmc_property_wired_get_auto_negotiate, NM_SETTING_WIRED_AUTO_NEGOTIATE)
DEFINE_HWADDR_GETTER (nmc_property_wired_get_mac_address, NM_SETTING_WIRED_MAC_ADDRESS)
DEFINE_HWADDR_GETTER (nmc_property_wired_get_cloned_mac_address, NM_SETTING_WIRED_CLONED_MAC_ADDRESS)
DEFINE_GETTER (nmc_property_wired_get_mac_address, NM_SETTING_WIRED_MAC_ADDRESS)
DEFINE_GETTER (nmc_property_wired_get_cloned_mac_address, NM_SETTING_WIRED_CLONED_MAC_ADDRESS)
DEFINE_GETTER (nmc_property_wired_get_mac_address_blacklist, NM_SETTING_WIRED_MAC_ADDRESS_BLACKLIST)
DEFINE_GETTER (nmc_property_wired_get_s390_subchannels, NM_SETTING_WIRED_S390_SUBCHANNELS)
DEFINE_GETTER (nmc_property_wired_get_s390_nettype, NM_SETTING_WIRED_S390_NETTYPE)
@ -1383,11 +1367,11 @@ nmc_property_wired_get_mtu (NMSetting *setting)
DEFINE_GETTER (nmc_property_wireless_get_mode, NM_SETTING_WIRELESS_MODE)
DEFINE_GETTER (nmc_property_wireless_get_band, NM_SETTING_WIRELESS_BAND)
DEFINE_GETTER (nmc_property_wireless_get_channel, NM_SETTING_WIRELESS_CHANNEL)
DEFINE_HWADDR_GETTER (nmc_property_wireless_get_bssid, NM_SETTING_WIRELESS_BSSID)
DEFINE_GETTER (nmc_property_wireless_get_bssid, NM_SETTING_WIRELESS_BSSID)
DEFINE_GETTER (nmc_property_wireless_get_rate, NM_SETTING_WIRELESS_RATE)
DEFINE_GETTER (nmc_property_wireless_get_tx_power, NM_SETTING_WIRELESS_TX_POWER)
DEFINE_HWADDR_GETTER (nmc_property_wireless_get_mac_address, NM_SETTING_WIRELESS_MAC_ADDRESS)
DEFINE_HWADDR_GETTER (nmc_property_wireless_get_cloned_mac_address, NM_SETTING_WIRELESS_CLONED_MAC_ADDRESS)
DEFINE_GETTER (nmc_property_wireless_get_mac_address, NM_SETTING_WIRELESS_MAC_ADDRESS)
DEFINE_GETTER (nmc_property_wireless_get_cloned_mac_address, NM_SETTING_WIRELESS_CLONED_MAC_ADDRESS)
DEFINE_GETTER (nmc_property_wireless_get_mac_address_blacklist, NM_SETTING_WIRELESS_MAC_ADDRESS_BLACKLIST)
DEFINE_GETTER (nmc_property_wireless_get_seen_bssids, NM_SETTING_WIRELESS_SEEN_BSSIDS)
DEFINE_GETTER (nmc_property_wireless_get_hidden, NM_SETTING_WIRELESS_HIDDEN)
@ -2061,18 +2045,14 @@ nmc_property_set_ssid (NMSetting *setting, const char *prop, const char *val, GE
static gboolean
nmc_property_set_mac (NMSetting *setting, const char *prop, const char *val, GError **error)
{
GByteArray *array;
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
array = nm_utils_hwaddr_atoba (val, ETH_ALEN);
if (!array) {
if (!nm_utils_hwaddr_valid (val, ETH_ALEN)) {
g_set_error (error, 1, 0, _("'%s' is not a valid Ethernet MAC"), val);
return FALSE;
}
g_object_set (setting, prop, array, NULL);
g_byte_array_free (array, TRUE);
g_object_set (setting, prop, val, NULL);
return TRUE;
}
@ -2830,18 +2810,14 @@ nmc_property_bond_allowed_options (NMSetting *setting, const char *prop)
static gboolean
nmc_property_ib_set_mac (NMSetting *setting, const char *prop, const char *val, GError **error)
{
GByteArray *array;
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
array = nm_utils_hwaddr_atoba (val, INFINIBAND_ALEN);
if (!array) {
if (!nm_utils_hwaddr_valid (val, INFINIBAND_ALEN)) {
g_set_error (error, 1, 0, _("'%s' is not a valid InfiniBand MAC"), val);
return FALSE;
}
g_object_set (setting, prop, array, NULL);
g_byte_array_free (array, TRUE);
g_object_set (setting, prop, val, NULL);
return TRUE;
}

57
clients/tui/nmt-device-entry.c
View file

@ -57,7 +57,7 @@ typedef struct {
int arptype;
char *interface_name;
GByteArray *mac_address;
char *mac_address;
char *label;
NmtNewtEntry *entry;
@ -259,8 +259,8 @@ update_entry (NmtDeviceEntry *deventry)
}
if (priv->mac_address) {
mac = nm_utils_hwaddr_ntoa (priv->mac_address->data, priv->mac_address->len);
mac_device = find_device_by_mac_address (deventry, mac);
mac = g_strdup (priv->mac_address);
mac_device = find_device_by_mac_address (deventry, priv->mac_address);
} else {
mac = NULL;
mac_device = NULL;
@ -312,25 +312,21 @@ nmt_device_entry_set_interface_name (NmtDeviceEntry *deventry,
static gboolean
nmt_device_entry_set_mac_address (NmtDeviceEntry *deventry,
GByteArray *mac_address)
const char *mac_address)
{
NmtDeviceEntryPrivate *priv = NMT_DEVICE_ENTRY_GET_PRIVATE (deventry);
gboolean changed;
if (mac_address)
g_return_val_if_fail (mac_address->len == nm_utils_hwaddr_len (priv->arptype), FALSE);
if (mac_address && !priv->mac_address) {
priv->mac_address = g_boxed_copy (DBUS_TYPE_G_UCHAR_ARRAY, mac_address);
priv->mac_address = g_strdup (mac_address);
changed = TRUE;
} else if (!mac_address && priv->mac_address) {
g_clear_pointer (&priv->mac_address, g_byte_array_unref);
g_clear_pointer (&priv->mac_address, g_free);
changed = TRUE;
} else if ( mac_address && priv->mac_address
&& !nm_utils_hwaddr_matches (mac_address->data, mac_address->len,
priv->mac_address->data, priv->mac_address->len)) {
g_byte_array_unref (priv->mac_address);
priv->mac_address = g_boxed_copy (DBUS_TYPE_G_UCHAR_ARRAY, mac_address);
&& !nm_utils_hwaddr_matches (mac_address, -1, priv->mac_address, -1)) {
g_free (priv->mac_address);
priv->mac_address = g_strdup (mac_address);
changed = TRUE;
} else
changed = FALSE;
@ -356,21 +352,11 @@ entry_text_changed (GObject *object,
if (!device_entry_parse (deventry, text, &ifname, &mac))
return;
if (ifname) {
nmt_device_entry_set_interface_name (deventry, ifname);
g_free (ifname);
} else
nmt_device_entry_set_interface_name (deventry, NULL);
nmt_device_entry_set_interface_name (deventry, ifname);
g_free (ifname);
if (mac) {
GByteArray *mac_address;
mac_address = nm_utils_hwaddr_atoba (mac, nm_utils_hwaddr_len (priv->arptype));
nmt_device_entry_set_mac_address (deventry, mac_address);
g_byte_array_unref (mac_address);
g_free (mac);
} else
nmt_device_entry_set_mac_address (deventry, NULL);
nmt_device_entry_set_mac_address (deventry, mac);
g_free (mac);
}
static void
@ -410,8 +396,7 @@ nmt_device_entry_finalize (GObject *object)
NmtDeviceEntryPrivate *priv = NMT_DEVICE_ENTRY_GET_PRIVATE (object);
g_free (priv->interface_name);
if (priv->mac_address)
g_byte_array_unref (priv->mac_address);
g_free (priv->mac_address);
G_OBJECT_CLASS (nmt_device_entry_parent_class)->finalize (object);
}
@ -461,7 +446,7 @@ nmt_device_entry_set_property (GObject *object,
NmtDeviceEntry *deventry = NMT_DEVICE_ENTRY (object);
NmtDeviceEntryPrivate *priv = NMT_DEVICE_ENTRY_GET_PRIVATE (deventry);
const char *interface_name;
GByteArray *mac_address;
const char *mac_address;
switch (prop_id) {
case PROP_LABEL:
@ -480,7 +465,7 @@ nmt_device_entry_set_property (GObject *object,
update_entry (deventry);
break;
case PROP_MAC_ADDRESS:
mac_address = g_value_get_boxed (value);
mac_address = g_value_get_string (value);
if (nmt_device_entry_set_mac_address (deventry, mac_address))
update_entry (deventry);
break;
@ -512,7 +497,7 @@ nmt_device_entry_get_property (GObject *object,
g_value_set_string (value, priv->interface_name);
break;
case PROP_MAC_ADDRESS:
g_value_set_boxed (value, priv->mac_address);
g_value_set_string (value, priv->mac_address);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@ -587,8 +572,8 @@ nmt_device_entry_class_init (NmtDeviceEntryClass *deventry_class)
*/
g_object_class_install_property
(object_class, PROP_MAC_ADDRESS,
g_param_spec_boxed ("mac-address", "", "",
DBUS_TYPE_G_UCHAR_ARRAY,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS));
g_param_spec_string ("mac-address", "", "",
NULL,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS));
}

26
clients/tui/nmt-mac-entry.c
View file

@ -152,8 +152,6 @@ nmt_mac_entry_set_property (GObject *object,
GParamSpec *pspec)
{
NmtMacEntryPrivate *priv = NMT_MAC_ENTRY_GET_PRIVATE (object);
GByteArray *addr;
char *addr_str;
switch (prop_id) {
case PROP_MAC_LENGTH:
@ -161,13 +159,7 @@ nmt_mac_entry_set_property (GObject *object,
priv->mac_str_length = priv->mac_length * 3 - 1;
break;
case PROP_MAC_ADDRESS:
addr = g_value_get_boxed (value);
if (addr) {
addr_str = nm_utils_hwaddr_ntoa (addr->data, addr->len);
nmt_newt_entry_set_text (NMT_NEWT_ENTRY (object), addr_str);
g_free (addr_str);
} else
nmt_newt_entry_set_text (NMT_NEWT_ENTRY (object), "");
nmt_newt_entry_set_text (NMT_NEWT_ENTRY (object), g_value_get_string (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@ -182,15 +174,13 @@ nmt_mac_entry_get_property (GObject *object,
GParamSpec *pspec)
{
NmtMacEntryPrivate *priv = NMT_MAC_ENTRY_GET_PRIVATE (object);
GByteArray *addr;
switch (prop_id) {
case PROP_MAC_LENGTH:
g_value_set_int (value, priv->mac_length);
break;
case PROP_MAC_ADDRESS:
addr = nm_utils_hwaddr_atoba (nmt_newt_entry_get_text (NMT_NEWT_ENTRY (object)), ETH_ALEN);
g_value_take_boxed (value, addr);
g_value_set_boxed (value, nmt_newt_entry_get_text (NMT_NEWT_ENTRY (object)));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@ -225,13 +215,13 @@ nmt_mac_entry_class_init (NmtMacEntryClass *entry_class)
/**
* NmtMacEntry:mac-address:
*
* The MAC address, in binary (in the same format used by the various
* #NMSetting "mac-address" properties).
* The MAC address, as a string (as with the various #NMSetting
* "mac-address" properties).
*/
g_object_class_install_property
(object_class, PROP_MAC_ADDRESS,
g_param_spec_boxed ("mac-address", "", "",
DBUS_TYPE_G_UCHAR_ARRAY,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS));
g_param_spec_string ("mac-address", "", "",
NULL,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS));
}

32
libnm-core/nm-setting-bluetooth.c
View file

@ -29,6 +29,8 @@
#include "nm-setting-cdma.h"
#include "nm-setting-gsm.h"
#include "nm-setting-private.h"
#include "nm-utils.h"
#include "nm-utils-private.h"
/**
* SECTION:nm-setting-bluetooth
@ -65,7 +67,7 @@ NM_SETTING_REGISTER_TYPE (NM_TYPE_SETTING_BLUETOOTH)
#define NM_SETTING_BLUETOOTH_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), NM_TYPE_SETTING_BLUETOOTH, NMSettingBluetoothPrivate))
typedef struct {
GByteArray *bdaddr;
char *bdaddr;
char *type;
} NMSettingBluetoothPrivate;
@ -115,7 +117,7 @@ nm_setting_bluetooth_get_connection_type (NMSettingBluetooth *setting)
*
* Returns: the Bluetooth address
**/
const GByteArray *
const char *
nm_setting_bluetooth_get_bdaddr (NMSettingBluetooth *setting)
{
g_return_val_if_fail (NM_IS_SETTING_BLUETOOTH (setting), NULL);
@ -137,7 +139,7 @@ verify (NMSetting *setting, GSList *all_settings, GError **error)
return FALSE;
}
if (priv->bdaddr && priv->bdaddr->len != ETH_ALEN) {
if (!nm_utils_hwaddr_valid (priv->bdaddr, ETH_ALEN)) {
g_set_error_literal (error,
NM_SETTING_BLUETOOTH_ERROR,
NM_SETTING_BLUETOOTH_ERROR_INVALID_PROPERTY,
@ -199,8 +201,7 @@ finalize (GObject *object)
{
NMSettingBluetoothPrivate *priv = NM_SETTING_BLUETOOTH_GET_PRIVATE (object);
if (priv->bdaddr)
g_byte_array_free (priv->bdaddr, TRUE);
g_free (priv->bdaddr);
g_free (priv->type);
G_OBJECT_CLASS (nm_setting_bluetooth_parent_class)->finalize (object);
@ -214,9 +215,8 @@ set_property (GObject *object, guint prop_id,
switch (prop_id) {
case PROP_BDADDR:
if (priv->bdaddr)
g_byte_array_free (priv->bdaddr, TRUE);
priv->bdaddr = g_value_dup_boxed (value);
g_free (priv->bdaddr);
priv->bdaddr = g_value_dup_string (value);
break;
case PROP_TYPE:
g_free (priv->type);
@ -236,7 +236,7 @@ get_property (GObject *object, guint prop_id,
switch (prop_id) {
case PROP_BDADDR:
g_value_set_boxed (value, nm_setting_bluetooth_get_bdaddr (setting));
g_value_set_string (value, nm_setting_bluetooth_get_bdaddr (setting));
break;
case PROP_TYPE:
g_value_set_string (value, nm_setting_bluetooth_get_connection_type (setting));
@ -270,11 +270,15 @@ nm_setting_bluetooth_class_init (NMSettingBluetoothClass *setting_class)
**/
g_object_class_install_property
(object_class, PROP_BDADDR,
g_param_spec_boxed (NM_SETTING_BLUETOOTH_BDADDR, "", "",
DBUS_TYPE_G_UCHAR_ARRAY,
G_PARAM_READWRITE |
NM_SETTING_PARAM_INFERRABLE |
G_PARAM_STATIC_STRINGS));
g_param_spec_string (NM_SETTING_BLUETOOTH_BDADDR, "", "",
NULL,
G_PARAM_READWRITE |
NM_SETTING_PARAM_INFERRABLE |
G_PARAM_STATIC_STRINGS));
_nm_setting_class_transform_property (parent_class, NM_SETTING_BLUETOOTH_BDADDR,
DBUS_TYPE_G_UCHAR_ARRAY,
_nm_utils_hwaddr_to_dbus,
_nm_utils_hwaddr_from_dbus);
/**
* NMSettingBluetooth:type:

2
libnm-core/nm-setting-bluetooth.h
View file

@ -93,7 +93,7 @@ typedef struct {
GType nm_setting_bluetooth_get_type (void);
NMSetting * nm_setting_bluetooth_new (void);
const GByteArray *nm_setting_bluetooth_get_bdaddr (NMSettingBluetooth *setting);
const char * nm_setting_bluetooth_get_bdaddr (NMSettingBluetooth *setting);
const char * nm_setting_bluetooth_get_connection_type (NMSettingBluetooth *setting);
G_END_DECLS

31
libnm-core/nm-setting-bridge.c
View file

@ -29,7 +29,6 @@
#include "nm-setting-private.h"
#include "nm-utils.h"
#include "nm-utils-private.h"
#include "nm-dbus-glib-types.h"
/**
* SECTION:nm-setting-bridge
@ -64,7 +63,7 @@ NM_SETTING_REGISTER_TYPE (NM_TYPE_SETTING_BRIDGE)
#define NM_SETTING_BRIDGE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), NM_TYPE_SETTING_BRIDGE, NMSettingBridgePrivate))
typedef struct {
GByteArray *mac_address;
char * mac_address;
gboolean stp;
guint16 priority;
guint16 forward_delay;
@ -104,7 +103,7 @@ nm_setting_bridge_new (void)
*
* Returns: the #NMSettingBridge:mac-address property of the setting
**/
const GByteArray *
const char *
nm_setting_bridge_get_mac_address (NMSettingBridge *setting)
{
g_return_val_if_fail (NM_IS_SETTING_BRIDGE (setting), NULL);
@ -234,7 +233,7 @@ verify (NMSetting *setting, GSList *all_settings, GError **error)
{
NMSettingBridgePrivate *priv = NM_SETTING_BRIDGE_GET_PRIVATE (setting);
if (priv->mac_address && priv->mac_address->len != ETH_ALEN) {
if (priv->mac_address && !nm_utils_hwaddr_valid (priv->mac_address, ETH_ALEN)) {
g_set_error_literal (error,
NM_SETTING_BRIDGE_ERROR,
NM_SETTING_BRIDGE_ERROR_INVALID_PROPERTY,
@ -284,8 +283,7 @@ finalize (GObject *object)
{
NMSettingBridgePrivate *priv = NM_SETTING_BRIDGE_GET_PRIVATE (object);
if (priv->mac_address)
g_byte_array_free (priv->mac_address, TRUE);
g_free (priv->mac_address);
G_OBJECT_CLASS (nm_setting_bridge_parent_class)->finalize (object);
}
@ -298,9 +296,8 @@ set_property (GObject *object, guint prop_id,
switch (prop_id) {
case PROP_MAC_ADDRESS:
if (priv->mac_address)
g_byte_array_free (priv->mac_address, TRUE);
priv->mac_address = g_value_dup_boxed (value);
g_free (priv->mac_address);
priv->mac_address = g_value_dup_string (value);
break;
case PROP_STP:
priv->stp = g_value_get_boolean (value);
@ -335,7 +332,7 @@ get_property (GObject *object, guint prop_id,
switch (prop_id) {
case PROP_MAC_ADDRESS:
g_value_set_boxed (value, nm_setting_bridge_get_mac_address (setting));
g_value_set_string (value, nm_setting_bridge_get_mac_address (setting));
break;
case PROP_STP:
g_value_set_boolean (value, priv->stp);
@ -385,11 +382,15 @@ nm_setting_bridge_class_init (NMSettingBridgeClass *setting_class)
**/
g_object_class_install_property
(object_class, PROP_MAC_ADDRESS,
g_param_spec_boxed (NM_SETTING_BRIDGE_MAC_ADDRESS, "", "",
DBUS_TYPE_G_UCHAR_ARRAY,
G_PARAM_READWRITE |
NM_SETTING_PARAM_INFERRABLE |
G_PARAM_STATIC_STRINGS));
g_param_spec_string (NM_SETTING_BRIDGE_MAC_ADDRESS, "", "",
NULL,
G_PARAM_READWRITE |
NM_SETTING_PARAM_INFERRABLE |
G_PARAM_STATIC_STRINGS));
_nm_setting_class_transform_property (parent_class, NM_SETTING_BRIDGE_MAC_ADDRESS,
DBUS_TYPE_G_UCHAR_ARRAY,
_nm_utils_hwaddr_to_dbus,
_nm_utils_hwaddr_from_dbus);
/**
* NMSettingBridge:stp:

2
libnm-core/nm-setting-bridge.h
View file

@ -78,7 +78,7 @@ GType nm_setting_bridge_get_type (void);
NMSetting * nm_setting_bridge_new (void);
const GByteArray *nm_setting_bridge_get_mac_address (NMSettingBridge *setting);
const char * nm_setting_bridge_get_mac_address (NMSettingBridge *setting);
gboolean nm_setting_bridge_get_stp (NMSettingBridge *setting);

30
libnm-core/nm-setting-infiniband.c
View file

@ -61,7 +61,7 @@ NM_SETTING_REGISTER_TYPE (NM_TYPE_SETTING_INFINIBAND)
#define NM_SETTING_INFINIBAND_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), NM_TYPE_SETTING_INFINIBAND, NMSettingInfinibandPrivate))
typedef struct {
GByteArray *mac_address;
char *mac_address;
char *transport_mode;
guint32 mtu;
int p_key;
@ -98,7 +98,7 @@ nm_setting_infiniband_new (void)
*
* Returns: the #NMSettingInfiniband:mac-address property of the setting
**/
const GByteArray *
const char *
nm_setting_infiniband_get_mac_address (NMSettingInfiniband *setting)
{
g_return_val_if_fail (NM_IS_SETTING_INFINIBAND (setting), NULL);
@ -202,7 +202,7 @@ verify (NMSetting *setting, GSList *all_settings, GError **error)
NMSettingInfinibandPrivate *priv = NM_SETTING_INFINIBAND_GET_PRIVATE (setting);
guint32 normerr_max_mtu = 0;
if (priv->mac_address && priv->mac_address->len != INFINIBAND_ALEN) {
if (priv->mac_address && !nm_utils_hwaddr_valid (priv->mac_address, INFINIBAND_ALEN)) {
g_set_error_literal (error,
NM_SETTING_INFINIBAND_ERROR,
NM_SETTING_INFINIBAND_ERROR_INVALID_PROPERTY,
@ -320,8 +320,7 @@ finalize (GObject *object)
NMSettingInfinibandPrivate *priv = NM_SETTING_INFINIBAND_GET_PRIVATE (object);
g_free (priv->transport_mode);
if (priv->mac_address)
g_byte_array_free (priv->mac_address, TRUE);
g_free (priv->mac_address);
g_free (priv->parent);
g_free (priv->virtual_iface_name);
@ -336,9 +335,8 @@ set_property (GObject *object, guint prop_id,
switch (prop_id) {
case PROP_MAC_ADDRESS:
if (priv->mac_address)
g_byte_array_free (priv->mac_address, TRUE);
priv->mac_address = g_value_dup_boxed (value);
g_free (priv->mac_address);
priv->mac_address = g_value_dup_string (value);
break;
case PROP_MTU:
priv->mtu = g_value_get_uint (value);
@ -370,7 +368,7 @@ get_property (GObject *object, guint prop_id,
switch (prop_id) {
case PROP_MAC_ADDRESS:
g_value_set_boxed (value, nm_setting_infiniband_get_mac_address (setting));
g_value_set_string (value, nm_setting_infiniband_get_mac_address (setting));
break;
case PROP_MTU:
g_value_set_uint (value, nm_setting_infiniband_get_mtu (setting));
@ -415,11 +413,15 @@ nm_setting_infiniband_class_init (NMSettingInfinibandClass *setting_class)
**/
g_object_class_install_property
(object_class, PROP_MAC_ADDRESS,
g_param_spec_boxed (NM_SETTING_INFINIBAND_MAC_ADDRESS, "", "",
DBUS_TYPE_G_UCHAR_ARRAY,
G_PARAM_READWRITE |
NM_SETTING_PARAM_INFERRABLE |
G_PARAM_STATIC_STRINGS));
g_param_spec_string (NM_SETTING_INFINIBAND_MAC_ADDRESS, "", "",
NULL,
G_PARAM_READWRITE |
NM_SETTING_PARAM_INFERRABLE |
G_PARAM_STATIC_STRINGS));
_nm_setting_class_transform_property (parent_class, NM_SETTING_INFINIBAND_MAC_ADDRESS,
DBUS_TYPE_G_UCHAR_ARRAY,
_nm_utils_hwaddr_to_dbus,
_nm_utils_hwaddr_from_dbus);
/**
* NMSettingInfiniband:mtu:

2
libnm-core/nm-setting-infiniband.h
View file

@ -75,7 +75,7 @@ typedef struct {
GType nm_setting_infiniband_get_type (void);
NMSetting * nm_setting_infiniband_new (void);
const GByteArray *nm_setting_infiniband_get_mac_address (NMSettingInfiniband *setting);
const char * nm_setting_infiniband_get_mac_address (NMSettingInfiniband *setting);
guint32 nm_setting_infiniband_get_mtu (NMSettingInfiniband *setting);
const char * nm_setting_infiniband_get_transport_mode (NMSettingInfiniband *setting);
int nm_setting_infiniband_get_p_key (NMSettingInfiniband *setting);

28
libnm-core/nm-setting-olpc-mesh.c
View file

@ -52,7 +52,7 @@ NM_SETTING_REGISTER_TYPE (NM_TYPE_SETTING_OLPC_MESH)
typedef struct {
GByteArray *ssid;
guint32 channel;
GByteArray *dhcp_anycast_addr;
char *dhcp_anycast_addr;
} NMSettingOlpcMeshPrivate;
enum {
@ -97,7 +97,7 @@ nm_setting_olpc_mesh_get_channel (NMSettingOlpcMesh *setting)
return NM_SETTING_OLPC_MESH_GET_PRIVATE (setting)->channel;
}
const GByteArray *
const char *
nm_setting_olpc_mesh_get_dhcp_anycast_address (NMSettingOlpcMesh *setting)
{
g_return_val_if_fail (NM_IS_SETTING_OLPC_MESH (setting), NULL);
@ -138,7 +138,7 @@ verify (NMSetting *setting, GSList *all_settings, GError **error)
return FALSE;
}
if (priv->dhcp_anycast_addr && priv->dhcp_anycast_addr->len != ETH_ALEN) {
if (priv->dhcp_anycast_addr && !nm_utils_hwaddr_valid (priv->dhcp_anycast_addr, ETH_ALEN)) {
g_set_error_literal (error,
NM_SETTING_OLPC_MESH_ERROR,
NM_SETTING_OLPC_MESH_ERROR_INVALID_PROPERTY,
@ -157,8 +157,7 @@ finalize (GObject *object)
if (priv->ssid)
g_byte_array_free (priv->ssid, TRUE);
if (priv->dhcp_anycast_addr)
g_byte_array_free (priv->dhcp_anycast_addr, TRUE);
g_free (priv->dhcp_anycast_addr);
G_OBJECT_CLASS (nm_setting_olpc_mesh_parent_class)->finalize (object);
}
@ -179,9 +178,8 @@ set_property (GObject *object, guint prop_id,
priv->channel = g_value_get_uint (value);
break;
case PROP_DHCP_ANYCAST_ADDRESS:
if (priv->dhcp_anycast_addr)
g_byte_array_free (priv->dhcp_anycast_addr, TRUE);
priv->dhcp_anycast_addr = g_value_dup_boxed (value);
g_free (priv->dhcp_anycast_addr);
priv->dhcp_anycast_addr = g_value_dup_string (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@ -203,7 +201,7 @@ get_property (GObject *object, guint prop_id,
g_value_set_uint (value, nm_setting_olpc_mesh_get_channel (setting));
break;
case PROP_DHCP_ANYCAST_ADDRESS:
g_value_set_boxed (value, nm_setting_olpc_mesh_get_dhcp_anycast_address (setting));
g_value_set_string (value, nm_setting_olpc_mesh_get_dhcp_anycast_address (setting));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@ -262,8 +260,12 @@ nm_setting_olpc_mesh_class_init (NMSettingOlpcMeshClass *setting_class)
**/
g_object_class_install_property
(object_class, PROP_DHCP_ANYCAST_ADDRESS,
g_param_spec_boxed (NM_SETTING_OLPC_MESH_DHCP_ANYCAST_ADDRESS, "", "",
DBUS_TYPE_G_UCHAR_ARRAY,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS));
g_param_spec_string (NM_SETTING_OLPC_MESH_DHCP_ANYCAST_ADDRESS, "", "",
NULL,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS));
_nm_setting_class_transform_property (parent_class, NM_SETTING_OLPC_MESH_DHCP_ANYCAST_ADDRESS,
DBUS_TYPE_G_UCHAR_ARRAY,
_nm_utils_hwaddr_to_dbus,
_nm_utils_hwaddr_from_dbus);
}

2
libnm-core/nm-setting-olpc-mesh.h
View file

@ -76,7 +76,7 @@ GType nm_setting_olpc_mesh_get_type (void);
NMSetting * nm_setting_olpc_mesh_new (void);
const GByteArray *nm_setting_olpc_mesh_get_ssid (NMSettingOlpcMesh *setting);
guint32 nm_setting_olpc_mesh_get_channel (NMSettingOlpcMesh *setting);
const GByteArray *nm_setting_olpc_mesh_get_dhcp_anycast_address (NMSettingOlpcMesh *setting);
const char * nm_setting_olpc_mesh_get_dhcp_anycast_address (NMSettingOlpcMesh *setting);
G_END_DECLS

30
libnm-core/nm-setting-wimax.c
View file

@ -27,6 +27,8 @@
#include "nm-setting-wimax.h"
#include "nm-setting-private.h"
#include "nm-utils.h"
#include "nm-utils-private.h"
/**
* SECTION:nm-setting-wimax
@ -62,7 +64,7 @@ NM_SETTING_REGISTER_TYPE (NM_TYPE_SETTING_WIMAX)
typedef struct {
char *network_name;
GByteArray *mac_address;
char *mac_address;
} NMSettingWimaxPrivate;
enum {
@ -112,7 +114,7 @@ nm_setting_wimax_get_network_name (NMSettingWimax *setting)
*
* Returns: the MAC address
**/
const GByteArray *
const char *
nm_setting_wimax_get_mac_address (NMSettingWimax *setting)
{
g_return_val_if_fail (NM_IS_SETTING_WIMAX (setting), NULL);
@ -143,7 +145,7 @@ verify (NMSetting *setting, GSList *all_settings, GError **error)
return FALSE;
}
if (priv->mac_address && priv->mac_address->len != ETH_ALEN) {
if (priv->mac_address && !nm_utils_hwaddr_valid (priv->mac_address, ETH_ALEN)) {
g_set_error_literal (error,
NM_SETTING_WIMAX_ERROR,
NM_SETTING_WIMAX_ERROR_INVALID_PROPERTY,
@ -166,8 +168,7 @@ finalize (GObject *object)
NMSettingWimaxPrivate *priv = NM_SETTING_WIMAX_GET_PRIVATE (object);
g_free (priv->network_name);
if (priv->mac_address)
g_byte_array_free (priv->mac_address, TRUE);
g_free (priv->mac_address);
G_OBJECT_CLASS (nm_setting_wimax_parent_class)->finalize (object);
}
@ -184,9 +185,8 @@ set_property (GObject *object, guint prop_id,
priv->network_name = g_value_dup_string (value);
break;
case PROP_MAC_ADDRESS:
if (priv->mac_address)
g_byte_array_free (priv->mac_address, TRUE);
priv->mac_address = g_value_dup_boxed (value);
g_free (priv->mac_address);
priv->mac_address = g_value_dup_string (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@ -205,7 +205,7 @@ get_property (GObject *object, guint prop_id,
g_value_set_string (value, nm_setting_wimax_get_network_name (setting));
break;
case PROP_MAC_ADDRESS:
g_value_set_boxed (value, nm_setting_wimax_get_mac_address (setting));
g_value_set_string (value, nm_setting_wimax_get_mac_address (setting));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@ -250,8 +250,12 @@ nm_setting_wimax_class_init (NMSettingWimaxClass *setting_class)
**/
g_object_class_install_property
(object_class, PROP_MAC_ADDRESS,
g_param_spec_boxed (NM_SETTING_WIMAX_MAC_ADDRESS, "", "",
DBUS_TYPE_G_UCHAR_ARRAY,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS));
g_param_spec_string (NM_SETTING_WIMAX_MAC_ADDRESS, "", "",
NULL,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS));
_nm_setting_class_transform_property (parent_class, NM_SETTING_WIMAX_MAC_ADDRESS,
DBUS_TYPE_G_UCHAR_ARRAY,
_nm_utils_hwaddr_to_dbus,
_nm_utils_hwaddr_from_dbus);
}

2
libnm-core/nm-setting-wimax.h
View file

@ -73,7 +73,7 @@ GType nm_setting_wimax_get_type (void);
NMSetting *nm_setting_wimax_new (void);
const char *nm_setting_wimax_get_network_name (NMSettingWimax *setting);
const GByteArray *nm_setting_wimax_get_mac_address (NMSettingWimax *setting);
const char *nm_setting_wimax_get_mac_address (NMSettingWimax *setting);
G_END_DECLS

66
libnm-core/nm-setting-wired.c
View file

@ -68,8 +68,8 @@ typedef struct {
guint32 speed;
char *duplex;
gboolean auto_negotiate;
GByteArray *device_mac_address;
GByteArray *cloned_mac_address;
char *device_mac_address;
char *cloned_mac_address;
GSList *mac_address_blacklist;
guint32 mtu;
GPtrArray *s390_subchannels;
@ -179,7 +179,7 @@ nm_setting_wired_get_auto_negotiate (NMSettingWired *setting)
*
* Returns: the #NMSettingWired:mac-address property of the setting
**/
const GByteArray *
const char *
nm_setting_wired_get_mac_address (NMSettingWired *setting)
{
g_return_val_if_fail (NM_IS_SETTING_WIRED (setting), NULL);
@ -193,7 +193,7 @@ nm_setting_wired_get_mac_address (NMSettingWired *setting)
*
* Returns: the #NMSettingWired:cloned-mac-address property of the setting
**/
const GByteArray *
const char *
nm_setting_wired_get_cloned_mac_address (NMSettingWired *setting)
{
g_return_val_if_fail (NM_IS_SETTING_WIRED (setting), NULL);
@ -205,7 +205,7 @@ nm_setting_wired_get_cloned_mac_address (NMSettingWired *setting)
* nm_setting_wired_get_mac_address_blacklist:
* @setting: the #NMSettingWired
*
* Returns: (element-type GLib.ByteArray): the #NMSettingWired:mac-address-blacklist
* Returns: (element-type utf8): the #NMSettingWired:mac-address-blacklist
* property of the setting
**/
const GSList *
@ -606,7 +606,7 @@ verify (NMSetting *setting, GSList *all_settings, GError **error)
return FALSE;
}
if (priv->device_mac_address && priv->device_mac_address->len != ETH_ALEN) {
if (priv->device_mac_address && !nm_utils_hwaddr_valid (priv->device_mac_address, ETH_ALEN)) {
g_set_error_literal (error,
NM_SETTING_WIRED_ERROR,
NM_SETTING_WIRED_ERROR_INVALID_PROPERTY,
@ -662,7 +662,7 @@ verify (NMSetting *setting, GSList *all_settings, GError **error)
}
}
if (priv->cloned_mac_address && priv->cloned_mac_address->len != ETH_ALEN) {
if (priv->cloned_mac_address && !nm_utils_hwaddr_valid (priv->cloned_mac_address, ETH_ALEN)) {
g_set_error_literal (error,
NM_SETTING_WIRED_ERROR,
NM_SETTING_WIRED_ERROR_INVALID_PROPERTY,
@ -693,12 +693,8 @@ finalize (GObject *object)
g_hash_table_destroy (priv->s390_options);
if (priv->device_mac_address)
g_byte_array_free (priv->device_mac_address, TRUE);
if (priv->cloned_mac_address)
g_byte_array_free (priv->cloned_mac_address, TRUE);
g_free (priv->device_mac_address);
g_free (priv->cloned_mac_address);
g_slist_free_full (priv->mac_address_blacklist, g_free);
if (priv->s390_subchannels) {
@ -738,14 +734,12 @@ set_property (GObject *object, guint prop_id,
priv->auto_negotiate = g_value_get_boolean (value);
break;
case PROP_MAC_ADDRESS:
if (priv->device_mac_address)
g_byte_array_free (priv->device_mac_address, TRUE);
priv->device_mac_address = g_value_dup_boxed (value);
g_free (priv->device_mac_address);
priv->device_mac_address = g_value_dup_string (value);
break;
case PROP_CLONED_MAC_ADDRESS:
if (priv->cloned_mac_address)
g_byte_array_free (priv->cloned_mac_address, TRUE);
priv->cloned_mac_address = g_value_dup_boxed (value);
g_free (priv->cloned_mac_address);
priv->cloned_mac_address = g_value_dup_string (value);
break;
case PROP_MAC_ADDRESS_BLACKLIST:
g_slist_free_full (priv->mac_address_blacklist, g_free);
@ -799,10 +793,10 @@ get_property (GObject *object, guint prop_id,
g_value_set_boolean (value, nm_setting_wired_get_auto_negotiate (setting));
break;
case PROP_MAC_ADDRESS:
g_value_set_boxed (value, nm_setting_wired_get_mac_address (setting));
g_value_set_string (value, nm_setting_wired_get_mac_address (setting));
break;
case PROP_CLONED_MAC_ADDRESS:
g_value_set_boxed (value, nm_setting_wired_get_cloned_mac_address (setting));
g_value_set_string (value, nm_setting_wired_get_cloned_mac_address (setting));
break;
case PROP_MAC_ADDRESS_BLACKLIST:
g_value_set_boxed (value, nm_setting_wired_get_mac_address_blacklist (setting));
@ -906,11 +900,15 @@ nm_setting_wired_class_init (NMSettingWiredClass *setting_class)
**/
g_object_class_install_property
(object_class, PROP_MAC_ADDRESS,
g_param_spec_boxed (NM_SETTING_WIRED_MAC_ADDRESS, "", "",
DBUS_TYPE_G_UCHAR_ARRAY,
G_PARAM_READWRITE |
NM_SETTING_PARAM_INFERRABLE |
G_PARAM_STATIC_STRINGS));
g_param_spec_string (NM_SETTING_WIRED_MAC_ADDRESS, "", "",
NULL,
G_PARAM_READWRITE |
NM_SETTING_PARAM_INFERRABLE |
G_PARAM_STATIC_STRINGS));
_nm_setting_class_transform_property (parent_class, NM_SETTING_WIRED_MAC_ADDRESS,
DBUS_TYPE_G_UCHAR_ARRAY,
_nm_utils_hwaddr_to_dbus,
_nm_utils_hwaddr_from_dbus);
/**
* NMSettingWired:cloned-mac-address:
@ -920,12 +918,16 @@ nm_setting_wired_class_init (NMSettingWiredClass *setting_class)
**/
g_object_class_install_property
(object_class, PROP_CLONED_MAC_ADDRESS,
g_param_spec_boxed (NM_SETTING_WIRED_CLONED_MAC_ADDRESS, "", "",
DBUS_TYPE_G_UCHAR_ARRAY,
G_PARAM_READWRITE |
NM_SETTING_PARAM_INFERRABLE |
G_PARAM_STATIC_STRINGS));
g_param_spec_string (NM_SETTING_WIRED_CLONED_MAC_ADDRESS, "", "",
NULL,
G_PARAM_READWRITE |
NM_SETTING_PARAM_INFERRABLE |
G_PARAM_STATIC_STRINGS));
_nm_setting_class_transform_property (parent_class, NM_SETTING_WIRED_CLONED_MAC_ADDRESS,
DBUS_TYPE_G_UCHAR_ARRAY,
_nm_utils_hwaddr_to_dbus,
_nm_utils_hwaddr_from_dbus);
/**
* NMSettingWired:mac-address-blacklist:
*

4
libnm-core/nm-setting-wired.h
View file

@ -86,8 +86,8 @@ const char * nm_setting_wired_get_port (NMSettingWired *setting
guint32 nm_setting_wired_get_speed (NMSettingWired *setting);
const char * nm_setting_wired_get_duplex (NMSettingWired *setting);
gboolean nm_setting_wired_get_auto_negotiate (NMSettingWired *setting);
const GByteArray *nm_setting_wired_get_mac_address (NMSettingWired *setting);
const GByteArray *nm_setting_wired_get_cloned_mac_address (NMSettingWired *setting);
const char * nm_setting_wired_get_mac_address (NMSettingWired *setting);
const char * nm_setting_wired_get_cloned_mac_address (NMSettingWired *setting);
const GSList *nm_setting_wired_get_mac_address_blacklist (NMSettingWired *setting);
guint32 nm_setting_wired_get_num_mac_blacklist_items (NMSettingWired *setting);

86
libnm-core/nm-setting-wireless.c
View file

@ -69,11 +69,11 @@ typedef struct {
char *mode;
char *band;
guint32 channel;
GByteArray *bssid;
char *bssid;
guint32 rate;
guint32 tx_power;
GByteArray *device_mac_address;
GByteArray *cloned_mac_address;
char *device_mac_address;
char *cloned_mac_address;
GSList *mac_address_blacklist;
guint32 mtu;
GSList *seen_bssids;
@ -371,7 +371,7 @@ nm_setting_wireless_get_channel (NMSettingWireless *setting)
*
* Returns: the #NMSettingWireless:bssid property of the setting
**/
const GByteArray *
const char *
nm_setting_wireless_get_bssid (NMSettingWireless *setting)
{
g_return_val_if_fail (NM_IS_SETTING_WIRELESS (setting), NULL);
@ -413,7 +413,7 @@ nm_setting_wireless_get_tx_power (NMSettingWireless *setting)
*
* Returns: the #NMSettingWireless:mac-address property of the setting
**/
const GByteArray *
const char *
nm_setting_wireless_get_mac_address (NMSettingWireless *setting)
{
g_return_val_if_fail (NM_IS_SETTING_WIRELESS (setting), NULL);
@ -427,7 +427,7 @@ nm_setting_wireless_get_mac_address (NMSettingWireless *setting)
*
* Returns: the #NMSettingWireless:cloned-mac-address property of the setting
**/
const GByteArray *
const char *
nm_setting_wireless_get_cloned_mac_address (NMSettingWireless *setting)
{
g_return_val_if_fail (NM_IS_SETTING_WIRELESS (setting), NULL);
@ -439,7 +439,7 @@ nm_setting_wireless_get_cloned_mac_address (NMSettingWireless *setting)
* nm_setting_wireless_get_mac_address_blacklist:
* @setting: the #NMSettingWireless
*
* Returns: (element-type GLib.ByteArray): the
* Returns: (element-type utf8): the
* #NMSettingWireless:mac-address-blacklist property of the setting
**/
const GSList *
@ -764,7 +764,7 @@ verify (NMSetting *setting, GSList *all_settings, GError **error)
}
}
if (priv->bssid && priv->bssid->len != ETH_ALEN) {
if (priv->bssid && !nm_utils_hwaddr_valid (priv->bssid, ETH_ALEN)) {
g_set_error_literal (error,
NM_SETTING_WIRELESS_ERROR,
NM_SETTING_WIRELESS_ERROR_INVALID_PROPERTY,
@ -773,7 +773,7 @@ verify (NMSetting *setting, GSList *all_settings, GError **error)
return FALSE;
}
if (priv->device_mac_address && priv->device_mac_address->len != ETH_ALEN) {
if (priv->device_mac_address && !nm_utils_hwaddr_valid (priv->device_mac_address, ETH_ALEN)) {
g_set_error_literal (error,
NM_SETTING_WIRELESS_ERROR,
NM_SETTING_WIRELESS_ERROR_INVALID_PROPERTY,
@ -782,7 +782,7 @@ verify (NMSetting *setting, GSList *all_settings, GError **error)
return FALSE;
}
if (priv->cloned_mac_address && priv->cloned_mac_address->len != ETH_ALEN) {
if (priv->cloned_mac_address && !nm_utils_hwaddr_valid (priv->cloned_mac_address, ETH_ALEN)) {
g_set_error_literal (error,
NM_SETTING_WIRELESS_ERROR,
NM_SETTING_WIRELESS_ERROR_INVALID_PROPERTY,
@ -846,12 +846,9 @@ finalize (GObject *object)
if (priv->ssid)
g_byte_array_free (priv->ssid, TRUE);
if (priv->bssid)
g_byte_array_free (priv->bssid, TRUE);
if (priv->device_mac_address)
g_byte_array_free (priv->device_mac_address, TRUE);
if (priv->cloned_mac_address)
g_byte_array_free (priv->cloned_mac_address, TRUE);
g_free (priv->bssid);
g_free (priv->device_mac_address);
g_free (priv->cloned_mac_address);
g_slist_free_full (priv->mac_address_blacklist, g_free);
g_slist_free_full (priv->seen_bssids, g_free);
@ -882,9 +879,8 @@ set_property (GObject *object, guint prop_id,
priv->channel = g_value_get_uint (value);
break;
case PROP_BSSID:
if (priv->bssid)
g_byte_array_free (priv->bssid, TRUE);
priv->bssid = g_value_dup_boxed (value);
g_free (priv->bssid);
priv->bssid = g_value_dup_string (value);
break;
case PROP_RATE:
priv->rate = g_value_get_uint (value);
@ -893,14 +889,12 @@ set_property (GObject *object, guint prop_id,
priv->tx_power = g_value_get_uint (value);
break;
case PROP_MAC_ADDRESS:
if (priv->device_mac_address)
g_byte_array_free (priv->device_mac_address, TRUE);
priv->device_mac_address = g_value_dup_boxed (value);
g_free (priv->device_mac_address);
priv->device_mac_address = g_value_dup_string (value);
break;
case PROP_CLONED_MAC_ADDRESS:
if (priv->cloned_mac_address)
g_byte_array_free (priv->cloned_mac_address, TRUE);
priv->cloned_mac_address = g_value_dup_boxed (value);
g_free (priv->cloned_mac_address);
priv->cloned_mac_address = g_value_dup_string (value);
break;
case PROP_MAC_ADDRESS_BLACKLIST:
g_slist_free_full (priv->mac_address_blacklist, g_free);
@ -942,7 +936,7 @@ get_property (GObject *object, guint prop_id,
g_value_set_uint (value, nm_setting_wireless_get_channel (setting));
break;
case PROP_BSSID:
g_value_set_boxed (value, nm_setting_wireless_get_bssid (setting));
g_value_set_string (value, nm_setting_wireless_get_bssid (setting));
break;
case PROP_RATE:
g_value_set_uint (value, nm_setting_wireless_get_rate (setting));
@ -951,10 +945,10 @@ get_property (GObject *object, guint prop_id,
g_value_set_uint (value, nm_setting_wireless_get_tx_power (setting));
break;
case PROP_MAC_ADDRESS:
g_value_set_boxed (value, nm_setting_wireless_get_mac_address (setting));
g_value_set_string (value, nm_setting_wireless_get_mac_address (setting));
break;
case PROP_CLONED_MAC_ADDRESS:
g_value_set_boxed (value, nm_setting_wireless_get_cloned_mac_address (setting));
g_value_set_string (value, nm_setting_wireless_get_cloned_mac_address (setting));
break;
case PROP_MAC_ADDRESS_BLACKLIST:
g_value_set_boxed (value, nm_setting_wireless_get_mac_address_blacklist (setting));
@ -1057,10 +1051,14 @@ nm_setting_wireless_class_init (NMSettingWirelessClass *setting_class)
**/
g_object_class_install_property
(object_class, PROP_BSSID,
g_param_spec_boxed (NM_SETTING_WIRELESS_BSSID, "", "",
DBUS_TYPE_G_UCHAR_ARRAY,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS));
g_param_spec_string (NM_SETTING_WIRELESS_BSSID, "", "",
NULL,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS));
_nm_setting_class_transform_property (parent_class, NM_SETTING_WIRELESS_BSSID,
DBUS_TYPE_G_UCHAR_ARRAY,
_nm_utils_hwaddr_to_dbus,
_nm_utils_hwaddr_from_dbus);
/**
* NMSettingWireless:rate:
@ -1104,10 +1102,14 @@ nm_setting_wireless_class_init (NMSettingWirelessClass *setting_class)
**/
g_object_class_install_property
(object_class, PROP_MAC_ADDRESS,
g_param_spec_boxed (NM_SETTING_WIRELESS_MAC_ADDRESS, "", "",
DBUS_TYPE_G_UCHAR_ARRAY,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS));
g_param_spec_string (NM_SETTING_WIRELESS_MAC_ADDRESS, "", "",
NULL,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS));
_nm_setting_class_transform_property (parent_class, NM_SETTING_WIRELESS_MAC_ADDRESS,
DBUS_TYPE_G_UCHAR_ARRAY,
_nm_utils_hwaddr_to_dbus,
_nm_utils_hwaddr_from_dbus);
/**
* NMSettingWireless:cloned-mac-address:
@ -1117,10 +1119,14 @@ nm_setting_wireless_class_init (NMSettingWirelessClass *setting_class)
**/
g_object_class_install_property
(object_class, PROP_CLONED_MAC_ADDRESS,
g_param_spec_boxed (NM_SETTING_WIRELESS_CLONED_MAC_ADDRESS, "", "",
DBUS_TYPE_G_UCHAR_ARRAY,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS));
g_param_spec_string (NM_SETTING_WIRELESS_CLONED_MAC_ADDRESS, "", "",
NULL,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS));
_nm_setting_class_transform_property (parent_class, NM_SETTING_WIRELESS_CLONED_MAC_ADDRESS,
DBUS_TYPE_G_UCHAR_ARRAY,
_nm_utils_hwaddr_to_dbus,
_nm_utils_hwaddr_from_dbus);
/**
* NMSettingWireless:mac-address-blacklist:

6
libnm-core/nm-setting-wireless.h
View file

@ -120,11 +120,11 @@ const GByteArray *nm_setting_wireless_get_ssid (NMSettingWireless
const char *nm_setting_wireless_get_mode (NMSettingWireless *setting);
const char *nm_setting_wireless_get_band (NMSettingWireless *setting);
guint32 nm_setting_wireless_get_channel (NMSettingWireless *setting);
const GByteArray *nm_setting_wireless_get_bssid (NMSettingWireless *setting);
const char *nm_setting_wireless_get_bssid (NMSettingWireless *setting);
guint32 nm_setting_wireless_get_rate (NMSettingWireless *setting);
guint32 nm_setting_wireless_get_tx_power (NMSettingWireless *setting);
const GByteArray *nm_setting_wireless_get_mac_address (NMSettingWireless *setting);
const GByteArray *nm_setting_wireless_get_cloned_mac_address (NMSettingWireless *setting);
const char *nm_setting_wireless_get_mac_address (NMSettingWireless *setting);
const char *nm_setting_wireless_get_cloned_mac_address (NMSettingWireless *setting);
const GSList *nm_setting_wireless_get_mac_address_blacklist (NMSettingWireless *setting);
guint32 nm_setting_wireless_get_num_mac_blacklist_items (NMSettingWireless *setting);

5
libnm-core/nm-utils-private.h
View file

@ -34,4 +34,9 @@ gboolean _nm_utils_gvalue_array_validate (GValueArray *elements,
void _nm_value_transforms_register (void);
void _nm_utils_hwaddr_to_dbus (const GValue *prop_value,
GValue *dbus_value);
void _nm_utils_hwaddr_from_dbus (const GValue *dbus_value,
GValue *prop_value);
#endif

22
libnm-core/nm-utils.c
View file

@ -2230,6 +2230,28 @@ nm_utils_hwaddr_matches (gconstpointer hwaddr1,
return !memcmp (hwaddr1, hwaddr2, hwaddr1_len);
}
void
_nm_utils_hwaddr_to_dbus (const GValue *prop_value,
GValue *dbus_value)
{
const char *str = g_value_get_string (prop_value);
GByteArray *array;
array = str ? nm_utils_hwaddr_atoba (str, hwaddr_binary_len (str)) : NULL;
g_value_take_boxed (dbus_value, array);
}
void
_nm_utils_hwaddr_from_dbus (const GValue *dbus_value,
GValue *prop_value)
{
GByteArray *array = g_value_get_boxed (dbus_value);
char *str;
str = array ? nm_utils_hwaddr_ntoa (array->data, array->len) : NULL;
g_value_take_string (prop_value, str);
}
/**
* nm_utils_bin2hexstr:
* @bytes: an array of bytes

80
libnm-core/tests/test-general.c
View file

@ -748,6 +748,42 @@ test_setting_to_dbus_only_secrets (void)
g_object_unref (s_wsec);
}
static void
test_setting_to_dbus_transform (void)
{
NMSetting *s_wired;
GHashTable *hash;
GValue *val;
const char *test_mac_address = "11:22:33:44:55:66";
GByteArray *dbus_mac_address;
GByteArray *cmp_mac_address;
s_wired = nm_setting_wired_new ();
g_object_set (s_wired,
NM_SETTING_WIRED_MAC_ADDRESS, test_mac_address,
NULL);
g_assert_cmpstr (nm_setting_wired_get_mac_address (NM_SETTING_WIRED (s_wired)), ==, test_mac_address);
hash = _nm_setting_to_dbus (s_wired, NULL, NM_CONNECTION_SERIALIZE_ALL);
g_assert (hash != NULL);
val = g_hash_table_lookup (hash, NM_SETTING_WIRED_MAC_ADDRESS);
g_assert (val != NULL);
g_assert (G_VALUE_HOLDS (val, DBUS_TYPE_G_UCHAR_ARRAY));
dbus_mac_address = g_value_get_boxed (val);
cmp_mac_address = nm_utils_hwaddr_atoba (test_mac_address, ETH_ALEN);
g_assert_cmpint (dbus_mac_address->len, ==, cmp_mac_address->len);
g_assert (memcmp (dbus_mac_address->data, cmp_mac_address->data, ETH_ALEN) == 0);
g_byte_array_unref (cmp_mac_address);
g_hash_table_unref (hash);
g_object_unref (s_wired);
}
static void
test_connection_to_dbus_setting_name (void)
{
@ -845,6 +881,32 @@ test_setting_new_from_dbus (void)
g_object_unref (s_wsec);
}
static void
test_setting_new_from_dbus_transform (void)
{
NMSetting *s_wired;
GHashTable *hash;
GValue val = { 0, };
const char *test_mac_address = "11:22:33:44:55:66";
GByteArray *dbus_mac_address;
GError *error = NULL;
hash = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, (GDestroyNotify) g_value_unset);
dbus_mac_address = nm_utils_hwaddr_atoba (test_mac_address, ETH_ALEN);
g_value_init (&val, DBUS_TYPE_G_UCHAR_ARRAY);
g_value_take_boxed (&val, dbus_mac_address);
g_hash_table_insert (hash, NM_SETTING_WIRED_MAC_ADDRESS, &val);
s_wired = _nm_setting_new_from_dbus (NM_TYPE_SETTING_WIRED, hash, NULL, &error);
g_assert_no_error (error);
g_assert_cmpstr (nm_setting_wired_get_mac_address (NM_SETTING_WIRED (s_wired)), ==, test_mac_address);
g_hash_table_unref (hash);
g_object_unref (s_wired);
}
static NMConnection *
new_test_connection (void)
{
@ -1739,7 +1801,7 @@ test_connection_good_base_types (void)
gboolean success;
GError *error = NULL;
GByteArray *array;
const guint8 bdaddr[] = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66 };
const char *bdaddr = "11:22:33:44:55:66";
/* Try a basic wired connection */
connection = nm_simple_connection_new ();
@ -1788,13 +1850,10 @@ test_connection_good_base_types (void)
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_BLUETOOTH_BDADDR, bdaddr,
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);
@ -2861,13 +2920,11 @@ static NMSetting *
_add_setting_fcn_bluetooth (NMConnection *con)
{
NMSetting *setting;
GByteArray *bdaddr = nm_utils_hwaddr_atoba ("11:22:33:44:55:66", ETH_ALEN);
setting = g_object_new (NM_TYPE_SETTING_BLUETOOTH,
NM_SETTING_BLUETOOTH_BDADDR, bdaddr,
NM_SETTING_BLUETOOTH_BDADDR, "11:22:33:44:55:66",
NM_SETTING_BLUETOOTH_TYPE, NM_SETTING_BLUETOOTH_TYPE_PANU,
NULL);
g_byte_array_free (bdaddr, TRUE);
nm_connection_add_setting (con, setting);
return setting;
@ -3033,12 +3090,9 @@ _add_setting_fcn_wireless (NMConnection *con)
static void
_prepare_normalizable_fcn_vlan (NMConnection *con)
{
GByteArray *mac_addr = nm_utils_hwaddr_atoba ("11:22:33:44:55:66", ETH_ALEN);
nm_connection_add_setting (con, g_object_new (NM_TYPE_SETTING_WIRED,
NM_SETTING_WIRED_MAC_ADDRESS, mac_addr,
NM_SETTING_WIRED_MAC_ADDRESS, "11:22:33:44:55:66",
NULL));
g_byte_array_free (mac_addr, TRUE);
}
static void
@ -3203,6 +3257,7 @@ int main (int argc, char **argv)
g_test_add_func ("/core/general/test_setting_to_dbus_all", test_setting_to_dbus_all);
g_test_add_func ("/core/general/test_setting_to_dbus_no_secrets", test_setting_to_dbus_no_secrets);
g_test_add_func ("/core/general/test_setting_to_dbus_only_secrets", test_setting_to_dbus_only_secrets);
g_test_add_func ("/core/general/test_setting_to_dbus_transform", test_setting_to_dbus_transform);
g_test_add_func ("/core/general/test_setting_compare_id", test_setting_compare_id);
#define ADD_FUNC(func, secret_flags, comp_flags, remove_secret) \
g_test_add_data_func_full ("/core/general/" G_STRINGIFY (func), \
@ -3221,6 +3276,7 @@ int main (int argc, char **argv)
g_test_add_func ("/core/general/test_connection_to_dbus_setting_name", test_connection_to_dbus_setting_name);
g_test_add_func ("/core/general/test_connection_to_dbus_deprecated_props", test_connection_to_dbus_deprecated_props);
g_test_add_func ("/core/general/test_setting_new_from_dbus", test_setting_new_from_dbus);
g_test_add_func ("/core/general/test_setting_new_from_dbus_transform", test_setting_new_from_dbus_transform);
g_test_add_func ("/core/general/test_connection_replace_settings", test_connection_replace_settings);
g_test_add_func ("/core/general/test_connection_replace_settings_from_connection", test_connection_replace_settings_from_connection);
g_test_add_func ("/core/general/test_connection_replace_settings_bad", test_connection_replace_settings_bad);

4
libnm/nm-access-point.c
View file

@ -238,7 +238,7 @@ nm_access_point_connection_valid (NMAccessPoint *ap, NMConnection *connection)
const char *ctype, *ap_bssid;
const GByteArray *setting_ssid;
const GByteArray *ap_ssid;
const GByteArray *setting_bssid;
const char *setting_bssid;
const char *setting_mode;
NM80211Mode ap_mode;
const char *setting_band;
@ -268,7 +268,7 @@ nm_access_point_connection_valid (NMAccessPoint *ap, NMConnection *connection)
g_warn_if_fail (ap_bssid);
setting_bssid = nm_setting_wireless_get_bssid (s_wifi);
if (setting_bssid && ap_bssid) {
if (!nm_utils_hwaddr_matches (ap_bssid, -1, setting_bssid->data, setting_bssid->len))
if (!nm_utils_hwaddr_matches (ap_bssid, -1, setting_bssid, -1))
return FALSE;
}

7
libnm/nm-device-bt.c
View file

@ -146,8 +146,7 @@ connection_compatible (NMDevice *device, NMConnection *connection, GError **erro
NMSettingConnection *s_con;
NMSettingBluetooth *s_bt;
const char *ctype;
const GByteArray *mac;
const char *hw_addr;
const char *hw_addr, *setting_addr;
NMBluetoothCapabilities dev_caps;
NMBluetoothCapabilities bt_type;
@ -176,8 +175,8 @@ connection_compatible (NMDevice *device, NMConnection *connection, GError **erro
"Invalid device MAC address.");
return FALSE;
}
mac = nm_setting_bluetooth_get_bdaddr (s_bt);
if (mac && !nm_utils_hwaddr_matches (mac->data, mac->len, hw_addr, -1)) {
setting_addr = nm_setting_bluetooth_get_bdaddr (s_bt);
if (setting_addr && !nm_utils_hwaddr_matches (setting_addr, -1, hw_addr, -1)) {
g_set_error (error, NM_DEVICE_BT_ERROR, NM_DEVICE_BT_ERROR_MAC_MISMATCH,
"The MACs of the device and the connection didn't match.");
return FALSE;

7
libnm/nm-device-ethernet.c
View file

@ -168,8 +168,7 @@ connection_compatible (NMDevice *device, NMConnection *connection, GError **erro
}
if (s_wired) {
const GByteArray *mac;
const char *perm_addr;
const char *perm_addr, *setting_addr;
/* FIXME: filter using s390 subchannels when they are exported over the bus */
@ -181,8 +180,8 @@ connection_compatible (NMDevice *device, NMConnection *connection, GError **erro
"Invalid device MAC address.");
return FALSE;
}
mac = nm_setting_wired_get_mac_address (s_wired);
if (mac && !nm_utils_hwaddr_matches (mac->data, mac->len, perm_addr, -1)) {
setting_addr = nm_setting_wired_get_mac_address (s_wired);
if (setting_addr && !nm_utils_hwaddr_matches (setting_addr, -1, perm_addr, -1)) {
g_set_error (error, NM_DEVICE_ETHERNET_ERROR, NM_DEVICE_ETHERNET_ERROR_MAC_MISMATCH,
"The MACs of the device and the connection didn't match.");
return FALSE;

7
libnm/nm-device-infiniband.c
View file

@ -105,8 +105,7 @@ connection_compatible (NMDevice *device, NMConnection *connection, GError **erro
{
NMSettingConnection *s_con;
NMSettingInfiniband *s_infiniband;
const char *ctype, *hwaddr;
const GByteArray *mac;
const char *ctype, *hwaddr, *setting_hwaddr;
s_con = nm_connection_get_setting_connection (connection);
g_assert (s_con);
@ -132,9 +131,9 @@ connection_compatible (NMDevice *device, NMConnection *connection, GError **erro
"Invalid device MAC address.");
return FALSE;
}
mac = nm_setting_infiniband_get_mac_address (s_infiniband);
if (mac && !nm_utils_hwaddr_matches (mac->data, mac->len, hwaddr, -1)) {
setting_hwaddr = nm_setting_infiniband_get_mac_address (s_infiniband);
if (setting_hwaddr && !nm_utils_hwaddr_matches (setting_hwaddr, -1, hwaddr, -1)) {
g_set_error (error, NM_DEVICE_INFINIBAND_ERROR, NM_DEVICE_INFINIBAND_ERROR_MAC_MISMATCH,
"The MACs of the device and the connection didn't match.");
return FALSE;

14
libnm/nm-device-vlan.c
View file

@ -123,8 +123,7 @@ connection_compatible (NMDevice *device, NMConnection *connection, GError **erro
NMSettingVlan *s_vlan;
NMSettingWired *s_wired;
const char *ctype, *dev_iface_name, *vlan_iface_name;
const GByteArray *mac_address;
char *mac_address_str;
const char *setting_hwaddr;
s_con = nm_connection_get_setting_connection (connection);
g_assert (s_con);
@ -159,16 +158,15 @@ connection_compatible (NMDevice *device, NMConnection *connection, GError **erro
s_wired = nm_connection_get_setting_wired (connection);
if (s_wired)
mac_address = nm_setting_wired_get_mac_address (s_wired);
setting_hwaddr = nm_setting_wired_get_mac_address (s_wired);
else
mac_address = NULL;
if (mac_address) {
mac_address_str = nm_utils_hwaddr_ntoa (mac_address->data, mac_address->len);
if (!g_strcmp0 (mac_address_str, NM_DEVICE_VLAN_GET_PRIVATE (device)->hw_address)) {
setting_hwaddr = NULL;
if (setting_hwaddr) {
if (!nm_utils_hwaddr_matches (setting_hwaddr, -1,
NM_DEVICE_VLAN_GET_PRIVATE (device)->hw_address, -1)) {
g_set_error (error, NM_DEVICE_VLAN_ERROR, NM_DEVICE_VLAN_ERROR_MAC_MISMATCH,
"The hardware address of the device and the connection didn't match.");
}
g_free (mac_address_str);
}
return NM_DEVICE_CLASS (nm_device_vlan_parent_class)->connection_compatible (device, connection, error);

13
libnm/nm-device-wifi.c
View file

@ -418,8 +418,7 @@ connection_compatible (NMDevice *device, NMConnection *connection, GError **erro
NMSettingWireless *s_wifi;
NMSettingWirelessSecurity *s_wsec;
const char *ctype;
const GByteArray *mac;
const char *hw_addr;
const char *hwaddr, *setting_hwaddr;
NMDeviceWifiCapabilities wifi_caps;
const char *key_mgmt;
@ -441,15 +440,15 @@ connection_compatible (NMDevice *device, NMConnection *connection, GError **erro
}
/* Check MAC address */
hw_addr = nm_device_wifi_get_permanent_hw_address (NM_DEVICE_WIFI (device));
if (hw_addr) {
if (!nm_utils_hwaddr_valid (hw_addr, ETH_ALEN)) {
hwaddr = nm_device_wifi_get_permanent_hw_address (NM_DEVICE_WIFI (device));
if (hwaddr) {
if (!nm_utils_hwaddr_valid (hwaddr, ETH_ALEN)) {
g_set_error (error, NM_DEVICE_WIFI_ERROR, NM_DEVICE_WIFI_ERROR_INVALID_DEVICE_MAC,
"Invalid device MAC address.");
return FALSE;
}
mac = nm_setting_wireless_get_mac_address (s_wifi);
if (mac && !nm_utils_hwaddr_matches (mac->data, mac->len, hw_addr, -1)) {
setting_hwaddr = nm_setting_wireless_get_mac_address (s_wifi);
if (setting_hwaddr && !nm_utils_hwaddr_matches (setting_hwaddr, -1, hwaddr, -1)) {
g_set_error (error, NM_DEVICE_WIFI_ERROR, NM_DEVICE_WIFI_ERROR_MAC_MISMATCH,
"The MACs of the device and the connection didn't match.");
return FALSE;

13
libnm/nm-device-wimax.c
View file

@ -322,8 +322,7 @@ connection_compatible (NMDevice *device, NMConnection *connection, GError **erro
NMSettingConnection *s_con;
NMSettingWimax *s_wimax;
const char *ctype;
const GByteArray *mac;
const char *hw_addr;
const char *hwaddr, *setting_hwaddr;
s_con = nm_connection_get_setting_connection (connection);
g_assert (s_con);
@ -343,15 +342,15 @@ connection_compatible (NMDevice *device, NMConnection *connection, GError **erro
}
/* Check MAC address */
hw_addr = nm_device_wimax_get_hw_address (NM_DEVICE_WIMAX (device));
if (hw_addr) {
if (!nm_utils_hwaddr_valid (hw_addr, ETH_ALEN)) {
hwaddr = nm_device_wimax_get_hw_address (NM_DEVICE_WIMAX (device));
if (hwaddr) {
if (!nm_utils_hwaddr_valid (hwaddr, ETH_ALEN)) {
g_set_error (error, NM_DEVICE_WIMAX_ERROR, NM_DEVICE_WIMAX_ERROR_INVALID_DEVICE_MAC,
"Invalid device MAC address.");
return FALSE;
}
mac = nm_setting_wimax_get_mac_address (s_wimax);
if (mac && !nm_utils_hwaddr_matches (mac->data, mac->len, hw_addr, -1)) {
setting_hwaddr = nm_setting_wimax_get_mac_address (s_wimax);
if (setting_hwaddr && !nm_utils_hwaddr_matches (setting_hwaddr, -1, hwaddr, -1)) {
g_set_error (error, NM_DEVICE_WIMAX_ERROR, NM_DEVICE_WIMAX_ERROR_MAC_MISMATCH,
"The MACs of the device and the connection didn't match.");
return FALSE;

25
src/NetworkManagerUtils.c
View file

@ -63,30 +63,37 @@
*
*/
gboolean
nm_ethernet_address_is_valid (const guint8 *test_addr)
nm_ethernet_address_is_valid (gconstpointer addr, gsize len)
{
guint8 invalid_addr1[ETH_ALEN] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
guint8 invalid_addr2[ETH_ALEN] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
guint8 invalid_addr3[ETH_ALEN] = {0x44, 0x44, 0x44, 0x44, 0x44, 0x44};
guint8 invalid_addr4[ETH_ALEN] = {0x00, 0x30, 0xb4, 0x00, 0x00, 0x00}; /* prism54 dummy MAC */
guchar first_octet;
g_return_val_if_fail (test_addr != NULL, FALSE);
g_return_val_if_fail (addr != NULL, FALSE);
g_return_val_if_fail (len == ETH_ALEN || len == -1, FALSE);
/* Compare the AP address the card has with invalid ethernet MAC addresses. */
if (!memcmp (test_addr, invalid_addr1, ETH_ALEN))
if (nm_utils_hwaddr_matches (addr, len, invalid_addr1, ETH_ALEN))
return FALSE;
if (!memcmp (test_addr, invalid_addr2, ETH_ALEN))
if (nm_utils_hwaddr_matches (addr, len, invalid_addr2, ETH_ALEN))
return FALSE;
if (!memcmp (test_addr, invalid_addr3, ETH_ALEN))
if (nm_utils_hwaddr_matches (addr, len, invalid_addr3, ETH_ALEN))
return FALSE;
if (!memcmp (test_addr, invalid_addr4, ETH_ALEN))
if (nm_utils_hwaddr_matches (addr, len, invalid_addr4, ETH_ALEN))
return FALSE;
if (test_addr[0] & 1) /* Multicast addresses */
return FALSE;
/* Check for multicast address */
if (len == -1)
first_octet = strtoul (addr, NULL, 16);
else
first_octet = ((guint8 *)addr)[0];
if (first_octet & 0x01)
return FALSE;
return TRUE;
}
@ -1237,7 +1244,7 @@ check_connection_mac_address (NMConnection *orig,
GHashTable *settings)
{
GHashTable *props;
const GByteArray *orig_mac = NULL, *cand_mac = NULL;
const char *orig_mac = NULL, *cand_mac = NULL;
NMSettingWired *s_wired_orig, *s_wired_cand;
props = check_property_in_hash (settings,

2
src/NetworkManagerUtils.h
View file

@ -28,7 +28,7 @@
#include "nm-connection.h"
#include "nm-platform.h"
gboolean nm_ethernet_address_is_valid (const guint8 *test_addr);
gboolean nm_ethernet_address_is_valid (gconstpointer addr, gsize len);
in_addr_t nm_utils_ip4_address_clear_host_address (in_addr_t addr, guint8 plen);
void nm_utils_ip6_address_clear_host_address (struct in6_addr *dst, const struct in6_addr *src, guint8 plen);

26
src/devices/bluetooth/nm-bluez-device.c
View file

@ -54,7 +54,6 @@ typedef struct {
NMBluetoothCapabilities connection_bt_type;
char *address;
guint8 bin_address[ETH_ALEN];
char *name;
guint32 capabilities;
gboolean connected;
@ -166,7 +165,6 @@ pan_connection_check_create (NMBluezDevice *self)
NMConnection *added;
NMSetting *setting;
char *uuid, *id;
GByteArray *bdaddr_array;
GError *error = NULL;
NMBluezDevicePrivate *priv = NM_BLUEZ_DEVICE_GET_PRIVATE (self);
@ -200,15 +198,12 @@ pan_connection_check_create (NMBluezDevice *self)
nm_connection_add_setting (connection, setting);
/* Setting: Bluetooth */
bdaddr_array = g_byte_array_sized_new (sizeof (priv->bin_address));
g_byte_array_append (bdaddr_array, priv->bin_address, sizeof (priv->bin_address));
setting = nm_setting_bluetooth_new ();
g_object_set (G_OBJECT (setting),
NM_SETTING_BLUETOOTH_BDADDR, bdaddr_array,
NM_SETTING_BLUETOOTH_BDADDR, priv->address,
NM_SETTING_BLUETOOTH_TYPE, NM_SETTING_BLUETOOTH_TYPE_PANU,
NULL);
nm_connection_add_setting (connection, setting);
g_byte_array_free (bdaddr_array, TRUE);
/* Setting: IPv4 */
setting = nm_setting_ip4_config_new ();
@ -300,7 +295,7 @@ connection_compatible (NMBluezDevice *self, NMConnection *connection)
NMBluezDevicePrivate *priv = NM_BLUEZ_DEVICE_GET_PRIVATE (self);
NMSettingBluetooth *s_bt;
const char *bt_type;
const GByteArray *bdaddr;
const char *bdaddr;
if (!nm_connection_is_type (connection, NM_SETTING_BLUETOOTH_SETTING_NAME))
return FALSE;
@ -309,14 +304,13 @@ connection_compatible (NMBluezDevice *self, NMConnection *connection)
if (!s_bt)
return FALSE;
if (!priv->address) {
/* unless address is set, bin_address is not initialized. */
if (!priv->address)
return FALSE;
}
bdaddr = nm_setting_bluetooth_get_bdaddr (s_bt);
if (!bdaddr)
return FALSE;
if (!nm_utils_hwaddr_matches (bdaddr->data, bdaddr->len, priv->bin_address, ETH_ALEN))
if (!nm_utils_hwaddr_matches (bdaddr, -1, priv->address, -1))
return FALSE;
bt_type = nm_setting_bluetooth_get_connection_type (s_bt);
@ -611,8 +605,6 @@ _set_property_capabilities (NMBluezDevice *self, const char **uuids)
/**
* priv->address can only be set one to a certain (non NULL) value. Every later attempt
* to reset it to another value will be ignored and a warning will be logged.
*
* When setting the address for the first time, we also set bin_address.
**/
static void
_set_property_address (NMBluezDevice *self, const char *addr)
@ -632,13 +624,11 @@ _set_property_address (NMBluezDevice *self, const char *addr)
return;
}
if (!nm_utils_hwaddr_aton (addr, priv->bin_address, ETH_ALEN)) {
if (priv->address)
nm_log_warn (LOGD_BT, "bluez[%s] cannot reset address from '%s' to '%s' (invalid value)", priv->path, priv->address, addr);
else
nm_log_warn (LOGD_BT, "bluez[%s] cannot reset address from NULL to '%s' (invalid value)", priv->path, addr);
if (!nm_utils_hwaddr_valid (addr, ETH_ALEN)) {
nm_log_warn (LOGD_BT, "bluez[%s] cannot set address to '%s' (invalid value)", priv->path, addr);
return;
}
priv->address = g_strdup (addr);
g_object_notify (G_OBJECT (self), NM_BLUEZ_DEVICE_ADDRESS);
}

21
src/devices/bluetooth/nm-device-bt.c
View file

@ -158,7 +158,7 @@ check_connection_compatible (NMDevice *device, NMConnection *connection)
NMDeviceBtPrivate *priv = NM_DEVICE_BT_GET_PRIVATE (device);
NMSettingConnection *s_con;
NMSettingBluetooth *s_bt;
const GByteArray *array;
const char *bdaddr;
guint32 bt_type;
if (!NM_DEVICE_CLASS (nm_device_bt_parent_class)->check_connection_compatible (device, connection))
@ -178,10 +178,10 @@ check_connection_compatible (NMDevice *device, NMConnection *connection)
if (!(bt_type & priv->capabilities))
return FALSE;
array = nm_setting_bluetooth_get_bdaddr (s_bt);
if (!array)
bdaddr = nm_setting_bluetooth_get_bdaddr (s_bt);
if (!bdaddr)
return FALSE;
if (!nm_utils_hwaddr_matches (priv->bdaddr, -1, array->data, array->len))
if (!nm_utils_hwaddr_matches (priv->bdaddr, -1, bdaddr, -1))
return FALSE;
return TRUE;
@ -215,7 +215,7 @@ complete_connection (NMDevice *device,
{
NMDeviceBtPrivate *priv = NM_DEVICE_BT_GET_PRIVATE (device);
NMSettingBluetooth *s_bt;
const GByteArray *setting_bdaddr;
const char *setting_bdaddr;
const char *ctype;
gboolean is_dun = FALSE, is_pan = FALSE;
NMSettingGsm *s_gsm;
@ -324,7 +324,7 @@ complete_connection (NMDevice *device,
setting_bdaddr = nm_setting_bluetooth_get_bdaddr (s_bt);
if (setting_bdaddr) {
/* Make sure the setting BT Address (if any) matches the device's */
if (!nm_utils_hwaddr_matches (setting_bdaddr->data, setting_bdaddr->len, priv->bdaddr, -1)) {
if (!nm_utils_hwaddr_matches (setting_bdaddr, -1, priv->bdaddr, -1)) {
g_set_error_literal (error,
NM_SETTING_BLUETOOTH_ERROR,
NM_SETTING_BLUETOOTH_ERROR_INVALID_PROPERTY,
@ -332,14 +332,9 @@ complete_connection (NMDevice *device,
return FALSE;
}
} else {
GByteArray *bdaddr;
/* Lock the connection to this device by default */
if (!nm_utils_hwaddr_matches (priv->bdaddr, -1, NULL, ETH_ALEN)) {
bdaddr = nm_utils_hwaddr_atoba (priv->bdaddr, ETH_ALEN);
g_object_set (G_OBJECT (s_bt), NM_SETTING_BLUETOOTH_BDADDR, bdaddr, NULL);
g_byte_array_free (bdaddr, TRUE);
}
if (!nm_utils_hwaddr_matches (priv->bdaddr, -1, NULL, ETH_ALEN))
g_object_set (G_OBJECT (s_bt), NM_SETTING_BLUETOOTH_BDADDR, priv->bdaddr, NULL);
}
return TRUE;

18
src/devices/nm-device-bridge.c
View file

@ -101,7 +101,7 @@ check_connection_compatible (NMDevice *device, NMConnection *connection)
{
const char *iface;
NMSettingBridge *s_bridge;
const GByteArray *mac_address;
const char *mac_address;
if (!NM_DEVICE_CLASS (nm_device_bridge_parent_class)->check_connection_compatible (device, connection))
return FALSE;
@ -120,8 +120,7 @@ check_connection_compatible (NMDevice *device, NMConnection *connection)
const char *hw_addr;
hw_addr = nm_device_get_hw_address (device);
if ( !hw_addr
|| !nm_utils_hwaddr_matches (hw_addr, -1, mac_address->data, mac_address->len))
if (!hw_addr || !nm_utils_hwaddr_matches (hw_addr, -1, mac_address, -1))
return FALSE;
}
@ -424,7 +423,8 @@ nm_device_bridge_new_for_connection (NMConnection *connection)
{
const char *iface;
NMSettingBridge *s_bridge;
const GByteArray *mac_address;
const char *mac_address_str;
guint8 mac_address[NM_UTILS_HWADDR_LEN_MAX];
g_return_val_if_fail (connection != NULL, NULL);
@ -434,11 +434,15 @@ nm_device_bridge_new_for_connection (NMConnection *connection)
s_bridge = nm_connection_get_setting_bridge (connection);
g_return_val_if_fail (s_bridge, NULL);
mac_address = nm_setting_bridge_get_mac_address (s_bridge);
mac_address_str = nm_setting_bridge_get_mac_address (s_bridge);
if (mac_address_str) {
if (!nm_utils_hwaddr_aton (mac_address_str, mac_address, ETH_ALEN))
mac_address_str = NULL;
}
if ( !nm_platform_bridge_add (iface,
mac_address ? mac_address->data : NULL,
mac_address ? mac_address->len : 0)
mac_address_str ? mac_address : NULL,
mac_address_str ? ETH_ALEN : 0)
&& nm_platform_get_error () != NM_PLATFORM_ERROR_EXISTS) {
nm_log_warn (LOGD_DEVICE | LOGD_BRIDGE, "(%s): failed to create bridge master interface for '%s': %s",
iface, nm_connection_get_id (connection),

55
src/devices/nm-device-ethernet.c
View file

@ -101,8 +101,8 @@ typedef enum {
} DcbWait;
typedef struct {
char * perm_hw_addr; /* Permanent MAC address */
guint8 initial_hw_addr[ETH_ALEN]; /* Initial MAC address (as seen when NM starts) */
char * perm_hw_addr; /* Permanent MAC address */
char * initial_hw_addr; /* Initial MAC address (as seen when NM starts) */
guint32 speed;
@ -361,7 +361,7 @@ update_permanent_hw_address (NMDevice *dev)
errno = 0;
ret = ioctl (fd, SIOCETHTOOL, &req);
errsv = errno;
if ((ret < 0) || !nm_ethernet_address_is_valid (epaddr->data)) {
if ((ret < 0) || !nm_ethernet_address_is_valid (epaddr->data, ETH_ALEN)) {
_LOGD (LOGD_HW | LOGD_ETHER, "unable to read permanent MAC address (error %d)", errsv);
/* Fall back to current address */
mac = nm_device_get_hw_address (dev);
@ -382,16 +382,13 @@ update_initial_hw_address (NMDevice *dev)
{
NMDeviceEthernet *self = NM_DEVICE_ETHERNET (dev);
NMDeviceEthernetPrivate *priv = NM_DEVICE_ETHERNET_GET_PRIVATE (self);
const char *mac;
/* This sets initial MAC address from current MAC address. It should only
* be called from NMDevice constructor() to really get the initial address.
*/
mac = nm_device_get_hw_address (dev);
if (mac)
nm_utils_hwaddr_aton (mac, priv->initial_hw_addr, ETH_ALEN);
priv->initial_hw_addr = g_strdup (nm_device_get_hw_address (dev));
_LOGD (LOGD_DEVICE | LOGD_ETHER, "read initial MAC address %s", mac);
_LOGD (LOGD_DEVICE | LOGD_ETHER, "read initial MAC address %s", priv->initial_hw_addr);
}
static guint32
@ -462,7 +459,7 @@ check_connection_compatible (NMDevice *device, NMConnection *connection)
return FALSE;
if (s_wired) {
const GByteArray *mac;
const char *mac;
gboolean try_mac = TRUE;
const GSList *mac_blacklist, *mac_blacklist_iter;
@ -470,21 +467,19 @@ check_connection_compatible (NMDevice *device, NMConnection *connection)
return FALSE;
mac = nm_setting_wired_get_mac_address (s_wired);
if (try_mac && mac && !nm_utils_hwaddr_matches (mac->data, mac->len, priv->perm_hw_addr, -1))
if (try_mac && mac && !nm_utils_hwaddr_matches (mac, -1, priv->perm_hw_addr, -1))
return FALSE;
/* Check for MAC address blacklist */
mac_blacklist = nm_setting_wired_get_mac_address_blacklist (s_wired);
for (mac_blacklist_iter = mac_blacklist; mac_blacklist_iter;
mac_blacklist_iter = g_slist_next (mac_blacklist_iter)) {
guint8 addr[ETH_ALEN];
if (!nm_utils_hwaddr_aton (mac_blacklist_iter->data, addr, ETH_ALEN)) {
if (!nm_utils_hwaddr_valid (mac_blacklist_iter->data, ETH_ALEN)) {
g_warn_if_reached ();
return FALSE;
}
if (nm_utils_hwaddr_matches (addr, ETH_ALEN, priv->perm_hw_addr, -1))
if (nm_utils_hwaddr_matches (mac_blacklist_iter->data, -1, priv->perm_hw_addr, -1))
return FALSE;
}
}
@ -911,7 +906,7 @@ act_stage1_prepare (NMDevice *dev, NMDeviceStateReason *reason)
NMDeviceEthernetPrivate *priv = NM_DEVICE_ETHERNET_GET_PRIVATE (self);
NMActRequest *req;
NMSettingWired *s_wired;
const GByteArray *cloned_mac;
const char *cloned_mac;
NMActStageReturn ret = NM_ACT_STAGE_RETURN_SUCCESS;
g_return_val_if_fail (reason != NULL, NM_ACT_STAGE_RETURN_FAILURE);
@ -925,8 +920,8 @@ act_stage1_prepare (NMDevice *dev, NMDeviceStateReason *reason)
if (s_wired) {
/* Set device MAC address if the connection wants to change it */
cloned_mac = nm_setting_wired_get_cloned_mac_address (s_wired);
if (cloned_mac && (cloned_mac->len == ETH_ALEN))
nm_device_set_hw_addr (dev, cloned_mac->data, "set", LOGD_ETHER);
if (cloned_mac)
nm_device_set_hw_addr (dev, cloned_mac, "set", LOGD_ETHER);
}
/* If we're re-activating a PPPoE connection a short while after
@ -1430,7 +1425,7 @@ complete_connection (NMDevice *device,
NMDeviceEthernetPrivate *priv = NM_DEVICE_ETHERNET_GET_PRIVATE (device);
NMSettingWired *s_wired;
NMSettingPppoe *s_pppoe;
const GByteArray *setting_mac;
const char *setting_mac;
s_pppoe = nm_connection_get_setting_pppoe (connection);
@ -1460,7 +1455,7 @@ complete_connection (NMDevice *device,
setting_mac = nm_setting_wired_get_mac_address (s_wired);
if (setting_mac) {
/* Make sure the setting MAC (if any) matches the device's permanent MAC */
if (!nm_utils_hwaddr_matches (setting_mac->data, setting_mac->len, priv->perm_hw_addr, -1)) {
if (!nm_utils_hwaddr_matches (setting_mac, -1, priv->perm_hw_addr, -1)) {
g_set_error_literal (error,
NM_SETTING_WIRED_ERROR,
NM_SETTING_WIRED_ERROR_INVALID_PROPERTY,
@ -1468,13 +1463,10 @@ complete_connection (NMDevice *device,
return FALSE;
}
} else {
GByteArray *mac;
/* Lock the connection to this device by default */
if (!nm_utils_hwaddr_matches (priv->perm_hw_addr, -1, NULL, ETH_ALEN)) {
mac = nm_utils_hwaddr_atoba (priv->perm_hw_addr, ETH_ALEN);
g_object_set (G_OBJECT (s_wired), NM_SETTING_WIRED_MAC_ADDRESS, mac, NULL);
g_byte_array_free (mac, TRUE);
g_object_set (G_OBJECT (s_wired),
NM_SETTING_WIRED_MAC_ADDRESS, priv->perm_hw_addr,
NULL);
}
}
@ -1499,7 +1491,6 @@ update_connection (NMDevice *device, NMConnection *connection)
NMSettingWired *s_wired = nm_connection_get_setting_wired (connection);
const char *mac = nm_device_get_hw_address (device);
const char *mac_prop = NM_SETTING_WIRED_MAC_ADDRESS;
GByteArray *array;
GHashTableIter iter;
gpointer key, value;
@ -1512,20 +1503,15 @@ update_connection (NMDevice *device, NMConnection *connection)
* and the current MAC, if different, is the cloned MAC.
*/
if (!nm_utils_hwaddr_matches (priv->perm_hw_addr, -1, NULL, ETH_ALEN)) {
array = nm_utils_hwaddr_atoba (priv->perm_hw_addr, ETH_ALEN);
g_object_set (s_wired, NM_SETTING_WIRED_MAC_ADDRESS, array, NULL);
g_byte_array_unref (array);
g_object_set (s_wired, NM_SETTING_WIRED_MAC_ADDRESS, priv->perm_hw_addr, NULL);
mac_prop = NULL;
if (mac && !nm_utils_hwaddr_matches (priv->perm_hw_addr, -1, mac, -1))
mac_prop = NM_SETTING_WIRED_CLONED_MAC_ADDRESS;
}
if (mac_prop && mac && nm_utils_hwaddr_valid (mac, ETH_ALEN)) {
array = nm_utils_hwaddr_atoba (mac, ETH_ALEN);
g_object_set (s_wired, mac_prop, array, NULL);
g_byte_array_unref (array);
}
if (mac_prop && mac && nm_utils_hwaddr_valid (mac, ETH_ALEN))
g_object_set (s_wired, mac_prop, mac, NULL);
/* We don't set the MTU as we don't know whether it was set explicitly */
@ -1628,6 +1614,7 @@ finalize (GObject *object)
NMDeviceEthernetPrivate *priv = NM_DEVICE_ETHERNET_GET_PRIVATE (self);
g_free (priv->perm_hw_addr);
g_free (priv->initial_hw_addr);
g_clear_object (&priv->supplicant.mgr);
g_free (priv->subchan1);
g_free (priv->subchan2);

24
src/devices/nm-device-infiniband.c
View file

@ -195,7 +195,6 @@ static gboolean
check_connection_compatible (NMDevice *device, NMConnection *connection)
{
NMSettingInfiniband *s_infiniband;
const GByteArray *mac;
if (!NM_DEVICE_CLASS (nm_device_infiniband_parent_class)->check_connection_compatible (device, connection))
return FALSE;
@ -208,9 +207,10 @@ check_connection_compatible (NMDevice *device, NMConnection *connection)
return FALSE;
if (s_infiniband) {
const char *mac;
mac = nm_setting_infiniband_get_mac_address (s_infiniband);
if (mac && !nm_utils_hwaddr_matches (mac->data, mac->len,
nm_device_get_hw_address (device), -1))
if (mac && !nm_utils_hwaddr_matches (mac, -1, nm_device_get_hw_address (device), -1))
return FALSE;
}
@ -225,7 +225,7 @@ complete_connection (NMDevice *device,
GError **error)
{
NMSettingInfiniband *s_infiniband;
const GByteArray *setting_mac;
const char *setting_mac;
const char *hw_address;
nm_utils_complete_generic (connection,
@ -246,7 +246,7 @@ complete_connection (NMDevice *device,
hw_address = nm_device_get_hw_address (device);
if (setting_mac) {
/* Make sure the setting MAC (if any) matches the device's MAC */
if (!nm_utils_hwaddr_matches (setting_mac->data, setting_mac->len, hw_address, INFINIBAND_ALEN)) {
if (!nm_utils_hwaddr_matches (setting_mac, -1, hw_address, -1)) {
g_set_error_literal (error,
NM_SETTING_INFINIBAND_ERROR,
NM_SETTING_INFINIBAND_ERROR_INVALID_PROPERTY,
@ -254,12 +254,8 @@ complete_connection (NMDevice *device,
return FALSE;
}
} else {
GByteArray *mac;
/* Lock the connection to this device by default */
mac = nm_utils_hwaddr_atoba (hw_address, INFINIBAND_ALEN);
g_object_set (G_OBJECT (s_infiniband), NM_SETTING_INFINIBAND_MAC_ADDRESS, mac, NULL);
g_byte_array_free (mac, TRUE);
g_object_set (G_OBJECT (s_infiniband), NM_SETTING_INFINIBAND_MAC_ADDRESS, hw_address, NULL);
}
if (!nm_setting_infiniband_get_transport_mode (s_infiniband))
@ -273,7 +269,6 @@ update_connection (NMDevice *device, NMConnection *connection)
{
NMSettingInfiniband *s_infiniband = nm_connection_get_setting_infiniband (connection);
const char *mac = nm_device_get_hw_address (device);
GByteArray *array;
char *mode_path, *contents = NULL;
const char *transport_mode = "datagram";
@ -282,11 +277,8 @@ update_connection (NMDevice *device, NMConnection *connection)
nm_connection_add_setting (connection, (NMSetting *) s_infiniband);
}
if (mac && !nm_utils_hwaddr_matches (mac, -1, NULL, INFINIBAND_ALEN)) {
array = nm_utils_hwaddr_atoba (mac, INFINIBAND_ALEN);
g_object_set (s_infiniband, NM_SETTING_INFINIBAND_MAC_ADDRESS, array, NULL);
g_byte_array_unref (array);
}
if (mac && !nm_utils_hwaddr_matches (mac, -1, NULL, INFINIBAND_ALEN))
g_object_set (s_infiniband, NM_SETTING_INFINIBAND_MAC_ADDRESS, mac, NULL);
mode_path = g_strdup_printf ("/sys/class/net/%s/mode",
ASSERT_VALID_PATH_COMPONENT (nm_device_get_iface (device)));

4
src/devices/nm-device-private.h
View file

@ -52,7 +52,7 @@ gboolean nm_device_bring_up (NMDevice *self, gboolean wait, gboolean *no_firmwar
void nm_device_take_down (NMDevice *self, gboolean block);
gboolean nm_device_set_hw_addr (NMDevice *device, const guint8 *addr,
gboolean nm_device_set_hw_addr (NMDevice *device, const char *addr,
const char *detail, guint64 hw_log_domain);
gboolean nm_device_ip_config_should_fail (NMDevice *self, gboolean ip6);
@ -75,7 +75,7 @@ gboolean nm_device_activate_ip6_state_in_conf (NMDevice *device);
gboolean nm_device_activate_ip6_state_in_wait (NMDevice *device);
void nm_device_set_dhcp_timeout (NMDevice *device, guint32 timeout);
void nm_device_set_dhcp_anycast_address (NMDevice *device, guint8 *addr);
void nm_device_set_dhcp_anycast_address (NMDevice *device, const char *addr);
gboolean nm_device_dhcp4_renew (NMDevice *device, gboolean release);
gboolean nm_device_dhcp6_renew (NMDevice *device, gboolean release);

35
src/devices/nm-device-vlan.c
View file

@ -51,7 +51,7 @@ G_DEFINE_TYPE (NMDeviceVlan, nm_device_vlan, NM_TYPE_DEVICE)
#define NM_VLAN_ERROR (nm_vlan_error_quark ())
typedef struct {
guint8 initial_hw_addr[ETH_ALEN];
char *initial_hw_addr;
gboolean disposed;
gboolean invalid;
@ -88,12 +88,9 @@ update_initial_hw_address (NMDevice *dev)
{
NMDeviceVlan *self = NM_DEVICE_VLAN (dev);
NMDeviceVlanPrivate *priv = NM_DEVICE_VLAN_GET_PRIVATE (self);
const char *mac_str;
mac_str = nm_device_get_hw_address (dev);
nm_utils_hwaddr_aton (mac_str, priv->initial_hw_addr, ETH_ALEN);
_LOGD (LOGD_DEVICE | LOGD_VLAN, "read initial MAC address %s", mac_str);
priv->initial_hw_addr = g_strdup (nm_device_get_hw_address (dev));
_LOGD (LOGD_DEVICE | LOGD_VLAN, "read initial MAC address %s", priv->initial_hw_addr);
}
static guint32
@ -157,20 +154,20 @@ static gboolean
match_hwaddr (NMDevice *device, NMConnection *connection, gboolean fail_if_no_hwaddr)
{
NMSettingWired *s_wired;
const GByteArray *mac;
const char *setting_mac;
const char *device_mac;
s_wired = nm_connection_get_setting_wired (connection);
if (!s_wired)
return !fail_if_no_hwaddr;
mac = nm_setting_wired_get_mac_address (s_wired);
if (!mac)
setting_mac = nm_setting_wired_get_mac_address (s_wired);
if (!setting_mac)
return !fail_if_no_hwaddr;
device_mac = nm_device_get_hw_address (device);
return nm_utils_hwaddr_matches (mac->data, mac->len, device_mac, -1);
return nm_utils_hwaddr_matches (setting_mac, -1, device_mac, -1);
}
static gboolean
@ -333,7 +330,7 @@ act_stage1_prepare (NMDevice *dev, NMDeviceStateReason *reason)
NMConnection *connection;
NMSettingVlan *s_vlan;
NMSettingWired *s_wired;
const GByteArray *cloned_mac;
const char *cloned_mac;
NMActStageReturn ret;
g_return_val_if_fail (reason != NULL, NM_ACT_STAGE_RETURN_FAILURE);
@ -352,8 +349,8 @@ act_stage1_prepare (NMDevice *dev, NMDeviceStateReason *reason)
if (s_wired) {
/* Set device MAC address if the connection wants to change it */
cloned_mac = nm_setting_wired_get_cloned_mac_address (s_wired);
if (cloned_mac && (cloned_mac->len == ETH_ALEN))
nm_device_set_hw_addr (dev, (const guint8 *) cloned_mac->data, "set", LOGD_VLAN);
if (cloned_mac)
nm_device_set_hw_addr (dev, cloned_mac, "set", LOGD_VLAN);
}
s_vlan = nm_connection_get_setting_vlan (connection);
@ -605,6 +602,17 @@ dispose (GObject *object)
G_OBJECT_CLASS (nm_device_vlan_parent_class)->dispose (object);
}
static void
finalize (GObject *object)
{
NMDeviceVlan *self = NM_DEVICE_VLAN (object);
NMDeviceVlanPrivate *priv = NM_DEVICE_VLAN_GET_PRIVATE (self);
g_free (priv->initial_hw_addr);
G_OBJECT_CLASS (nm_device_vlan_parent_class)->finalize (object);
}
static void
nm_device_vlan_class_init (NMDeviceVlanClass *klass)
{
@ -620,6 +628,7 @@ nm_device_vlan_class_init (NMDeviceVlanClass *klass)
object_class->get_property = get_property;
object_class->set_property = set_property;
object_class->dispose = dispose;
object_class->finalize = finalize;
parent_class->update_initial_hw_address = update_initial_hw_address;
parent_class->get_generic_capabilities = get_generic_capabilities;

42
src/devices/nm-device.c
View file

@ -232,7 +232,7 @@ typedef struct {
/* Generic DHCP stuff */
guint32 dhcp_timeout;
GByteArray * dhcp_anycast_address;
char * dhcp_anycast_address;
/* IP4 configuration info */
NMIP4Config * ip4_config; /* Combined config from VPN, settings, and device */
@ -6076,23 +6076,17 @@ nm_device_set_dhcp_timeout (NMDevice *self, guint32 timeout)
}
void
nm_device_set_dhcp_anycast_address (NMDevice *self, guint8 *addr)
nm_device_set_dhcp_anycast_address (NMDevice *self, const char *addr)
{
NMDevicePrivate *priv;
g_return_if_fail (NM_IS_DEVICE (self));
g_return_if_fail (!addr || nm_utils_hwaddr_valid (addr, ETH_ALEN));
priv = NM_DEVICE_GET_PRIVATE (self);
if (priv->dhcp_anycast_address) {
g_byte_array_free (priv->dhcp_anycast_address, TRUE);
priv->dhcp_anycast_address = NULL;
}
if (addr) {
priv->dhcp_anycast_address = g_byte_array_sized_new (ETH_ALEN);
g_byte_array_append (priv->dhcp_anycast_address, addr, ETH_ALEN);
}
g_free (priv->dhcp_anycast_address);
priv->dhcp_anycast_address = g_strdup (addr);
}
/**
@ -6984,46 +6978,47 @@ nm_device_update_hw_address (NMDevice *self)
}
gboolean
nm_device_set_hw_addr (NMDevice *self, const guint8 *addr,
nm_device_set_hw_addr (NMDevice *self, const char *addr,
const char *detail, guint64 hw_log_domain)
{
NMDevicePrivate *priv = NM_DEVICE_GET_PRIVATE (self);
char *mac_str = NULL;
gboolean success = FALSE;
const char *cur_addr = nm_device_get_hw_address (self);
guint8 addr_bytes[NM_UTILS_HWADDR_LEN_MAX];
g_return_val_if_fail (addr != NULL, FALSE);
/* Do nothing if current MAC is same */
if (cur_addr && nm_utils_hwaddr_matches (cur_addr, -1, addr, priv->hw_addr_len)) {
if (cur_addr && nm_utils_hwaddr_matches (cur_addr, -1, addr, -1)) {
_LOGD (LOGD_DEVICE | hw_log_domain, "no MAC address change needed");
return TRUE;
}
mac_str = nm_utils_hwaddr_ntoa (addr, priv->hw_addr_len);
if (!nm_utils_hwaddr_aton (addr, addr_bytes, priv->hw_addr_len)) {
_LOGW (LOGD_DEVICE | hw_log_domain, "invalid MAC address %s", addr);
return FALSE;
}
/* Can't change MAC address while device is up */
nm_device_take_down (self, FALSE);
success = nm_platform_link_set_address (nm_device_get_ip_ifindex (self), addr, priv->hw_addr_len);
success = nm_platform_link_set_address (nm_device_get_ip_ifindex (self), addr_bytes, priv->hw_addr_len);
if (success) {
/* MAC address succesfully changed; update the current MAC to match */
nm_device_update_hw_address (self);
cur_addr = nm_device_get_hw_address (self);
if (cur_addr && nm_utils_hwaddr_matches (cur_addr, -1, addr, priv->hw_addr_len)) {
if (cur_addr && nm_utils_hwaddr_matches (cur_addr, -1, addr, -1)) {
_LOGI (LOGD_DEVICE | hw_log_domain, "%s MAC address to %s",
detail, mac_str);
detail, addr);
} else {
_LOGW (LOGD_DEVICE | hw_log_domain,
"new MAC address %s not successfully set", mac_str);
"new MAC address %s not successfully set", addr);
success = FALSE;
}
} else {
_LOGW (LOGD_DEVICE | hw_log_domain, "failed to %s MAC address to %s",
detail, mac_str);
detail, addr);
}
nm_device_bring_up (self, TRUE, NULL);
g_free (mac_str);
return success;
}
@ -7316,8 +7311,7 @@ finalize (GObject *object)
g_free (priv->driver_version);
g_free (priv->firmware_version);
g_free (priv->type_desc);
if (priv->dhcp_anycast_address)
g_byte_array_free (priv->dhcp_anycast_address, TRUE);
g_free (priv->dhcp_anycast_address);
G_OBJECT_CLASS (nm_device_parent_class)->finalize (object);
}

16
src/devices/wifi/nm-device-olpc-mesh.c
View file

@ -150,12 +150,9 @@ complete_connection (NMDevice *device,
}
if (!nm_setting_olpc_mesh_get_dhcp_anycast_address (s_mesh)) {
const guint8 anycast[ETH_ALEN] = { 0xC0, 0x27, 0xC0, 0x27, 0xC0, 0x27 };
const char *anycast = "c0:27:c0:27:c0:27";
tmp = g_byte_array_sized_new (ETH_ALEN);
g_byte_array_append (tmp, anycast, sizeof (anycast));
g_object_set (G_OBJECT (s_mesh), NM_SETTING_OLPC_MESH_DHCP_ANYCAST_ADDRESS, tmp, NULL);
g_byte_array_free (tmp, TRUE);
g_object_set (G_OBJECT (s_mesh), NM_SETTING_OLPC_MESH_DHCP_ANYCAST_ADDRESS, anycast, NULL);
}
@ -225,8 +222,7 @@ act_stage2_config (NMDevice *device, NMDeviceStateReason *reason)
NMConnection *connection;
NMSettingOlpcMesh *s_mesh;
guint32 channel;
const GByteArray *anycast_addr_array;
guint8 *anycast_addr = NULL;
const char *anycast_addr;
connection = nm_device_get_connection (device);
g_assert (connection);
@ -240,11 +236,9 @@ act_stage2_config (NMDevice *device, NMDeviceStateReason *reason)
nm_platform_mesh_set_ssid (nm_device_get_ifindex (device),
nm_setting_olpc_mesh_get_ssid (s_mesh));
anycast_addr_array = nm_setting_olpc_mesh_get_dhcp_anycast_address (s_mesh);
if (anycast_addr_array)
anycast_addr = anycast_addr_array->data;
anycast_addr = nm_setting_olpc_mesh_get_dhcp_anycast_address (s_mesh);
nm_device_set_dhcp_anycast_address (device, anycast_addr);
return NM_ACT_STAGE_RETURN_SUCCESS;
}

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

@ -116,8 +116,8 @@ static guint signals[LAST_SIGNAL] = { 0 };
struct _NMDeviceWifiPrivate {
gboolean disposed;
char * perm_hw_addr; /* Permanent MAC address */
guint8 initial_hw_addr[ETH_ALEN]; /* Initial MAC address (as seen when NM starts) */
char * perm_hw_addr; /* Permanent MAC address */
char * initial_hw_addr; /* Initial MAC address (as seen when NM starts) */
gint8 invalid_strength_counter;
@ -377,7 +377,7 @@ find_active_ap (NMDeviceWifi *self,
_LOGD (LOGD_WIFI, "active BSSID: %02x:%02x:%02x:%02x:%02x:%02x",
bssid[0], bssid[1], bssid[2], bssid[3], bssid[4], bssid[5]);
if (!nm_ethernet_address_is_valid (bssid))
if (!nm_ethernet_address_is_valid (bssid, ETH_ALEN))
return NULL;
ssid = nm_platform_wifi_get_ssid (ifindex);
@ -399,24 +399,23 @@ find_active_ap (NMDeviceWifi *self,
/* Find this SSID + BSSID in the device's AP list */
for (iter = priv->ap_list; iter; iter = g_slist_next (iter)) {
NMAccessPoint *ap = NM_AP (iter->data);
const guint8 *ap_bssid = nm_ap_get_address (ap);
const char *ap_bssid = nm_ap_get_address (ap);
const GByteArray *ap_ssid = nm_ap_get_ssid (ap);
NM80211Mode apmode;
guint32 apfreq;
_LOGD (LOGD_WIFI, " AP: %s%s%s %02x:%02x:%02x:%02x:%02x:%02x",
_LOGD (LOGD_WIFI, " AP: %s%s%s %s",
ap_ssid ? "'" : "",
ap_ssid ? nm_utils_escape_ssid (ap_ssid->data, ap_ssid->len) : "(none)",
ap_ssid ? "'" : "",
ap_bssid[0], ap_bssid[1], ap_bssid[2],
ap_bssid[3], ap_bssid[4], ap_bssid[5]);
ap_bssid);
if (ap == ignore_ap) {
_LOGD (LOGD_WIFI, " ignored");
continue;
}
if (!nm_utils_hwaddr_matches (bssid, ETH_ALEN, ap_bssid, ETH_ALEN)) {
if (!nm_utils_hwaddr_matches (bssid, ETH_ALEN, ap_bssid, -1)) {
_LOGD (LOGD_WIFI, " BSSID mismatch");
continue;
}
@ -468,14 +467,14 @@ find_active_ap (NMDeviceWifi *self,
* we can't match the AP based on frequency at all, just give up.
*/
if (match_nofreq && ((found_a_band != found_bg_band) || (devfreq == 0))) {
const guint8 *ap_bssid = nm_ap_get_address (match_nofreq);
const char *ap_bssid = nm_ap_get_address (match_nofreq);
const GByteArray *ap_ssid = nm_ap_get_ssid (match_nofreq);
_LOGD (LOGD_WIFI, " matched %s%s%s %02x:%02x:%02x:%02x:%02x:%02x",
_LOGD (LOGD_WIFI, " matched %s%s%s %s",
ap_ssid ? "'" : "",
ap_ssid ? nm_utils_escape_ssid (ap_ssid->data, ap_ssid->len) : "(none)",
ap_ssid ? "'" : "",
ap_bssid[0], ap_bssid[1], ap_bssid[2], ap_bssid[3], ap_bssid[4], ap_bssid[5]);
ap_bssid);
active_ap = match_nofreq;
goto done;
@ -602,8 +601,11 @@ periodic_update (NMDeviceWifi *self, NMAccessPoint *ignore_ap)
/* 0x02 means "locally administered" and should be OR-ed into
* the first byte of IBSS BSSIDs.
*/
if ((bssid[0] & 0x02) && nm_ethernet_address_is_valid (bssid))
nm_ap_set_address (priv->current_ap, bssid);
if ((bssid[0] & 0x02) && nm_ethernet_address_is_valid (bssid, ETH_ALEN)) {
char *bssid_str = nm_utils_hwaddr_ntoa (bssid, ETH_ALEN);
nm_ap_set_address (priv->current_ap, bssid_str);
g_free (bssid_str);
}
}
new_ap = find_active_ap (self, ignore_ap, FALSE);
@ -619,31 +621,26 @@ periodic_update (NMDeviceWifi *self, NMAccessPoint *ignore_ap)
}
if (new_ap != priv->current_ap) {
const guint8 *new_bssid = NULL;
const char *new_bssid = NULL;
const GByteArray *new_ssid = NULL;
const guint8 *old_bssid = NULL;
const char *old_bssid = NULL;
const GByteArray *old_ssid = NULL;
char *old_addr = NULL, *new_addr = NULL;
if (new_ap) {
new_bssid = nm_ap_get_address (new_ap);
new_addr = nm_utils_hwaddr_ntoa (new_bssid, ETH_ALEN);
new_ssid = nm_ap_get_ssid (new_ap);
}
if (priv->current_ap) {
old_bssid = nm_ap_get_address (priv->current_ap);
old_addr = nm_utils_hwaddr_ntoa (old_bssid, ETH_ALEN);
old_ssid = nm_ap_get_ssid (priv->current_ap);
}
_LOGI (LOGD_WIFI, "roamed from BSSID %s (%s) to %s (%s)",
old_addr ? old_addr : "(none)",
old_bssid ? old_bssid : "(none)",
old_ssid ? nm_utils_escape_ssid (old_ssid->data, old_ssid->len) : "(none)",
new_addr ? new_addr : "(none)",
new_bssid ? new_bssid : "(none)",
new_ssid ? nm_utils_escape_ssid (new_ssid->data, new_ssid->len) : "(none)");
g_free (old_addr);
g_free (new_addr);
set_current_ap (self, new_ap, TRUE, FALSE);
}
@ -810,7 +807,7 @@ check_connection_compatible (NMDevice *device, NMConnection *connection)
NMDeviceWifiPrivate *priv = NM_DEVICE_WIFI_GET_PRIVATE (self);
NMSettingConnection *s_con;
NMSettingWireless *s_wireless;
const GByteArray *mac;
const char *mac;
const GSList *mac_blacklist, *mac_blacklist_iter;
const char *mode;
@ -828,21 +825,19 @@ check_connection_compatible (NMDevice *device, NMConnection *connection)
return FALSE;
mac = nm_setting_wireless_get_mac_address (s_wireless);
if (mac && !nm_utils_hwaddr_matches (mac->data, mac->len, priv->perm_hw_addr, -1))
if (mac && !nm_utils_hwaddr_matches (mac, -1, priv->perm_hw_addr, -1))
return FALSE;
/* Check for MAC address blacklist */
mac_blacklist = nm_setting_wireless_get_mac_address_blacklist (s_wireless);
for (mac_blacklist_iter = mac_blacklist; mac_blacklist_iter;
mac_blacklist_iter = g_slist_next (mac_blacklist_iter)) {
guint8 addr[ETH_ALEN];
if (!nm_utils_hwaddr_aton (mac_blacklist_iter->data, addr, ETH_ALEN)) {
if (!nm_utils_hwaddr_valid (mac_blacklist_iter->data, ETH_ALEN)) {
g_warn_if_reached ();
return FALSE;
}
if (nm_utils_hwaddr_matches (addr, ETH_ALEN, priv->perm_hw_addr, -1))
if (nm_utils_hwaddr_matches (mac_blacklist_iter->data, -1, priv->perm_hw_addr, -1))
return FALSE;
}
@ -980,7 +975,7 @@ complete_connection (NMDevice *device,
NMSettingWireless *s_wifi;
NMSettingWirelessSecurity *s_wsec;
NMSetting8021x *s_8021x;
const GByteArray *setting_mac;
const char *setting_mac;
char *str_ssid = NULL;
NMAccessPoint *ap = NULL;
const GByteArray *ssid = NULL;
@ -1119,7 +1114,7 @@ complete_connection (NMDevice *device,
setting_mac = nm_setting_wireless_get_mac_address (s_wifi);
if (setting_mac) {
/* Make sure the setting MAC (if any) matches the device's permanent MAC */
if (!nm_utils_hwaddr_matches (setting_mac->data, setting_mac->len, priv->perm_hw_addr, -1)) {
if (!nm_utils_hwaddr_matches (setting_mac, -1, priv->perm_hw_addr, -1)) {
g_set_error (error,
NM_SETTING_WIRELESS_ERROR,
NM_SETTING_WIRELESS_ERROR_INVALID_PROPERTY,
@ -1127,7 +1122,6 @@ complete_connection (NMDevice *device,
return FALSE;
}
} else {
GByteArray *mac;
guint8 perm_hw_addr[ETH_ALEN];
/* Lock the connection to this device by default if it uses a
@ -1136,9 +1130,9 @@ complete_connection (NMDevice *device,
nm_utils_hwaddr_aton (priv->perm_hw_addr, perm_hw_addr, ETH_ALEN);
if ( !(perm_hw_addr[0] & 0x02)
&& !nm_utils_hwaddr_matches (perm_hw_addr, ETH_ALEN, NULL, ETH_ALEN)) {
mac = nm_utils_hwaddr_atoba (priv->perm_hw_addr, ETH_ALEN);
g_object_set (G_OBJECT (s_wifi), NM_SETTING_WIRELESS_MAC_ADDRESS, mac, NULL);
g_byte_array_free (mac, TRUE);
g_object_set (G_OBJECT (s_wifi),
NM_SETTING_WIRELESS_MAC_ADDRESS, priv->perm_hw_addr,
NULL);
}
}
@ -1389,7 +1383,6 @@ scanning_allowed (NMDeviceWifi *self)
if (connection) {
NMSettingWireless *s_wifi;
const char *ip4_method = NULL;
const GByteArray *bssid;
/* Don't scan when a shared connection is active; it makes drivers mad */
ip4_method = nm_utils_get_ip_config_method (connection, NM_TYPE_SETTING_IP4_CONFIG);
@ -1403,8 +1396,7 @@ scanning_allowed (NMDeviceWifi *self)
*/
s_wifi = nm_connection_get_setting_wireless (connection);
g_assert (s_wifi);
bssid = nm_setting_wireless_get_bssid (s_wifi);
if (bssid && bssid->len == ETH_ALEN)
if (nm_setting_wireless_get_bssid (s_wifi))
return FALSE;
}
@ -1639,7 +1631,7 @@ supplicant_iface_scan_done_cb (NMSupplicantInterface *iface,
static void
try_fill_ssid_for_hidden_ap (NMAccessPoint *ap)
{
const guint8 *bssid;
const char *bssid;
const GSList *connections, *iter;
g_return_if_fail (nm_ap_get_ssid (ap) == NULL);
@ -1664,9 +1656,6 @@ try_fill_ssid_for_hidden_ap (NMAccessPoint *ap)
}
}
#define MAC_FMT "%02x:%02x:%02x:%02x:%02x:%02x"
#define MAC_ARG(x) ((guint8*)(x))[0],((guint8*)(x))[1],((guint8*)(x))[2],((guint8*)(x))[3],((guint8*)(x))[4],((guint8*)(x))[5]
/*
* merge_scanned_ap
*
@ -1686,7 +1675,7 @@ merge_scanned_ap (NMDeviceWifi *self,
NMDeviceWifiPrivate *priv = NM_DEVICE_WIFI_GET_PRIVATE (self);
NMAccessPoint *found_ap = NULL;
const GByteArray *ssid;
const guint8 *bssid;
const char *bssid;
gboolean strict_match = TRUE;
/* Let the manager try to fill in the SSID from seen-bssids lists */
@ -1699,14 +1688,13 @@ merge_scanned_ap (NMDeviceWifi *self,
ssid = nm_ap_get_ssid (merge_ap);
if (ssid && (nm_utils_is_empty_ssid (ssid->data, ssid->len) == FALSE)) {
/* Yay, matched it, no longer treat as hidden */
_LOGD (LOGD_WIFI_SCAN, "matched hidden AP " MAC_FMT " => '%s'",
MAC_ARG (bssid),
nm_utils_escape_ssid (ssid->data, ssid->len));
_LOGD (LOGD_WIFI_SCAN, "matched hidden AP %s => '%s'",
bssid, nm_utils_escape_ssid (ssid->data, ssid->len));
nm_ap_set_broadcast (merge_ap, FALSE);
} else {
/* Didn't have an entry for this AP in the database */
_LOGD (LOGD_WIFI_SCAN, "failed to match hidden AP " MAC_FMT,
MAC_ARG (bssid));
_LOGD (LOGD_WIFI_SCAN, "failed to match hidden AP %s",
bssid);
}
}
@ -1723,9 +1711,9 @@ merge_scanned_ap (NMDeviceWifi *self,
if (!found_ap)
found_ap = nm_ap_match_in_list (merge_ap, priv->ap_list, strict_match);
if (found_ap) {
_LOGD (LOGD_WIFI_SCAN, "merging AP '%s' " MAC_FMT " (%p) with existing (%p)",
_LOGD (LOGD_WIFI_SCAN, "merging AP '%s' %s (%p) with existing (%p)",
ssid ? nm_utils_escape_ssid (ssid->data, ssid->len) : "(none)",
MAC_ARG (bssid),
bssid,
merge_ap,
found_ap);
@ -1745,10 +1733,9 @@ merge_scanned_ap (NMDeviceWifi *self,
nm_ap_set_fake (found_ap, FALSE);
} else {
/* New entry in the list */
_LOGD (LOGD_WIFI_SCAN, "adding new AP '%s' " MAC_FMT " (%p)",
_LOGD (LOGD_WIFI_SCAN, "adding new AP '%s' %s (%p)",
ssid ? nm_utils_escape_ssid (ssid->data, ssid->len) : "(none)",
MAC_ARG (bssid),
merge_ap);
bssid, merge_ap);
g_object_ref (merge_ap);
priv->ap_list = g_slist_prepend (priv->ap_list, merge_ap);
@ -1804,14 +1791,14 @@ cull_scan_list (NMDeviceWifi *self)
/* Remove outdated APs */
for (elt = outdated_list; elt; elt = g_slist_next (elt)) {
NMAccessPoint *outdated_ap = NM_AP (elt->data);
const guint8 *bssid;
const char *bssid;
const GByteArray *ssid;
bssid = nm_ap_get_address (outdated_ap);
ssid = nm_ap_get_ssid (outdated_ap);
_LOGD (LOGD_WIFI_SCAN,
" removing %02x:%02x:%02x:%02x:%02x:%02x (%s%s%s)",
bssid[0], bssid[1], bssid[2], bssid[3], bssid[4], bssid[5],
" removing %s (%s%s%s)",
bssid,
ssid ? "'" : "",
ssid ? nm_utils_escape_ssid (ssid->data, ssid->len) : "(none)",
ssid ? "'" : "");
@ -2533,7 +2520,7 @@ update_permanent_hw_address (NMDevice *device)
errno = 0;
ret = ioctl (fd, SIOCETHTOOL, &req);
errsv = errno;
if ((ret < 0) || !nm_ethernet_address_is_valid (epaddr->data)) {
if ((ret < 0) || !nm_ethernet_address_is_valid (epaddr->data, ETH_ALEN)) {
_LOGD (LOGD_HW | LOGD_ETHER, "unable to read permanent MAC address (error %d)",
errsv);
/* Fall back to current address */
@ -2551,15 +2538,13 @@ update_initial_hw_address (NMDevice *device)
{
NMDeviceWifi *self = NM_DEVICE_WIFI (device);
NMDeviceWifiPrivate *priv = NM_DEVICE_WIFI_GET_PRIVATE (self);
const char *mac_str;
/* This sets initial MAC address from current MAC address. It should only
* be called from NMDevice constructor() to really get the initial address.
*/
mac_str = nm_device_get_hw_address (device);
nm_utils_hwaddr_aton (mac_str, priv->initial_hw_addr, ETH_ALEN);
priv->initial_hw_addr = g_strdup (nm_device_get_hw_address (device));
_LOGD (LOGD_DEVICE | LOGD_ETHER, "read initial MAC address %s", mac_str);
_LOGD (LOGD_DEVICE | LOGD_ETHER, "read initial MAC address %s", priv->initial_hw_addr);
}
static NMActStageReturn
@ -2572,7 +2557,7 @@ act_stage1_prepare (NMDevice *device, NMDeviceStateReason *reason)
NMActRequest *req;
NMConnection *connection;
NMSettingWireless *s_wireless;
const GByteArray *cloned_mac;
const char *cloned_mac;
GSList *iter;
const char *mode;
const char *ap_path;
@ -2615,8 +2600,8 @@ act_stage1_prepare (NMDevice *device, NMDeviceStateReason *reason)
/* Set spoof MAC to the interface */
cloned_mac = nm_setting_wireless_get_cloned_mac_address (s_wireless);
if (cloned_mac && (cloned_mac->len == ETH_ALEN))
nm_device_set_hw_addr (device, (const guint8 *) cloned_mac->data, "set", LOGD_WIFI);
if (cloned_mac)
nm_device_set_hw_addr (device, cloned_mac, "set", LOGD_WIFI);
/* AP mode never uses a specific object or existing scanned AP */
if (priv->mode != NM_802_11_MODE_AP) {
@ -2653,12 +2638,8 @@ act_stage1_prepare (NMDevice *device, NMDeviceStateReason *reason)
if (nm_ap_get_mode (ap) == NM_802_11_MODE_INFRA)
nm_ap_set_broadcast (ap, FALSE);
else if (nm_ap_is_hotspot (ap)) {
guint8 addr[ETH_ALEN];
nm_utils_hwaddr_aton (nm_device_get_hw_address (device), addr, ETH_ALEN);
nm_ap_set_address (ap, addr);
}
else if (nm_ap_is_hotspot (ap))
nm_ap_set_address (ap, nm_device_get_hw_address (device));
priv->ap_list = g_slist_prepend (priv->ap_list, ap);
nm_ap_export_to_dbus (ap);
@ -3021,8 +3002,11 @@ activation_success_handler (NMDevice *device)
* the BSSID off the card and fill in the BSSID of the activation AP.
*/
nm_platform_wifi_get_bssid (ifindex, bssid);
if (!nm_ethernet_address_is_valid (nm_ap_get_address (ap)))
nm_ap_set_address (ap, bssid);
if (!nm_ethernet_address_is_valid (nm_ap_get_address (ap), -1)) {
char *bssid_str = nm_utils_hwaddr_ntoa (bssid, ETH_ALEN);
nm_ap_set_address (ap, bssid_str);
g_free (bssid_str);
}
if (!nm_ap_get_freq (ap))
nm_ap_set_freq (ap, nm_platform_wifi_get_frequency (ifindex));
if (!nm_ap_get_max_bitrate (ap))
@ -3255,6 +3239,7 @@ finalize (GObject *object)
NMDeviceWifiPrivate *priv = NM_DEVICE_WIFI_GET_PRIVATE (self);
g_free (priv->perm_hw_addr);
g_free (priv->initial_hw_addr);
G_OBJECT_CLASS (nm_device_wifi_parent_class)->finalize (object);
}

10
src/devices/wifi/nm-wifi-ap-utils.c
View file

@ -466,7 +466,7 @@ verify_adhoc (NMSettingWirelessSecurity *s_wsec,
gboolean
nm_ap_utils_complete_connection (const GByteArray *ap_ssid,
const guint8 *ap_bssid,
const char *bssid,
NM80211Mode ap_mode,
guint32 ap_flags,
guint32 ap_wpa_flags,
@ -500,14 +500,8 @@ nm_ap_utils_complete_connection (const GByteArray *ap_ssid,
return FALSE;
}
if (lock_bssid && !nm_setting_wireless_get_bssid (s_wifi)) {
GByteArray *bssid;
bssid = g_byte_array_sized_new (ETH_ALEN);
g_byte_array_append (bssid, ap_bssid, ETH_ALEN);
if (lock_bssid && !nm_setting_wireless_get_bssid (s_wifi))
g_object_set (G_OBJECT (s_wifi), NM_SETTING_WIRELESS_BSSID, bssid, NULL);
g_byte_array_free (bssid, TRUE);
}
/* And mode */
mode = nm_setting_wireless_get_mode (s_wifi);

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

@ -29,7 +29,7 @@
#include <nm-setting-8021x.h>
gboolean nm_ap_utils_complete_connection (const GByteArray *ssid,
const guint8 *bssid,
const char *bssid,
NM80211Mode mode,
guint32 flags,
guint32 wpa_flags,

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

@ -44,7 +44,7 @@ typedef struct
/* Scanned or cached values */
GByteArray * ssid;
guint8 address[ETH_ALEN];
char * address;
NM80211Mode mode;
gint8 strength;
guint32 freq; /* Frequency in MHz; ie 2412 (== 2.412 GHz) */
@ -101,6 +101,7 @@ finalize (GObject *object)
g_free (priv->supplicant_path);
if (priv->ssid)
g_byte_array_free (priv->ssid, TRUE);
g_free (priv->address);
G_OBJECT_CLASS (nm_ap_parent_class)->finalize (object);
}
@ -175,7 +176,7 @@ get_property (GObject *object, guint prop_id,
g_value_set_uint (value, priv->freq);
break;
case PROP_HW_ADDRESS:
g_value_take_string (value, nm_utils_hwaddr_ntoa (&priv->address, ETH_ALEN));
g_value_set_string (value, priv->address);
break;
case PROP_MODE:
g_value_set_uint (value, priv->mode);
@ -407,9 +408,13 @@ foreach_property_cb (gpointer key, gpointer value, gpointer user_data)
nm_ap_set_ssid (ap, ssid);
g_byte_array_free (ssid, TRUE);
} else if (!strcmp (key, "BSSID")) {
char *addr;
if (array->len != ETH_ALEN)
return;
nm_ap_set_address (ap, (guint8 *) array->data);
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;
@ -469,7 +474,7 @@ NMAccessPoint *
nm_ap_new_from_properties (const char *supplicant_path, GHashTable *properties)
{
NMAccessPoint *ap;
const guint8 *addr;
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 };
@ -484,8 +489,8 @@ nm_ap_new_from_properties (const char *supplicant_path, GHashTable *properties)
/* ignore APs with invalid BSSIDs */
addr = nm_ap_get_address (ap);
if ( !(memcmp (addr, bad_bssid1, ETH_ALEN))
|| !(memcmp (addr, bad_bssid2, ETH_ALEN))) {
if ( nm_utils_hwaddr_matches (addr, -1, bad_bssid1, ETH_ALEN)
|| nm_utils_hwaddr_matches (addr, -1, bad_bssid2, ETH_ALEN)) {
g_object_unref (ap);
return NULL;
}
@ -706,10 +711,6 @@ error:
return NULL;
}
#define MAC_FMT "%02x:%02x:%02x:%02x:%02x:%02x"
#define MAC_ARG(x) ((guint8*)(x))[0],((guint8*)(x))[1],((guint8*)(x))[2],((guint8*)(x))[3],((guint8*)(x))[4],((guint8*)(x))[5]
void
nm_ap_dump (NMAccessPoint *ap, const char *prefix)
{
@ -723,7 +724,7 @@ nm_ap_dump (NMAccessPoint *ap, const char *prefix)
prefix,
priv->ssid ? nm_utils_escape_ssid (priv->ssid->data, priv->ssid->len) : "(none)",
ap);
nm_log_dbg (LOGD_WIFI_SCAN, " BSSID " MAC_FMT, MAC_ARG (priv->address));
nm_log_dbg (LOGD_WIFI_SCAN, " BSSID %s", priv->address);
nm_log_dbg (LOGD_WIFI_SCAN, " mode %d", priv->mode);
nm_log_dbg (LOGD_WIFI_SCAN, " flags 0x%X", priv->flags);
nm_log_dbg (LOGD_WIFI_SCAN, " wpa flags 0x%X", priv->wpa_flags);
@ -883,7 +884,7 @@ nm_ap_set_rsn_flags (NMAccessPoint *ap, NM80211ApSecurityFlags flags)
* Get/set functions for address
*
*/
const guint8 *
const char *
nm_ap_get_address (const NMAccessPoint *ap)
{
g_return_val_if_fail (NM_IS_AP (ap), NULL);
@ -892,17 +893,19 @@ nm_ap_get_address (const NMAccessPoint *ap)
}
void
nm_ap_set_address (NMAccessPoint *ap, const guint8 *addr)
nm_ap_set_address (NMAccessPoint *ap, const char *addr)
{
NMAccessPointPrivate *priv;
g_return_if_fail (NM_IS_AP (ap));
g_return_if_fail (addr != NULL);
g_return_if_fail (nm_utils_hwaddr_valid (addr, ETH_ALEN));
priv = NM_AP_GET_PRIVATE (ap);
if (!nm_utils_hwaddr_matches (addr, ETH_ALEN, priv->address, sizeof (priv->address))) {
memcpy (NM_AP_GET_PRIVATE (ap)->address, addr, sizeof (priv->address));
if (!priv->address || !nm_utils_hwaddr_matches (addr, -1, priv->address, -1)) {
g_free (priv->address);
priv->address = g_strdup (addr);
g_object_notify (G_OBJECT (ap), NM_AP_HW_ADDRESS);
}
}
@ -1108,7 +1111,7 @@ nm_ap_check_compatible (NMAccessPoint *self,
NMSettingWirelessSecurity *s_wireless_sec;
const char *mode;
const char *band;
const GByteArray *bssid;
const char *bssid;
guint32 channel;
g_return_val_if_fail (NM_IS_AP (self), FALSE);
@ -1124,7 +1127,7 @@ nm_ap_check_compatible (NMAccessPoint *self,
return FALSE;
bssid = nm_setting_wireless_get_bssid (s_wireless);
if (bssid && !nm_utils_hwaddr_matches (bssid->data, bssid->len, priv->address, ETH_ALEN))
if (bssid && !nm_utils_hwaddr_matches (bssid, -1, priv->address, -1))
return FALSE;
mode = nm_setting_wireless_get_mode (s_wireless);
@ -1221,10 +1224,10 @@ nm_ap_match_in_list (NMAccessPoint *find_ap,
for (iter = ap_list; iter; iter = g_slist_next (iter)) {
NMAccessPoint * list_ap = NM_AP (iter->data);
const GByteArray * list_ssid = nm_ap_get_ssid (list_ap);
const guint8 * list_addr = nm_ap_get_address (list_ap);
const char * list_addr = nm_ap_get_address (list_ap);
const GByteArray * find_ssid = nm_ap_get_ssid (find_ap);
const guint8 * find_addr = nm_ap_get_address (find_ap);
const char * find_addr = nm_ap_get_address (find_ap);
/* SSID match; if both APs are hiding their SSIDs,
* let matching continue on BSSID and other properties
@ -1235,9 +1238,9 @@ nm_ap_match_in_list (NMAccessPoint *find_ap,
continue;
/* BSSID match */
if ( (strict_match || nm_ethernet_address_is_valid (find_addr))
&& nm_ethernet_address_is_valid (list_addr)
&& !nm_utils_hwaddr_matches (list_addr, ETH_ALEN, find_addr, ETH_ALEN))
if ( (strict_match || nm_ethernet_address_is_valid (find_addr, -1))
&& nm_ethernet_address_is_valid (list_addr, -1)
&& !nm_utils_hwaddr_matches (list_addr, -1, find_addr, -1))
continue;
/* mode match */

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

@ -78,8 +78,8 @@ void nm_ap_set_wpa_flags (NMAccessPoint *ap, NM80211ApSecurity
NM80211ApSecurityFlags nm_ap_get_rsn_flags (NMAccessPoint *ap);
void nm_ap_set_rsn_flags (NMAccessPoint *ap, NM80211ApSecurityFlags flags);
const guint8 *nm_ap_get_address (const NMAccessPoint *ap);
void nm_ap_set_address (NMAccessPoint *ap, const guint8 *addr);
const char *nm_ap_get_address (const NMAccessPoint *ap);
void nm_ap_set_address (NMAccessPoint *ap, const char *addr);
NM80211Mode nm_ap_get_mode (NMAccessPoint *ap);
void nm_ap_set_mode (NMAccessPoint *ap, const NM80211Mode mode);

46
src/devices/wifi/tests/test-wifi-ap-utils.c
View file

@ -67,7 +67,7 @@
static gboolean
complete_connection (const char *ssid,
const guint8 bssid[ETH_ALEN],
const char *bssid,
NM80211Mode mode,
guint32 flags,
guint32 wpa_flags,
@ -218,7 +218,7 @@ fill_8021x (NMConnection *connection, const KeyData items[])
static NMConnection *
create_basic (const char *ssid,
const guint8 *bssid,
const char *bssid,
NM80211Mode mode)
{
NMConnection *connection;
@ -237,12 +237,8 @@ create_basic (const char *ssid,
g_byte_array_free (tmp, TRUE);
/* BSSID */
if (bssid) {
tmp = g_byte_array_sized_new (ETH_ALEN);
g_byte_array_append (tmp, bssid, ETH_ALEN);
g_object_set (G_OBJECT (s_wifi), NM_SETTING_WIRELESS_BSSID, tmp, NULL);
g_byte_array_free (tmp, TRUE);
}
if (bssid)
g_object_set (G_OBJECT (s_wifi), NM_SETTING_WIRELESS_BSSID, bssid, NULL);
if (mode == NM_802_11_MODE_INFRA)
g_object_set (G_OBJECT (s_wifi), NM_SETTING_WIRELESS_MODE, "infrastructure", NULL);
@ -260,7 +256,7 @@ static void
test_lock_bssid (void)
{
NMConnection *src, *expected;
const guint8 bssid[ETH_ALEN] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 };
const char *bssid = "01:02:03:04:05:06";
const char *ssid = "blahblah";
gboolean success;
GError *error = NULL;
@ -284,7 +280,7 @@ static void
test_open_ap_empty_connection (void)
{
NMConnection *src, *expected;
const guint8 bssid[ETH_ALEN] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 };
const char *bssid = "01:02:03:04:05:06";
const char *ssid = "blahblah";
gboolean success;
GError *error = NULL;
@ -312,7 +308,7 @@ static void
test_open_ap_leap_connection_1 (gconstpointer add_wifi)
{
NMConnection *src;
const guint8 bssid[ETH_ALEN] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 };
const char *bssid = "01:02:03:04:05:06";
const KeyData src_wsec[] = { { NM_SETTING_WIRELESS_SECURITY_LEAP_USERNAME, "Bill Smith", 0 }, { NULL } };
gboolean success;
GError *error = NULL;
@ -344,7 +340,7 @@ static void
test_open_ap_leap_connection_2 (void)
{
NMConnection *src;
const guint8 bssid[ETH_ALEN] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 };
const char *bssid = "01:02:03:04:05:06";
const KeyData src_wsec[] = { { NM_SETTING_WIRELESS_SECURITY_KEY_MGMT, "ieee8021x", 0 }, { NULL } };
gboolean success;
GError *error = NULL;
@ -374,7 +370,7 @@ static void
test_open_ap_wep_connection (gconstpointer add_wifi)
{
NMConnection *src;
const guint8 bssid[ETH_ALEN] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 };
const char *bssid = "01:02:03:04:05:06";
const KeyData src_wsec[] = {
{ NM_SETTING_WIRELESS_SECURITY_WEP_KEY0, "11111111111111111111111111", 0 },
{ NM_SETTING_WIRELESS_SECURITY_WEP_TX_KEYIDX, NULL, 0 },
@ -415,7 +411,7 @@ test_ap_wpa_psk_connection_base (const char *key_mgmt,
{
NMConnection *src;
const char *ssid = "blahblah";
const guint8 bssid[ETH_ALEN] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 };
const char *bssid = "01:02:03:04:05:06";
const KeyData exp_wifi[] = {
{ NM_SETTING_WIRELESS_SSID, ssid, 0 },
{ NM_SETTING_WIRELESS_MODE, "infrastructure", 0 },
@ -525,7 +521,7 @@ test_ap_wpa_eap_connection_base (const char *key_mgmt,
guint error_code)
{
NMConnection *src;
const guint8 bssid[ETH_ALEN] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 };
const char *bssid = "01:02:03:04:05:06";
const KeyData src_empty[] = { { NULL } };
const KeyData src_wsec[] = {
{ NM_SETTING_WIRELESS_SECURITY_KEY_MGMT, key_mgmt, 0 },
@ -731,7 +727,7 @@ static void
test_priv_ap_empty_connection (void)
{
NMConnection *src, *expected;
const guint8 bssid[ETH_ALEN] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 };
const char *bssid = "01:02:03:04:05:06";
const char *ssid = "blahblah";
const KeyData exp_wsec[] = {
{ NM_SETTING_WIRELESS_SECURITY_KEY_MGMT, "none", 0 },
@ -766,7 +762,7 @@ test_priv_ap_leap_connection_1 (gconstpointer add_wifi)
{
NMConnection *src, *expected;
const char *ssid = "blahblah";
const guint8 bssid[ETH_ALEN] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 };
const char *bssid = "01:02:03:04:05:06";
const char *leap_username = "Bill Smith";
const KeyData src_wsec[] = {
{ NM_SETTING_WIRELESS_SECURITY_KEY_MGMT, "ieee8021x", 0 },
@ -811,7 +807,7 @@ static void
test_priv_ap_leap_connection_2 (void)
{
NMConnection *src;
const guint8 bssid[ETH_ALEN] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 };
const char *bssid = "01:02:03:04:05:06";
const KeyData src_wsec[] = {
{ NM_SETTING_WIRELESS_SECURITY_KEY_MGMT, "ieee8021x", 0 },
{ NM_SETTING_WIRELESS_SECURITY_AUTH_ALG, "leap", 0 },
@ -845,7 +841,7 @@ test_priv_ap_dynamic_wep_1 (void)
{
NMConnection *src, *expected;
const char *ssid = "blahblah";
const guint8 bssid[ETH_ALEN] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 };
const char *bssid = "01:02:03:04:05:06";
const KeyData src_wsec[] = {
{ NM_SETTING_WIRELESS_SECURITY_KEY_MGMT, "ieee8021x", 0 },
{ NM_SETTING_WIRELESS_SECURITY_AUTH_ALG, "open", 0 },
@ -893,7 +889,7 @@ test_priv_ap_dynamic_wep_2 (void)
{
NMConnection *src, *expected;
const char *ssid = "blahblah";
const guint8 bssid[ETH_ALEN] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 };
const char *bssid = "01:02:03:04:05:06";
const KeyData src_wsec[] = {
{ NM_SETTING_WIRELESS_SECURITY_AUTH_ALG, "open", 0 },
{ NULL } };
@ -939,7 +935,7 @@ static void
test_priv_ap_dynamic_wep_3 (void)
{
NMConnection *src;
const guint8 bssid[ETH_ALEN] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 };
const char *bssid = "01:02:03:04:05:06";
const KeyData src_wsec[] = {
{ NM_SETTING_WIRELESS_SECURITY_AUTH_ALG, "shared", 0 },
{ NULL } };
@ -1052,7 +1048,7 @@ test_wpa_ap_empty_connection (gconstpointer data)
{
guint idx = GPOINTER_TO_UINT (data);
NMConnection *src, *expected;
const guint8 bssid[ETH_ALEN] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 };
const char *bssid = "01:02:03:04:05:06";
const char *ssid = "blahblah";
const KeyData exp_wsec[] = {
{ NM_SETTING_WIRELESS_SECURITY_KEY_MGMT, "wpa-psk", 0 },
@ -1090,7 +1086,7 @@ test_wpa_ap_leap_connection_1 (gconstpointer data)
guint idx = GPOINTER_TO_UINT (data);
NMConnection *src;
const char *ssid = "blahblah";
const guint8 bssid[ETH_ALEN] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 };
const char *bssid = "01:02:03:04:05:06";
const char *leap_username = "Bill Smith";
const KeyData src_wsec[] = {
{ NM_SETTING_WIRELESS_SECURITY_KEY_MGMT, "ieee8021x", 0 },
@ -1125,7 +1121,7 @@ test_wpa_ap_leap_connection_2 (gconstpointer data)
{
guint idx = GPOINTER_TO_UINT (data);
NMConnection *src;
const guint8 bssid[ETH_ALEN] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 };
const char *bssid = "01:02:03:04:05:06";
const KeyData src_wsec[] = {
{ NM_SETTING_WIRELESS_SECURITY_KEY_MGMT, "ieee8021x", 0 },
{ NM_SETTING_WIRELESS_SECURITY_AUTH_ALG, "leap", 0 },
@ -1159,7 +1155,7 @@ test_wpa_ap_dynamic_wep_connection (gconstpointer data)
{
guint idx = GPOINTER_TO_UINT (data);
NMConnection *src;
const guint8 bssid[ETH_ALEN] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 };
const char *bssid = "01:02:03:04:05:06";
const KeyData src_wsec[] = {
{ NM_SETTING_WIRELESS_SECURITY_KEY_MGMT, "ieee8021x", 0 },
{ NULL } };

17
src/devices/wimax/nm-device-wimax.c
View file

@ -315,7 +315,7 @@ check_connection_compatible (NMDevice *device, NMConnection *connection)
NMSettingConnection *s_con;
NMSettingWimax *s_wimax;
const char *connection_type;
const GByteArray *mac;
const char *mac;
if (!NM_DEVICE_CLASS (nm_device_wimax_parent_class)->check_connection_compatible (device, connection))
return FALSE;
@ -332,7 +332,7 @@ check_connection_compatible (NMDevice *device, NMConnection *connection)
return FALSE;
mac = nm_setting_wimax_get_mac_address (s_wimax);
if (mac && !nm_utils_hwaddr_matches (mac->data, mac->len, nm_device_get_hw_address (device), -1))
if (mac && !nm_utils_hwaddr_matches (mac, -1, nm_device_get_hw_address (device), -1))
return FALSE;
return TRUE;
@ -371,7 +371,7 @@ complete_connection (NMDevice *device,
NMDeviceWimax *self = NM_DEVICE_WIMAX (device);
NMDeviceWimaxPrivate *priv = NM_DEVICE_WIMAX_GET_PRIVATE (self);
NMSettingWimax *s_wimax;
const GByteArray *setting_mac;
const char *setting_mac;
const char *hw_address;
const char *nsp_name = NULL;
NMWimaxNsp *nsp = NULL;
@ -450,7 +450,7 @@ complete_connection (NMDevice *device,
hw_address = nm_device_get_hw_address (device);
if (setting_mac) {
/* Make sure the setting MAC (if any) matches the device's permanent MAC */
if (!nm_utils_hwaddr_matches (setting_mac->data, setting_mac->len, hw_address, -1)) {
if (!nm_utils_hwaddr_matches (setting_mac, -1, hw_address, -1)) {
g_set_error (error,
NM_SETTING_WIMAX_ERROR,
NM_SETTING_WIMAX_ERROR_INVALID_PROPERTY,
@ -458,14 +458,9 @@ complete_connection (NMDevice *device,
return FALSE;
}
} else {
GByteArray *mac;
/* Lock the connection to this device by default */
if (!nm_utils_hwaddr_matches (hw_address, -1, NULL, ETH_ALEN)) {
mac = nm_utils_hwaddr_atoba (hw_address, ETH_ALEN);
g_object_set (G_OBJECT (s_wimax), NM_SETTING_WIMAX_MAC_ADDRESS, mac, NULL);
g_byte_array_free (mac, TRUE);
}
if (!nm_utils_hwaddr_matches (hw_address, -1, NULL, ETH_ALEN))
g_object_set (G_OBJECT (s_wimax), NM_SETTING_WIMAX_MAC_ADDRESS, hw_address, NULL);
}
return TRUE;

4
src/dhcp-manager/nm-dhcp-client.c
View file

@ -348,7 +348,7 @@ nm_dhcp_client_watch_child (NMDhcpClient *self, pid_t pid)
gboolean
nm_dhcp_client_start_ip4 (NMDhcpClient *self,
const char *dhcp_client_id,
GByteArray *dhcp_anycast_addr,
const char *dhcp_anycast_addr,
const char *hostname)
{
NMDhcpClientPrivate *priv;
@ -480,7 +480,7 @@ get_duid (NMDhcpClient *self)
gboolean
nm_dhcp_client_start_ip6 (NMDhcpClient *self,
GByteArray *dhcp_anycast_addr,
const char *dhcp_anycast_addr,
const char *hostname,
gboolean info_only,
NMSettingIP6ConfigPrivacy privacy)

8
src/dhcp-manager/nm-dhcp-client.h
View file

@ -65,11 +65,11 @@ typedef struct {
gboolean (*ip4_start) (NMDhcpClient *self,
const char *dhcp_client_id,
GByteArray *anycast_addr,
const char *anycast_addr,
const char *hostname);
gboolean (*ip6_start) (NMDhcpClient *self,
GByteArray *anycast_addr,
const char *anycast_addr,
const char *hostname,
gboolean info_only,
NMSettingIP6ConfigPrivacy privacy,
@ -117,11 +117,11 @@ guint32 nm_dhcp_client_get_priority (NMDhcpClient *self);
gboolean nm_dhcp_client_start_ip4 (NMDhcpClient *self,
const char *dhcp_client_id,
GByteArray *dhcp_anycast_addr,
const char *dhcp_anycast_addr,
const char *hostname);
gboolean nm_dhcp_client_start_ip6 (NMDhcpClient *self,
GByteArray *dhcp_anycast_addr,
const char *dhcp_anycast_addr,
const char *hostname,
gboolean info_only,
NMSettingIP6ConfigPrivacy privacy);

18
src/dhcp-manager/nm-dhcp-dhclient-utils.c
View file

@ -129,7 +129,7 @@ char *
nm_dhcp_dhclient_create_config (const char *interface,
gboolean is_ip6,
const char *dhcp_client_id,
GByteArray *anycast_addr,
const char *anycast_addr,
const char *hostname,
const char *orig_path,
const char *orig_contents)
@ -138,6 +138,8 @@ nm_dhcp_dhclient_create_config (const char *interface,
GPtrArray *alsoreq;
int i;
g_return_val_if_fail (!anycast_addr || nm_utils_hwaddr_valid (anycast_addr, ETH_ALEN), NULL);
new_contents = g_string_new (_("# Created by NetworkManager\n"));
alsoreq = g_ptr_array_sized_new (5);
@ -246,22 +248,14 @@ nm_dhcp_dhclient_create_config (const char *interface,
g_string_append_c (new_contents, '\n');
if (anycast_addr && anycast_addr->len == 6) {
const guint8 *p_anycast_addr = anycast_addr->data;
if (anycast_addr) {
g_string_append_printf (new_contents, "interface \"%s\" {\n"
" initial-interval 1; \n"
" anycast-mac ethernet %02x:%02x:%02x:%02x:%02x:%02x;\n"
" anycast-mac ethernet %s;\n"
"}\n",
interface,
p_anycast_addr[0], p_anycast_addr[1],
p_anycast_addr[2], p_anycast_addr[3],
p_anycast_addr[4], p_anycast_addr[5]);
interface, anycast_addr);
}
/* Finally, assert that anycast_addr was unset or a 48 bit mac address. */
g_return_val_if_fail (!anycast_addr || anycast_addr->len == 6, g_string_free (new_contents, FALSE));
return g_string_free (new_contents, FALSE);
}

2
src/dhcp-manager/nm-dhcp-dhclient-utils.h
View file

@ -28,7 +28,7 @@
char *nm_dhcp_dhclient_create_config (const char *interface,
gboolean is_ip6,
const char *dhcp_client_id,
GByteArray *anycast_addr,
const char *anycast_addr,
const char *hostname,
const char *orig_path,
const char *orig_contents);

8
src/dhcp-manager/nm-dhcp-dhclient.c
View file

@ -166,7 +166,7 @@ merge_dhclient_config (const char *iface,
const char *conf_file,
gboolean is_ip6,
const char *dhcp_client_id,
GByteArray *anycast_addr,
const char *anycast_addr,
const char *hostname,
const char *orig_path,
GError **error)
@ -272,7 +272,7 @@ create_dhclient_config (const char *iface,
gboolean is_ip6,
const char *uuid,
const char *dhcp_client_id,
GByteArray *dhcp_anycast_addr,
const char *dhcp_anycast_addr,
const char *hostname)
{
char *orig = NULL, *new = NULL;
@ -482,7 +482,7 @@ dhclient_start (NMDhcpClient *client,
static gboolean
ip4_start (NMDhcpClient *client,
const char *dhcp_client_id,
GByteArray *dhcp_anycast_addr,
const char *dhcp_anycast_addr,
const char *hostname)
{
NMDhcpDhclientPrivate *priv = NM_DHCP_DHCLIENT_GET_PRIVATE (client);
@ -502,7 +502,7 @@ ip4_start (NMDhcpClient *client,
static gboolean
ip6_start (NMDhcpClient *client,
GByteArray *dhcp_anycast_addr,
const char *dhcp_anycast_addr,
const char *hostname,
gboolean info_only,
NMSettingIP6ConfigPrivacy privacy,

4
src/dhcp-manager/nm-dhcp-dhcpcd.c
View file

@ -88,7 +88,7 @@ dhcpcd_child_setup (gpointer user_data G_GNUC_UNUSED)
static gboolean
ip4_start (NMDhcpClient *client,
const char *dhcp_client_id,
GByteArray *dhcp_anycast_addr,
const char *dhcp_anycast_addr,
const char *hostname)
{
NMDhcpDhcpcdPrivate *priv = NM_DHCP_DHCPCD_GET_PRIVATE (client);
@ -171,7 +171,7 @@ ip4_start (NMDhcpClient *client,
static gboolean
ip6_start (NMDhcpClient *client,
GByteArray *dhcp_anycast_addr,
const char *dhcp_anycast_addr,
const char *hostname,
gboolean info_only,
NMSettingIP6ConfigPrivacy privacy,

6
src/dhcp-manager/nm-dhcp-manager.c
View file

@ -377,7 +377,7 @@ client_start (NMDhcpManager *self,
gboolean ipv6,
const char *dhcp_client_id,
guint32 timeout,
GByteArray *dhcp_anycast_addr,
const char *dhcp_anycast_addr,
const char *hostname,
gboolean info_only,
NMSettingIP6ConfigPrivacy privacy)
@ -452,7 +452,7 @@ nm_dhcp_manager_start_ip4 (NMDhcpManager *self,
const char *dhcp_hostname,
const char *dhcp_client_id,
guint32 timeout,
GByteArray *dhcp_anycast_addr)
const char *dhcp_anycast_addr)
{
const char *hostname = NULL;
@ -475,7 +475,7 @@ nm_dhcp_manager_start_ip6 (NMDhcpManager *self,
guint priority,
const char *dhcp_hostname,
guint32 timeout,
GByteArray *dhcp_anycast_addr,
const char *dhcp_anycast_addr,
gboolean info_only,
NMSettingIP6ConfigPrivacy privacy)
{

4
src/dhcp-manager/nm-dhcp-manager.h
View file

@ -71,7 +71,7 @@ NMDhcpClient * nm_dhcp_manager_start_ip4 (NMDhcpManager *manager,
const char *dhcp_hostname,
const char *dhcp_client_id,
guint32 timeout,
GByteArray *dhcp_anycast_addr);
const char *dhcp_anycast_addr);
NMDhcpClient * nm_dhcp_manager_start_ip6 (NMDhcpManager *manager,
const char *iface,
@ -81,7 +81,7 @@ NMDhcpClient * nm_dhcp_manager_start_ip6 (NMDhcpManager *manager,
guint priority,
const char *dhcp_hostname,
guint32 timeout,
GByteArray *dhcp_anycast_addr,
const char *dhcp_anycast_addr,
gboolean info_only,
NMSettingIP6ConfigPrivacy privacy);

2
src/dhcp-manager/tests/test-dhcp-dhclient.c
View file

@ -35,7 +35,7 @@ test_config (const char *orig,
const char *hostname,
const char *dhcp_client_id,
const char *iface,
GByteArray *anycast_addr)
const char *anycast_addr)
{
char *new;

8
src/nm-manager.c
View file

@ -842,7 +842,7 @@ nm_manager_get_state (NMManager *manager)
/*******************************************************************/
static NMDevice *
get_device_from_hwaddr (NMManager *self, const GByteArray *setting_mac)
get_device_from_hwaddr (NMManager *self, const char *setting_mac)
{
NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
const char *device_mac;
@ -857,7 +857,7 @@ get_device_from_hwaddr (NMManager *self, const GByteArray *setting_mac)
device_mac = nm_device_get_hw_address (iter->data);
if (!device_mac)
continue;
if (nm_utils_hwaddr_matches (setting_mac->data, setting_mac->len, device_mac, -1))
if (nm_utils_hwaddr_matches (setting_mac, -1, device_mac, -1))
return device;
}
return NULL;
@ -873,7 +873,7 @@ find_vlan_parent (NMManager *self,
NMConnection *parent_connection;
const char *parent_iface;
NMDevice *parent = NULL;
const GByteArray *setting_mac;
const char *setting_mac;
GSList *iter;
/* The 'parent' property could be given by an interface name, a
@ -926,7 +926,7 @@ find_infiniband_parent (NMManager *self,
NMSettingInfiniband *s_infiniband;
const char *parent_iface;
NMDevice *parent = NULL;
const GByteArray *setting_mac;
const char *setting_mac;
s_infiniband = nm_connection_get_setting_infiniband (connection);
g_return_val_if_fail (s_infiniband != NULL, NULL);

59
src/settings/nm-settings-connection.c
View file

@ -1703,31 +1703,6 @@ nm_settings_connection_read_and_fill_timestamp (NMSettingsConnection *connection
g_key_file_free (timestamps_file);
}
static guint
mac_hash (gconstpointer v)
{
const guint8 *p = v;
guint32 i, h = 5381;
for (i = 0; i < ETH_ALEN; i++)
h = (h << 5) + h + p[i];
return h;
}
static gboolean
mac_equal (gconstpointer a, gconstpointer b)
{
return memcmp (a, b, ETH_ALEN) == 0;
}
static guint8 *
mac_dup (const guint8 *old)
{
g_return_val_if_fail (old != NULL, NULL);
return g_memdup (old, ETH_ALEN);
}
/**
* nm_settings_connection_get_seen_bssids:
* @connection: the #NMSettingsConnection
@ -1754,7 +1729,7 @@ nm_settings_connection_get_seen_bssids (NMSettingsConnection *connection)
**/
gboolean
nm_settings_connection_has_seen_bssid (NMSettingsConnection *connection,
const guint8 *bssid)
const char *bssid)
{
g_return_val_if_fail (NM_IS_SETTINGS_CONNECTION (connection), FALSE);
g_return_val_if_fail (bssid != NULL, FALSE);
@ -1772,7 +1747,7 @@ nm_settings_connection_has_seen_bssid (NMSettingsConnection *connection,
**/
void
nm_settings_connection_add_seen_bssid (NMSettingsConnection *connection,
const guint8 *seen_bssid)
const char *seen_bssid)
{
NMSettingsConnectionPrivate *priv = NM_SETTINGS_CONNECTION_GET_PRIVATE (connection);
const char *connection_uuid;
@ -1790,8 +1765,8 @@ nm_settings_connection_add_seen_bssid (NMSettingsConnection *connection,
return; /* Already in the list */
/* Add the new BSSID; let the hash take ownership of the allocated BSSID string */
bssid_str = nm_utils_hwaddr_ntoa (seen_bssid, ETH_ALEN);
g_hash_table_insert (priv->seen_bssids, mac_dup (seen_bssid), bssid_str);
bssid_str = g_strdup (seen_bssid);
g_hash_table_insert (priv->seen_bssids, bssid_str, bssid_str);
/* Build up a list of all the BSSIDs in string form */
n = 0;
@ -1829,19 +1804,6 @@ nm_settings_connection_add_seen_bssid (NMSettingsConnection *connection,
}
}
static void
add_seen_bssid_string (NMSettingsConnection *self, const char *bssid)
{
guint8 mac[ETH_ALEN];
g_return_if_fail (bssid != NULL);
if (nm_utils_hwaddr_aton (bssid, mac, ETH_ALEN)) {
g_hash_table_insert (NM_SETTINGS_CONNECTION_GET_PRIVATE (self)->seen_bssids,
mac_dup (mac),
g_strdup (bssid));
}
}
/**
* nm_settings_connection_read_and_fill_seen_bssids:
* @connection: the #NMSettingsConnection
@ -1872,8 +1834,8 @@ nm_settings_connection_read_and_fill_seen_bssids (NMSettingsConnection *connecti
if (tmp_strv) {
g_hash_table_remove_all (priv->seen_bssids);
for (i = 0; i < len; i++)
add_seen_bssid_string (connection, tmp_strv[i]);
g_strfreev (tmp_strv);
g_hash_table_insert (priv->seen_bssids, tmp_strv[i], tmp_strv[i]);
g_free (tmp_strv);
} else {
/* If this connection didn't have an entry in the seen-bssids database,
* maybe this is the first time we've read it in, so populate the
@ -1883,8 +1845,11 @@ nm_settings_connection_read_and_fill_seen_bssids (NMSettingsConnection *connecti
s_wifi = nm_connection_get_setting_wireless (NM_CONNECTION (connection));
if (s_wifi) {
len = nm_setting_wireless_get_num_seen_bssids (s_wifi);
for (i = 0; i < len; i++)
add_seen_bssid_string (connection, nm_setting_wireless_get_seen_bssid (s_wifi, i));
for (i = 0; i < len; i++) {
char *bssid_dup = g_strdup (nm_setting_wireless_get_seen_bssid (s_wifi, i));
g_hash_table_insert (priv->seen_bssids, bssid_dup, bssid_dup);
}
}
}
}
@ -2011,7 +1976,7 @@ nm_settings_connection_init (NMSettingsConnection *self)
priv->agent_mgr = nm_agent_manager_get ();
priv->seen_bssids = g_hash_table_new_full (mac_hash, mac_equal, g_free, g_free);
priv->seen_bssids = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
priv->autoconnect_retries = AUTOCONNECT_RETRIES_DEFAULT;
priv->autoconnect_blocked_reason = NM_DEVICE_STATE_REASON_NONE;

4
src/settings/nm-settings-connection.h
View file

@ -141,10 +141,10 @@ void nm_settings_connection_read_and_fill_timestamp (NMSettingsConnection *conne
GSList *nm_settings_connection_get_seen_bssids (NMSettingsConnection *connection);
gboolean nm_settings_connection_has_seen_bssid (NMSettingsConnection *connection,
const guint8 *bssid);
const char *bssid);
void nm_settings_connection_add_seen_bssid (NMSettingsConnection *connection,
const guint8 *seen_bssid);
const char *seen_bssid);
void nm_settings_connection_read_and_fill_seen_bssids (NMSettingsConnection *connection);

12
src/settings/nm-settings.c
View file

@ -1472,12 +1472,12 @@ have_connection_for_device (NMSettings *self, NMDevice *device)
gpointer data;
NMSettingConnection *s_con;
NMSettingWired *s_wired;
const GByteArray *setting_mac;
const char *hwaddr;
const char *setting_hwaddr;
const char *device_hwaddr;
g_return_val_if_fail (NM_IS_SETTINGS (self), FALSE);
hwaddr = nm_device_get_hw_address (device);
device_hwaddr = nm_device_get_hw_address (device);
/* Find a wired connection locked to the given MAC address, if any */
g_hash_table_iter_init (&iter, priv->connections);
@ -1505,10 +1505,10 @@ have_connection_for_device (NMSettings *self, NMDevice *device)
g_assert (s_wired != NULL);
setting_mac = nm_setting_wired_get_mac_address (s_wired);
if (setting_mac && hwaddr) {
setting_hwaddr = nm_setting_wired_get_mac_address (s_wired);
if (setting_hwaddr) {
/* A connection mac-locked to this device */
if (nm_utils_hwaddr_matches (setting_mac->data, setting_mac->len, hwaddr, -1))
if (nm_utils_hwaddr_matches (setting_hwaddr, -1, device_hwaddr, -1))
return TRUE;
} else {
/* A connection that applies to any wired device */

11
src/settings/plugins/ibft/reader.c
View file

@ -489,29 +489,26 @@ wired_setting_add_from_block (const GPtrArray *block,
GError **error)
{
NMSetting *s_wired = NULL;
const char *hwaddr_str = NULL;
GByteArray *hwaddr;
const char *hwaddr = NULL;
g_assert (block);
g_assert (connection);
if (!parse_ibft_config (block, NULL, ISCSI_HWADDR_TAG, &hwaddr_str, NULL)) {
if (!parse_ibft_config (block, NULL, ISCSI_HWADDR_TAG, &hwaddr, NULL)) {
g_set_error_literal (error, IBFT_PLUGIN_ERROR, 0,
"iBFT: malformed iscsiadm record: missing " ISCSI_HWADDR_TAG);
return FALSE;
}
hwaddr = nm_utils_hwaddr_atoba (hwaddr_str, ETH_ALEN);
if (!hwaddr) {
if (!nm_utils_hwaddr_valid (hwaddr, ETH_ALEN)) {
g_set_error (error, IBFT_PLUGIN_ERROR, 0,
"iBFT: malformed iscsiadm record: invalid " ISCSI_HWADDR_TAG " '%s'.",
hwaddr_str);
hwaddr);
return FALSE;
}
s_wired = nm_setting_wired_new ();
g_object_set (s_wired, NM_SETTING_WIRED_MAC_ADDRESS, hwaddr, NULL);
g_byte_array_unref (hwaddr);
nm_connection_add_setting (connection, s_wired);
return TRUE;

24
src/settings/plugins/ibft/tests/test-ibft.c
View file

@ -79,7 +79,7 @@ test_read_ibft_dhcp (void)
NMSettingWired *s_wired;
NMSettingIP4Config *s_ip4;
GError *error = NULL;
const GByteArray *array;
const char *mac_address;
const char *expected_mac_address = "00:33:21:98:b9:f1";
GPtrArray *block;
@ -103,9 +103,9 @@ test_read_ibft_dhcp (void)
/* ===== WIRED SETTING ===== */
s_wired = nm_connection_get_setting_wired (connection);
g_assert (s_wired);
array = nm_setting_wired_get_mac_address (s_wired);
g_assert (array);
nmtst_assert_hwaddr_equals (array->data, array->len, expected_mac_address);
mac_address = nm_setting_wired_get_mac_address (s_wired);
g_assert (mac_address);
g_assert (nm_utils_hwaddr_matches (mac_address, -1, expected_mac_address, -1));
g_assert_cmpint (nm_setting_wired_get_mtu (s_wired), ==, 0);
/* ===== IPv4 SETTING ===== */
@ -124,7 +124,7 @@ test_read_ibft_static (void)
NMSettingWired *s_wired;
NMSettingIP4Config *s_ip4;
GError *error = NULL;
const GByteArray *array;
const char *mac_address;
const char *expected_mac_address = "00:33:21:98:b9:f0";
NMIP4Address *ip4_addr;
GPtrArray *block;
@ -149,9 +149,9 @@ test_read_ibft_static (void)
/* ===== WIRED SETTING ===== */
s_wired = nm_connection_get_setting_wired (connection);
g_assert (s_wired);
array = nm_setting_wired_get_mac_address (s_wired);
g_assert (array);
nmtst_assert_hwaddr_equals (array->data, array->len, expected_mac_address);
mac_address = nm_setting_wired_get_mac_address (s_wired);
g_assert (mac_address);
g_assert (nm_utils_hwaddr_matches (mac_address, -1, expected_mac_address, -1));
g_assert_cmpint (nm_setting_wired_get_mtu (s_wired), ==, 0);
/* ===== IPv4 SETTING ===== */
@ -224,7 +224,7 @@ test_read_ibft_vlan (void)
NMSettingWired *s_wired;
NMSettingVlan *s_vlan;
NMSettingIP4Config *s_ip4;
const GByteArray *array;
const char *mac_address;
const char *expected_mac_address = "00:33:21:98:b9:f0";
NMIP4Address *ip4_addr;
GError *error = NULL;
@ -243,9 +243,9 @@ test_read_ibft_vlan (void)
/* ===== WIRED SETTING ===== */
s_wired = nm_connection_get_setting_wired (connection);
g_assert (s_wired);
array = nm_setting_wired_get_mac_address (s_wired);
g_assert (array);
nmtst_assert_hwaddr_equals (array->data, array->len, expected_mac_address);
mac_address = nm_setting_wired_get_mac_address (s_wired);
g_assert (mac_address);
g_assert (nm_utils_hwaddr_matches (mac_address, -1, expected_mac_address, -1));
/* ===== VLAN SETTING ===== */
s_vlan = nm_connection_get_setting_vlan (connection);

129
src/settings/plugins/ifcfg-rh/reader.c
View file

@ -244,36 +244,6 @@ make_connection_setting (const char *file,
return NM_SETTING (s_con);
}
static gboolean
read_mac_address (shvarFile *ifcfg, const char *key, gsize len,
GByteArray **array, GError **error)
{
char *value = NULL;
g_return_val_if_fail (ifcfg != NULL, FALSE);
g_return_val_if_fail (array != NULL, FALSE);
g_return_val_if_fail (*array == NULL, FALSE);
if (error)
g_return_val_if_fail (*error == NULL, FALSE);
value = svGetValue (ifcfg, key, FALSE);
if (!value || !strlen (value)) {
g_free (value);
return TRUE;
}
*array = nm_utils_hwaddr_atoba (value, len);
if (!*array) {
g_set_error (error, IFCFG_PLUGIN_ERROR, 0,
"%s: the MAC address '%s' was invalid.", key, value);
g_free (value);
return FALSE;
}
g_free (value);
return TRUE;
}
/* Returns TRUE on missing address or valid address */
static gboolean
read_ip4_address (shvarFile *ifcfg,
@ -3282,29 +3252,22 @@ make_wireless_setting (shvarFile *ifcfg,
NMSettingWireless *s_wireless;
GByteArray *array = NULL;
GSList *macaddr_blacklist = NULL;
char *value;
char *value = NULL;
s_wireless = NM_SETTING_WIRELESS (nm_setting_wireless_new ());
if (read_mac_address (ifcfg, "HWADDR", ETH_ALEN, &array, error)) {
if (array) {
g_object_set (s_wireless, NM_SETTING_WIRELESS_MAC_ADDRESS, array, NULL);
g_byte_array_free (array, TRUE);
}
} else {
g_object_unref (s_wireless);
return NULL;
value = svGetValue (ifcfg, "HWADDR", FALSE);
if (value) {
value = g_strstrip (value);
g_object_set (s_wireless, NM_SETTING_WIRELESS_MAC_ADDRESS, value, NULL);
g_free (value);
}
array = NULL;
if (read_mac_address (ifcfg, "MACADDR", ETH_ALEN, &array, error)) {
if (array) {
g_object_set (s_wireless, NM_SETTING_WIRELESS_CLONED_MAC_ADDRESS, array, NULL);
g_byte_array_free (array, TRUE);
}
} else {
PARSE_WARNING ("%s", (*error)->message);
g_clear_error (error);
value = svGetValue (ifcfg, "MACADDR", FALSE);
if (value) {
value = g_strstrip (value);
g_object_set (s_wireless, NM_SETTING_WIRELESS_CLONED_MAC_ADDRESS, value, NULL);
g_free (value);
}
value = svGetValue (ifcfg, "HWADDR_BLACKLIST", FALSE);
@ -3415,18 +3378,8 @@ make_wireless_setting (shvarFile *ifcfg,
value = svGetValue (ifcfg, "BSSID", FALSE);
if (value) {
GByteArray *bssid;
bssid = nm_utils_hwaddr_atoba (value, ETH_ALEN);
if (!bssid) {
g_set_error (error, IFCFG_PLUGIN_ERROR, 0,
"Invalid BSSID '%s'", value);
g_free (value);
goto error;
}
g_object_set (s_wireless, NM_SETTING_WIRELESS_BSSID, bssid, NULL);
g_byte_array_free (bssid, TRUE);
value = g_strstrip (value);
g_object_set (s_wireless, NM_SETTING_WIRELESS_BSSID, value, NULL);
g_free (value);
}
@ -3557,7 +3510,6 @@ make_wired_setting (shvarFile *ifcfg,
NMSettingWired *s_wired;
char *value = NULL;
int mtu;
GByteArray *mac = NULL;
GSList *macaddr_blacklist = NULL;
char *nettype;
@ -3575,14 +3527,11 @@ make_wired_setting (shvarFile *ifcfg,
g_free (value);
}
if (read_mac_address (ifcfg, "HWADDR", ETH_ALEN, &mac, error)) {
if (mac) {
g_object_set (s_wired, NM_SETTING_WIRED_MAC_ADDRESS, mac, NULL);
g_byte_array_free (mac, TRUE);
}
} else {
g_object_unref (s_wired);
return NULL;
value = svGetValue (ifcfg, "HWADDR", FALSE);
if (value) {
value = g_strstrip (value);
g_object_set (s_wired, NM_SETTING_WIRED_MAC_ADDRESS, value, NULL);
g_free (value);
}
value = svGetValue (ifcfg, "SUBCHANNELS", FALSE);
@ -3666,15 +3615,11 @@ make_wired_setting (shvarFile *ifcfg,
}
g_free (value);
mac = NULL;
if (read_mac_address (ifcfg, "MACADDR", ETH_ALEN, &mac, error)) {
if (mac) {
g_object_set (s_wired, NM_SETTING_WIRED_CLONED_MAC_ADDRESS, mac, NULL);
g_byte_array_free (mac, TRUE);
}
} else {
PARSE_WARNING ("%s", (*error)->message);
g_clear_error (error);
value = svGetValue (ifcfg, "MACADDR", FALSE);
if (value) {
value = g_strstrip (value);
g_object_set (s_wired, NM_SETTING_WIRED_CLONED_MAC_ADDRESS, value, NULL);
g_free (value);
}
value = svGetValue (ifcfg, "HWADDR_BLACKLIST", FALSE);
@ -3834,7 +3779,6 @@ make_infiniband_setting (shvarFile *ifcfg,
{
NMSettingInfiniband *s_infiniband;
char *value = NULL;
GByteArray *mac = NULL;
int mtu;
s_infiniband = NM_SETTING_INFINIBAND (nm_setting_infiniband_new ());
@ -3851,14 +3795,11 @@ make_infiniband_setting (shvarFile *ifcfg,
g_free (value);
}
if (read_mac_address (ifcfg, "HWADDR", INFINIBAND_ALEN, &mac, error)) {
if (mac) {
g_object_set (s_infiniband, NM_SETTING_INFINIBAND_MAC_ADDRESS, mac, NULL);
g_byte_array_free (mac, TRUE);
}
} else {
g_object_unref (s_infiniband);
return NULL;
value = svGetValue (ifcfg, "HWADDR", FALSE);
if (value) {
value = g_strstrip (value);
g_object_set (s_infiniband, NM_SETTING_INFINIBAND_MAC_ADDRESS, value, NULL);
g_free (value);
}
if (svTrueValue (ifcfg, "CONNECTED_MODE", FALSE))
@ -4221,7 +4162,6 @@ make_bridge_setting (shvarFile *ifcfg,
guint32 u;
gboolean stp = FALSE;
gboolean stp_set = FALSE;
GByteArray *array = NULL;
s_bridge = NM_SETTING_BRIDGE (nm_setting_bridge_new ());
@ -4232,14 +4172,11 @@ make_bridge_setting (shvarFile *ifcfg,
}
g_free (value);
if (read_mac_address (ifcfg, "MACADDR", ETH_ALEN, &array, error)) {
if (array) {
g_object_set (s_bridge, NM_SETTING_BRIDGE_MAC_ADDRESS, array, NULL);
g_byte_array_free (array, TRUE);
}
} else {
PARSE_WARNING ("%s", (*error)->message);
g_clear_error (error);
value = svGetValue (ifcfg, "MACADDR", FALSE);
if (value) {
value = g_strstrip (value);
g_object_set (s_bridge, NM_SETTING_BRIDGE_MAC_ADDRESS, value, NULL);
g_free (value);
}
value = svGetValue (ifcfg, "STP", FALSE);

182
src/settings/plugins/ifcfg-rh/tests/test-ifcfg-rh.c
View file

@ -186,7 +186,7 @@ test_read_basic (void)
NMSettingIP4Config *s_ip4;
NMSettingIP6Config *s_ip6;
GError *error = NULL;
const GByteArray *array;
const char *mac;
char expected_mac_address[ETH_ALEN] = { 0x00, 0x16, 0x41, 0x11, 0x22, 0x33 };
const char *expected_id = "System test-minimal";
guint64 expected_timestamp = 0;
@ -218,10 +218,9 @@ test_read_basic (void)
g_assert_cmpint (nm_setting_wired_get_mtu (s_wired), ==, 0);
/* MAC address */
array = nm_setting_wired_get_mac_address (s_wired);
g_assert (array);
g_assert_cmpint (array->len, ==, ETH_ALEN);
g_assert (memcmp (array->data, &expected_mac_address[0], ETH_ALEN) == 0);
mac = nm_setting_wired_get_mac_address (s_wired);
g_assert (mac);
g_assert (nm_utils_hwaddr_matches (mac, -1, expected_mac_address, ETH_ALEN));
/* ===== IPv4 SETTING ===== */
s_ip4 = nm_connection_get_setting_ip4_config (connection);
@ -246,7 +245,7 @@ test_read_variables_corner_cases (void)
NMSettingWired *s_wired;
NMSettingIP4Config *s_ip4;
GError *error = NULL;
const GByteArray *array;
const char *mac;
char expected_mac_address[ETH_ALEN] = { 0x00, 0x16, 0x41, 0x11, 0x22, 0x33 };
const char *expected_zone = "'";
const char *expected_id = "\"";
@ -275,10 +274,9 @@ test_read_variables_corner_cases (void)
g_assert_cmpint (nm_setting_wired_get_mtu (s_wired), ==, 0);
/* MAC address */
array = nm_setting_wired_get_mac_address (s_wired);
g_assert (array);
g_assert_cmpint (array->len, ==, ETH_ALEN);
g_assert (memcmp (array->data, &expected_mac_address[0], ETH_ALEN) == 0);
mac = nm_setting_wired_get_mac_address (s_wired);
g_assert (mac);
g_assert (nm_utils_hwaddr_matches (mac, -1, expected_mac_address, ETH_ALEN));
/* ===== IPv4 SETTING ===== */
s_ip4 = nm_connection_get_setting_ip4_config (connection);
@ -396,7 +394,7 @@ test_read_wired_static (const char *file,
NMSettingIP6Config *s_ip6;
char *unmanaged = NULL;
GError *error = NULL;
const GByteArray *array;
const char *mac;
char expected_mac_address[ETH_ALEN] = { 0x00, 0x11, 0x22, 0x33, 0x44, 0xee };
const char *expected_dns1 = "4.2.2.1";
const char *expected_dns2 = "4.2.2.2";
@ -432,10 +430,9 @@ test_read_wired_static (const char *file,
g_assert_cmpint (nm_setting_wired_get_mtu (s_wired), ==, 1492);
/* MAC address */
array = nm_setting_wired_get_mac_address (s_wired);
g_assert (array);
g_assert_cmpint (array->len, ==, ETH_ALEN);
g_assert (memcmp (array->data, &expected_mac_address[0], ETH_ALEN) == 0);
mac = nm_setting_wired_get_mac_address (s_wired);
g_assert (mac);
g_assert (nm_utils_hwaddr_matches (mac, -1, expected_mac_address, ETH_ALEN));
/* ===== IPv4 SETTING ===== */
s_ip4 = nm_connection_get_setting_ip4_config (connection);
@ -552,7 +549,7 @@ test_read_wired_dhcp (void)
char *route6file = NULL;
gboolean ignore_error = FALSE;
GError *error = NULL;
const GByteArray *array;
const char *mac;
char expected_mac_address[ETH_ALEN] = { 0x00, 0x11, 0x22, 0x33, 0x44, 0xee };
const char *tmp;
const char *expected_id = "System test-wired-dhcp";
@ -623,18 +620,13 @@ test_read_wired_dhcp (void)
NM_SETTING_WIRED_SETTING_NAME);
/* MAC address */
array = nm_setting_wired_get_mac_address (s_wired);
ASSERT (array != NULL,
mac = nm_setting_wired_get_mac_address (s_wired);
ASSERT (mac != NULL,
"wired-dhcp-verify-wired", "failed to verify %s: missing %s / %s key",
TEST_IFCFG_WIRED_DHCP,
NM_SETTING_WIRED_SETTING_NAME,
NM_SETTING_WIRED_MAC_ADDRESS);
ASSERT (array->len == ETH_ALEN,
"wired-dhcp-verify-wired", "failed to verify %s: unexpected %s / %s key value length",
TEST_IFCFG_WIRED_DHCP,
NM_SETTING_WIRED_SETTING_NAME,
NM_SETTING_WIRED_MAC_ADDRESS);
ASSERT (memcmp (array->data, &expected_mac_address[0], sizeof (expected_mac_address)) == 0,
ASSERT (nm_utils_hwaddr_matches (mac, -1, expected_mac_address, sizeof (expected_mac_address)),
"wired-dhcp-verify-wired", "failed to verify %s: unexpected %s / %s key value",
TEST_IFCFG_WIRED_DHCP,
NM_SETTING_WIRED_SETTING_NAME,
@ -2843,6 +2835,7 @@ test_read_wifi_open (void)
GError *error = NULL;
const char *tmp;
const GByteArray *array;
const char *mac;
char expected_mac_address[ETH_ALEN] = { 0x00, 0x16, 0x41, 0x11, 0x22, 0x33 };
const char *expected_id = "System blahblah (test-wifi-open)";
guint64 expected_timestamp = 0;
@ -2914,18 +2907,13 @@ test_read_wifi_open (void)
NM_SETTING_WIRELESS_SETTING_NAME);
/* MAC address */
array = nm_setting_wireless_get_mac_address (s_wireless);
ASSERT (array != NULL,
mac = nm_setting_wireless_get_mac_address (s_wireless);
ASSERT (mac != NULL,
"wifi-open-verify-wireless", "failed to verify %s: missing %s / %s key",
TEST_IFCFG_WIFI_OPEN,
NM_SETTING_WIRELESS_SETTING_NAME,
NM_SETTING_WIRELESS_MAC_ADDRESS);
ASSERT (array->len == ETH_ALEN,
"wifi-open-verify-wireless", "failed to verify %s: unexpected %s / %s key value length",
TEST_IFCFG_WIFI_OPEN,
NM_SETTING_WIRELESS_SETTING_NAME,
NM_SETTING_WIRELESS_MAC_ADDRESS);
ASSERT (memcmp (array->data, &expected_mac_address[0], sizeof (expected_mac_address)) == 0,
ASSERT (nm_utils_hwaddr_matches (mac, -1, expected_mac_address, sizeof (expected_mac_address)),
"wifi-open-verify-wireless", "failed to verify %s: unexpected %s / %s key value",
TEST_IFCFG_WIFI_OPEN,
NM_SETTING_WIRELESS_SETTING_NAME,
@ -3309,6 +3297,7 @@ test_read_wifi_wep (void)
GError *error = NULL;
const char *tmp;
const GByteArray *array;
const char *mac;
char expected_mac_address[ETH_ALEN] = { 0x00, 0x16, 0x41, 0x11, 0x22, 0x33 };
const char *expected_id = "System blahblah (test-wifi-wep)";
guint64 expected_timestamp = 0;
@ -3382,18 +3371,13 @@ test_read_wifi_wep (void)
NM_SETTING_WIRELESS_SETTING_NAME);
/* MAC address */
array = nm_setting_wireless_get_mac_address (s_wireless);
ASSERT (array != NULL,
mac = nm_setting_wireless_get_mac_address (s_wireless);
ASSERT (mac != NULL,
"wifi-wep-verify-wireless", "failed to verify %s: missing %s / %s key",
TEST_IFCFG_WIFI_WEP,
NM_SETTING_WIRELESS_SETTING_NAME,
NM_SETTING_WIRELESS_MAC_ADDRESS);
ASSERT (array->len == ETH_ALEN,
"wifi-wep-verify-wireless", "failed to verify %s: unexpected %s / %s key value length",
TEST_IFCFG_WIFI_WEP,
NM_SETTING_WIRELESS_SETTING_NAME,
NM_SETTING_WIRELESS_MAC_ADDRESS);
ASSERT (memcmp (array->data, &expected_mac_address[0], sizeof (expected_mac_address)) == 0,
ASSERT (nm_utils_hwaddr_matches (mac, -1, expected_mac_address, sizeof (expected_mac_address)),
"wifi-wep-verify-wireless", "failed to verify %s: unexpected %s / %s key value",
TEST_IFCFG_WIFI_WEP,
NM_SETTING_WIRELESS_SETTING_NAME,
@ -4376,6 +4360,7 @@ test_read_wifi_wpa_psk (void)
GError *error = NULL;
const char *tmp;
const GByteArray *array;
const char *mac;
char expected_mac_address[ETH_ALEN] = { 0x00, 0x16, 0x41, 0x11, 0x22, 0x33 };
const char *expected_id = "System blahblah (test-wifi-wpa-psk)";
guint64 expected_timestamp = 0;
@ -4458,18 +4443,13 @@ test_read_wifi_wpa_psk (void)
NM_SETTING_WIRELESS_SETTING_NAME);
/* MAC address */
array = nm_setting_wireless_get_mac_address (s_wireless);
ASSERT (array != NULL,
mac = nm_setting_wireless_get_mac_address (s_wireless);
ASSERT (mac != NULL,
"wifi-wpa-psk-verify-wireless", "failed to verify %s: missing %s / %s key",
TEST_IFCFG_WIFI_WPA_PSK,
NM_SETTING_WIRELESS_SETTING_NAME,
NM_SETTING_WIRELESS_MAC_ADDRESS);
ASSERT (array->len == ETH_ALEN,
"wifi-wpa-psk-verify-wireless", "failed to verify %s: unexpected %s / %s key value length",
TEST_IFCFG_WIFI_WPA_PSK,
NM_SETTING_WIRELESS_SETTING_NAME,
NM_SETTING_WIRELESS_MAC_ADDRESS);
ASSERT (memcmp (array->data, &expected_mac_address[0], sizeof (expected_mac_address)) == 0,
ASSERT (nm_utils_hwaddr_matches (mac, -1, expected_mac_address, sizeof (expected_mac_address)),
"wifi-wpa-psk-verify-wireless", "failed to verify %s: unexpected %s / %s key value",
TEST_IFCFG_WIFI_WPA_PSK,
NM_SETTING_WIRELESS_SETTING_NAME,
@ -5866,7 +5846,7 @@ test_read_wired_qeth_static (void)
GError *error = NULL;
const char *tmp;
const char *expected_id = "System test-wired-qeth-static";
const GByteArray *array;
const char *mac;
const char *expected_channel0 = "0.0.0600";
const char *expected_channel1 = "0.0.0601";
const char *expected_channel2 = "0.0.0602";
@ -5920,8 +5900,8 @@ test_read_wired_qeth_static (void)
NM_SETTING_WIRED_SETTING_NAME);
/* MAC address */
array = nm_setting_wired_get_mac_address (s_wired);
ASSERT (array == NULL,
mac = nm_setting_wired_get_mac_address (s_wired);
ASSERT (mac == NULL,
"wired-qeth-static-verify-wired", "failed to verify %s: unexpected %s / %s key",
TEST_IFCFG_WIRED_QETH_STATIC,
NM_SETTING_WIRED_SETTING_NAME,
@ -6354,8 +6334,7 @@ test_write_wired_static (void)
NMSettingWired *s_wired;
NMSettingIP4Config *s_ip4, *reread_s_ip4;
NMSettingIP6Config *s_ip6, *reread_s_ip6;
static unsigned char tmpmac[] = { 0x31, 0x33, 0x33, 0x37, 0xbe, 0xcd };
GByteArray *mac;
static const char *mac = "31:33:33:37:be:cd";
guint32 mtu = 1492;
char *uuid;
const guint32 ip1 = htonl (0x01010103);
@ -6414,14 +6393,10 @@ test_write_wired_static (void)
s_wired = (NMSettingWired *) nm_setting_wired_new ();
nm_connection_add_setting (connection, NM_SETTING (s_wired));
mac = g_byte_array_sized_new (sizeof (tmpmac));
g_byte_array_append (mac, &tmpmac[0], sizeof (tmpmac));
g_object_set (s_wired,
NM_SETTING_WIRED_MAC_ADDRESS, mac,
NM_SETTING_WIRED_MTU, mtu,
NULL);
g_byte_array_free (mac, TRUE);
/* IP4 setting */
s_ip4 = (NMSettingIP4Config *) nm_setting_ip4_config_new ();
@ -6797,8 +6772,7 @@ test_write_wired_static_ip6_only (void)
NMSettingWired *s_wired;
NMSettingIP4Config *s_ip4;
NMSettingIP6Config *s_ip6;
static unsigned char tmpmac[] = { 0x31, 0x33, 0x33, 0x37, 0xbe, 0xcd };
GByteArray *mac;
static const char *mac = "31:33:33:37:be:cd";
char *uuid;
struct in6_addr ip6;
struct in6_addr dns6;
@ -6834,10 +6808,7 @@ test_write_wired_static_ip6_only (void)
s_wired = (NMSettingWired *) nm_setting_wired_new ();
nm_connection_add_setting (connection, NM_SETTING (s_wired));
mac = g_byte_array_sized_new (sizeof (tmpmac));
g_byte_array_append (mac, &tmpmac[0], sizeof (tmpmac));
g_object_set (s_wired, NM_SETTING_WIRED_MAC_ADDRESS, mac, NULL);
g_byte_array_free (mac, TRUE);
/* IP4 setting */
s_ip4 = (NMSettingIP4Config *) nm_setting_ip4_config_new ();
@ -6934,8 +6905,7 @@ test_write_wired_static_ip6_only_gw (gconstpointer user_data)
NMSettingWired *s_wired;
NMSettingIP4Config *s_ip4;
NMSettingIP6Config *s_ip6;
static unsigned char tmpmac[] = { 0x31, 0x33, 0x33, 0x37, 0xbe, 0xcd };
GByteArray *mac;
static const char *mac = "31:33:33:37:be:cd";
char *uuid;
struct in6_addr ip6;
struct in6_addr dns6;
@ -6983,10 +6953,7 @@ test_write_wired_static_ip6_only_gw (gconstpointer user_data)
s_wired = (NMSettingWired *) nm_setting_wired_new ();
nm_connection_add_setting (connection, NM_SETTING (s_wired));
mac = g_byte_array_sized_new (sizeof (tmpmac));
g_byte_array_append (mac, &tmpmac[0], sizeof (tmpmac));
g_object_set (s_wired, NM_SETTING_WIRED_MAC_ADDRESS, mac, NULL);
g_byte_array_free (mac, TRUE);
/* IP4 setting */
s_ip4 = (NMSettingIP4Config *) nm_setting_ip4_config_new ();
@ -7234,8 +7201,7 @@ test_write_wired_static_routes (void)
NMSettingWired *s_wired;
NMSettingIP4Config *s_ip4;
NMSettingIP6Config *s_ip6;
static unsigned char tmpmac[] = { 0x31, 0x33, 0x33, 0x37, 0xbe, 0xcd };
GByteArray *mac;
static const char *mac = "31:33:33:37:be:cd";
guint32 mtu = 1492;
char *uuid;
const guint32 ip1 = htonl (0x01010103);
@ -7280,14 +7246,10 @@ test_write_wired_static_routes (void)
s_wired = (NMSettingWired *) nm_setting_wired_new ();
nm_connection_add_setting (connection, NM_SETTING (s_wired));
mac = g_byte_array_sized_new (sizeof (tmpmac));
g_byte_array_append (mac, &tmpmac[0], sizeof (tmpmac));
g_object_set (s_wired,
NM_SETTING_WIRED_MAC_ADDRESS, mac,
NM_SETTING_WIRED_MTU, mtu,
NULL);
g_byte_array_free (mac, TRUE);
/* IP4 setting */
s_ip4 = (NMSettingIP4Config *) nm_setting_ip4_config_new ();
@ -8128,11 +8090,9 @@ test_write_wifi_open (void)
gboolean ignore_error = FALSE;
GByteArray *ssid;
const unsigned char ssid_data[] = { 0x54, 0x65, 0x73, 0x74, 0x20, 0x53, 0x53, 0x49, 0x44 };
GByteArray *bssid;
const unsigned char bssid_data[] = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66 };
const char *bssid = "11:22:33:44:55:66";
guint32 channel = 9, mtu = 1345;
GByteArray *mac;
const unsigned char mac_data[] = { 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff };
const char *mac = "aa:bb:cc:dd:ee:ff";
shvarFile *ifcfg;
char *tmp;
@ -8157,10 +8117,6 @@ test_write_wifi_open (void)
ssid = g_byte_array_sized_new (sizeof (ssid_data));
g_byte_array_append (ssid, ssid_data, sizeof (ssid_data));
bssid = g_byte_array_sized_new (sizeof (bssid_data));
g_byte_array_append (bssid, bssid_data, sizeof (bssid_data));
mac = g_byte_array_sized_new (sizeof (mac_data));
g_byte_array_append (mac, mac_data, sizeof (mac_data));
g_object_set (s_wifi,
NM_SETTING_WIRELESS_SSID, ssid,
@ -8173,8 +8129,6 @@ test_write_wifi_open (void)
NULL);
g_byte_array_free (ssid, TRUE);
g_byte_array_free (bssid, TRUE);
g_byte_array_free (mac, TRUE);
/* IP4 setting */
s_ip4 = (NMSettingIP4Config *) nm_setting_ip4_config_new ();
@ -11448,7 +11402,7 @@ test_read_bridge_main (void)
{
NMConnection *connection;
NMSettingBridge *s_bridge;
const GByteArray *array;
const char *mac;
char expected_mac_address[ETH_ALEN] = { 0x00, 0x16, 0x41, 0x11, 0x22, 0x33 };
char *unmanaged = NULL;
char *keyfile = NULL;
@ -11482,11 +11436,11 @@ test_read_bridge_main (void)
g_assert_cmpuint (nm_setting_bridge_get_hello_time (s_bridge), ==, 7);
g_assert_cmpuint (nm_setting_bridge_get_max_age (s_bridge), ==, 39);
g_assert_cmpuint (nm_setting_bridge_get_ageing_time (s_bridge), ==, 235352);
/* MAC address */
array = nm_setting_bridge_get_mac_address (s_bridge);
g_assert (array);
g_assert_cmpint (array->len, ==, ETH_ALEN);
g_assert (memcmp (array->data, &expected_mac_address[0], ETH_ALEN) == 0);
mac = nm_setting_bridge_get_mac_address (s_bridge);
g_assert (mac);
g_assert (nm_utils_hwaddr_matches (mac, -1, expected_mac_address, ETH_ALEN));
g_free (unmanaged);
g_free (keyfile);
@ -11509,8 +11463,7 @@ test_write_bridge_main (void)
const guint32 gw = htonl (0x01010101);
const guint32 prefix = 24;
NMIP4Address *addr;
static unsigned char bridge_mac[] = { 0x31, 0x33, 0x33, 0x37, 0xbe, 0xcd };
GByteArray *mac_array;
static const char *mac = "31:33:33:37:be:cd";
gboolean success;
GError *error = NULL;
char *testfile = NULL;
@ -11543,12 +11496,9 @@ test_write_bridge_main (void)
g_assert (s_bridge);
nm_connection_add_setting (connection, NM_SETTING (s_bridge));
mac_array = g_byte_array_sized_new (sizeof (bridge_mac));
g_byte_array_append (mac_array, bridge_mac, sizeof (bridge_mac));
g_object_set (s_bridge,
NM_SETTING_BRIDGE_MAC_ADDRESS, mac_array,
NM_SETTING_BRIDGE_MAC_ADDRESS, mac,
NULL);
g_byte_array_free (mac_array, TRUE);
/* IP4 setting */
s_ip4 = (NMSettingIP4Config *) nm_setting_ip4_config_new ();
@ -11672,8 +11622,7 @@ test_write_bridge_component (void)
NMSettingConnection *s_con;
NMSettingWired *s_wired;
NMSetting *s_port;
static unsigned char tmpmac[] = { 0x31, 0x33, 0x33, 0x37, 0xbe, 0xcd };
GByteArray *mac;
static const char *mac = "31:33:33:37:be:cd";
guint32 mtu = 1492;
char *uuid;
gboolean success;
@ -11709,14 +11658,10 @@ test_write_bridge_component (void)
g_assert (s_wired);
nm_connection_add_setting (connection, NM_SETTING (s_wired));
mac = g_byte_array_sized_new (sizeof (tmpmac));
g_byte_array_append (mac, &tmpmac[0], sizeof (tmpmac));
g_object_set (s_wired,
NM_SETTING_WIRED_MAC_ADDRESS, mac,
NM_SETTING_WIRED_MTU, mtu,
NULL);
g_byte_array_free (mac, TRUE);
/* Bridge port */
s_port = nm_setting_bridge_port_new ();
@ -12468,8 +12413,7 @@ test_write_bond_slave (void)
NMConnection *reread;
NMSettingConnection *s_con;
NMSettingWired *s_wired;
static unsigned char tmpmac[] = { 0x31, 0x33, 0x33, 0x37, 0xbe, 0xcd };
GByteArray *mac;
static const char *mac = "31:33:33:37:be:cd";
guint32 mtu = 1492;
char *uuid;
gboolean success;
@ -12502,14 +12446,10 @@ test_write_bond_slave (void)
s_wired = (NMSettingWired *) nm_setting_wired_new ();
nm_connection_add_setting (connection, NM_SETTING (s_wired));
mac = g_byte_array_sized_new (sizeof (tmpmac));
g_byte_array_append (mac, &tmpmac[0], sizeof (tmpmac));
g_object_set (s_wired,
NM_SETTING_WIRED_MAC_ADDRESS, mac,
NM_SETTING_WIRED_MTU, mtu,
NULL);
g_byte_array_free (mac, TRUE);
ASSERT (nm_connection_verify (connection, &error) == TRUE,
"bond-slave-write", "failed to verify connection: %s",
@ -12576,7 +12516,7 @@ test_read_infiniband (void)
char *route6file = NULL;
gboolean ignore_error = FALSE;
GError *error = NULL;
const GByteArray *array;
const char *mac;
char expected_mac_address[INFINIBAND_ALEN] = { 0x80, 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x00, 0x11, 0x22 };
const char *transport_mode;
@ -12607,18 +12547,13 @@ test_read_infiniband (void)
NM_SETTING_INFINIBAND_SETTING_NAME);
/* MAC address */
array = nm_setting_infiniband_get_mac_address (s_infiniband);
ASSERT (array != NULL,
mac = nm_setting_infiniband_get_mac_address (s_infiniband);
ASSERT (mac != NULL,
"infiniband-verify-infiniband", "failed to verify %s: missing %s / %s key",
TEST_IFCFG_INFINIBAND,
NM_SETTING_INFINIBAND_SETTING_NAME,
NM_SETTING_INFINIBAND_MAC_ADDRESS);
ASSERT (array->len == INFINIBAND_ALEN,
"infiniband-verify-infiniband", "failed to verify %s: unexpected %s / %s key value length",
TEST_IFCFG_INFINIBAND,
NM_SETTING_INFINIBAND_SETTING_NAME,
NM_SETTING_INFINIBAND_MAC_ADDRESS);
ASSERT (memcmp (array->data, &expected_mac_address[0], sizeof (expected_mac_address)) == 0,
ASSERT (nm_utils_hwaddr_matches (mac, -1, expected_mac_address, sizeof (expected_mac_address)),
"infiniband-verify-infiniband", "failed to verify %s: unexpected %s / %s key value",
TEST_IFCFG_INFINIBAND,
NM_SETTING_INFINIBAND_SETTING_NAME,
@ -12653,8 +12588,7 @@ test_write_infiniband (void)
NMSettingInfiniband *s_infiniband;
NMSettingIP4Config *s_ip4;
NMSettingIP6Config *s_ip6;
unsigned char tmpmac[INFINIBAND_ALEN] = { 0x80, 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x00, 0x11, 0x22 };
GByteArray *mac;
const char *mac = "80:00:11:22:33:44:55:66:77:88:99:aa:bb:cc:dd:ee:ff:00:11:22";
guint32 mtu = 65520;
char *uuid;
const guint32 ip1 = htonl (0x01010103);
@ -12689,15 +12623,11 @@ test_write_infiniband (void)
s_infiniband = (NMSettingInfiniband *) nm_setting_infiniband_new ();
nm_connection_add_setting (connection, NM_SETTING (s_infiniband));
mac = g_byte_array_sized_new (sizeof (tmpmac));
g_byte_array_append (mac, &tmpmac[0], sizeof (tmpmac));
g_object_set (s_infiniband,
NM_SETTING_INFINIBAND_MAC_ADDRESS, mac,
NM_SETTING_INFINIBAND_MTU, mtu,
NM_SETTING_INFINIBAND_TRANSPORT_MODE, "connected",
NULL);
g_byte_array_free (mac, TRUE);
/* IP4 setting */
s_ip4 = (NMSettingIP4Config *) nm_setting_ip4_config_new ();
@ -12830,11 +12760,7 @@ test_write_bond_slave_ib (void)
NMConnection *reread;
NMSettingConnection *s_con;
NMSettingInfiniband *s_infiniband;
static unsigned char tmpmac[] = {
0x80, 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x00, 0x11, 0x22
};
GByteArray *mac;
static const char *mac = "80:00:11:22:33:44:55:66:77:88:99:aa:bb:cc:dd:ee:ff:00:11:22";
char *uuid;
gboolean success;
GError *error = NULL;
@ -12866,15 +12792,11 @@ test_write_bond_slave_ib (void)
s_infiniband = (NMSettingInfiniband *) nm_setting_infiniband_new ();
nm_connection_add_setting (connection, NM_SETTING (s_infiniband));
mac = g_byte_array_sized_new (sizeof (tmpmac));
g_byte_array_append (mac, &tmpmac[0], sizeof (tmpmac));
g_object_set (s_infiniband,
NM_SETTING_INFINIBAND_MAC_ADDRESS, mac,
NM_SETTING_INFINIBAND_MTU, 2044,
NM_SETTING_INFINIBAND_TRANSPORT_MODE, "datagram",
NULL);
g_byte_array_free (mac, TRUE);
ASSERT (nm_connection_verify (connection, &error) == TRUE,
"bond-slave-write-ib", "failed to verify connection: %s",

76
src/settings/plugins/ifcfg-rh/writer.c
View file

@ -50,13 +50,6 @@
#include "crypto.h"
static void
svSetValue_free (shvarFile *s, const char *key, char *value, gboolean verbatim)
{
svSetValue (s, key, value, verbatim);
g_free (value);
}
static void
save_secret_flags (shvarFile *ifcfg,
const char *key,
@ -807,8 +800,9 @@ write_wireless_setting (NMConnection *connection,
{
NMSettingWireless *s_wireless;
char *tmp, *tmp2;
const GByteArray *ssid, *device_mac, *cloned_mac, *bssid;
const char *mode;
const GByteArray *ssid;
const char *mode, *bssid;
const char *device_mac, *cloned_mac;
char buf[33];
guint32 mtu, chan, i;
gboolean adhoc = FALSE, hex_ssid = FALSE;
@ -821,19 +815,11 @@ write_wireless_setting (NMConnection *connection,
return FALSE;
}
svSetValue (ifcfg, "HWADDR", NULL, FALSE);
device_mac = nm_setting_wireless_get_mac_address (s_wireless);
if (device_mac) {
svSetValue_free (ifcfg, "HWADDR",
nm_utils_hwaddr_ntoa (device_mac->data, device_mac->len), FALSE);
}
svSetValue (ifcfg, "HWADDR", device_mac, FALSE);
svSetValue (ifcfg, "MACADDR", NULL, FALSE);
cloned_mac = nm_setting_wireless_get_cloned_mac_address (s_wireless);
if (cloned_mac) {
svSetValue_free (ifcfg, "MACADDR",
nm_utils_hwaddr_ntoa (cloned_mac->data, cloned_mac->len), FALSE);
}
svSetValue (ifcfg, "MACADDR", cloned_mac, FALSE);
svSetValue (ifcfg, "HWADDR_BLACKLIST", NULL, FALSE);
macaddr_blacklist = nm_setting_wireless_get_mac_address_blacklist (s_wireless);
@ -931,12 +917,8 @@ write_wireless_setting (NMConnection *connection,
g_free (tmp);
}
svSetValue (ifcfg, "BSSID", NULL, FALSE);
bssid = nm_setting_wireless_get_bssid (s_wireless);
if (bssid) {
svSetValue_free (ifcfg, "BSSID",
nm_utils_hwaddr_ntoa (bssid->data, bssid->len), FALSE);
}
svSetValue (ifcfg, "BSSID", bssid, FALSE);
/* Ensure DEFAULTKEY and SECURITYMODE are cleared unless there's security;
* otherwise there's no way to detect WEP vs. open when WEP keys aren't
@ -993,9 +975,8 @@ static gboolean
write_infiniband_setting (NMConnection *connection, shvarFile *ifcfg, GError **error)
{
NMSettingInfiniband *s_infiniband;
const GByteArray *mac;
char *tmp;
const char *transport_mode, *parent;
const char *mac, *transport_mode, *parent;
guint32 mtu;
int p_key;
@ -1006,13 +987,8 @@ write_infiniband_setting (NMConnection *connection, shvarFile *ifcfg, GError **e
return FALSE;
}
svSetValue (ifcfg, "HWADDR", NULL, FALSE);
mac = nm_setting_infiniband_get_mac_address (s_infiniband);
if (mac) {
tmp = nm_utils_hwaddr_ntoa (mac->data, mac->len);
svSetValue (ifcfg, "HWADDR", tmp, FALSE);
g_free (tmp);
}
svSetValue (ifcfg, "HWADDR", mac, FALSE);
svSetValue (ifcfg, "MTU", NULL, FALSE);
mtu = nm_setting_infiniband_get_mtu (s_infiniband);
@ -1048,7 +1024,7 @@ static gboolean
write_wired_setting (NMConnection *connection, shvarFile *ifcfg, GError **error)
{
NMSettingWired *s_wired;
const GByteArray *device_mac, *cloned_mac;
const char *device_mac, *cloned_mac;
char *tmp;
const char *nettype, *portname, *ctcprot, *s390_key, *s390_val;
guint32 mtu, num_opts, i;
@ -1063,19 +1039,11 @@ write_wired_setting (NMConnection *connection, shvarFile *ifcfg, GError **error)
return FALSE;
}
svSetValue (ifcfg, "HWADDR", NULL, FALSE);
device_mac = nm_setting_wired_get_mac_address (s_wired);
if (device_mac) {
svSetValue_free (ifcfg, "HWADDR",
nm_utils_hwaddr_ntoa (device_mac->data, device_mac->len), FALSE);
}
svSetValue (ifcfg, "HWADDR", device_mac, FALSE);
svSetValue (ifcfg, "MACADDR", NULL, FALSE);
cloned_mac = nm_setting_wired_get_cloned_mac_address (s_wired);
if (cloned_mac) {
svSetValue_free (ifcfg, "MACADDR",
nm_utils_hwaddr_ntoa (cloned_mac->data, cloned_mac->len), FALSE);
}
svSetValue (ifcfg, "MACADDR", cloned_mac, FALSE);
svSetValue (ifcfg, "HWADDR_BLACKLIST", NULL, FALSE);
macaddr_blacklist = nm_setting_wired_get_mac_address_blacklist (s_wired);
@ -1245,24 +1213,18 @@ write_vlan_setting (NMConnection *connection, shvarFile *ifcfg, gboolean *wired,
s_wired = nm_connection_get_setting_wired (connection);
if (s_wired) {
const GByteArray *device_mac, *cloned_mac;
const char *device_mac, *cloned_mac;
guint32 mtu;
*wired = TRUE;
device_mac = nm_setting_wired_get_mac_address (s_wired);
if (device_mac) {
tmp = nm_utils_hwaddr_ntoa (device_mac->data, device_mac->len);
svSetValue (ifcfg, "HWADDR", tmp, FALSE);
g_free (tmp);
}
if (device_mac)
svSetValue (ifcfg, "HWADDR", device_mac, FALSE);
cloned_mac = nm_setting_wired_get_cloned_mac_address (s_wired);
if (cloned_mac) {
tmp = nm_utils_hwaddr_ntoa (cloned_mac->data, device_mac->len);
svSetValue (ifcfg, "MACADDR", tmp, FALSE);
g_free (tmp);
}
if (cloned_mac)
svSetValue (ifcfg, "MACADDR", cloned_mac, FALSE);
mtu = nm_setting_wired_get_mtu (s_wired);
if (mtu) {
@ -1378,7 +1340,7 @@ write_bridge_setting (NMConnection *connection, shvarFile *ifcfg, GError **error
const char *iface;
guint32 i;
GString *opts;
const GByteArray *mac;
const char *mac;
char *s;
s_bridge = nm_connection_get_setting_bridge (connection);
@ -1398,11 +1360,9 @@ write_bridge_setting (NMConnection *connection, shvarFile *ifcfg, GError **error
svSetValue (ifcfg, "BRIDGING_OPTS", NULL, FALSE);
svSetValue (ifcfg, "STP", "no", FALSE);
svSetValue (ifcfg, "DELAY", NULL, FALSE);
svSetValue (ifcfg, "MACADDR", NULL, FALSE);
mac = nm_setting_bridge_get_mac_address (s_bridge);
if (mac)
svSetValue_free (ifcfg, "MACADDR", nm_utils_hwaddr_ntoa (mac->data, mac->len), FALSE);
svSetValue (ifcfg, "MACADDR", mac, FALSE);
/* Bridge options */
opts = g_string_sized_new (32);

51
src/settings/plugins/ifnet/connection_parser.c
View file

@ -498,20 +498,20 @@ guess_connection_type (const char *conn_name)
/* Reading mac address for setting connection option.
* Unmanaged device mac address is required by NetworkManager*/
static gboolean
read_mac_address (const char *conn_name, GByteArray **array, GError **error)
read_mac_address (const char *conn_name, const char **mac, GError **error)
{
const char *value = ifnet_get_data (conn_name, "mac");
if (!value || !strlen (value))
return TRUE;
*array = nm_utils_hwaddr_atoba (value, ETH_ALEN);
if (!*array) {
if (!nm_utils_hwaddr_valid (value, ETH_ALEN)) {
g_set_error (error, ifnet_plugin_error_quark (), 0,
"The MAC address '%s' was invalid.", value);
"The MAC address '%s' was invalid.", value);
return FALSE;
}
*mac = value;
return TRUE;
}
@ -520,7 +520,7 @@ make_wired_connection_setting (NMConnection *connection,
const char *conn_name,
GError **error)
{
GByteArray *mac = NULL;
const char *mac = NULL;
NMSettingWired *s_wired = NULL;
const char *value = NULL;
@ -544,7 +544,6 @@ make_wired_connection_setting (NMConnection *connection,
if (mac) {
g_object_set (s_wired, NM_SETTING_WIRED_MAC_ADDRESS,
mac, NULL);
g_byte_array_free (mac, TRUE);
}
} else {
g_object_unref (s_wired);
@ -881,7 +880,8 @@ make_wireless_connection_setting (const char *conn_name,
NMSetting8021x **s_8021x,
GError **error)
{
GByteArray *array, *mac = NULL;
GByteArray *array;
const char *mac = NULL;
NMSettingWireless *wireless_setting = NULL;
gboolean adhoc = FALSE;
const char *value;
@ -903,8 +903,6 @@ make_wireless_connection_setting (const char *conn_name,
g_object_set (wireless_setting,
NM_SETTING_WIRELESS_MAC_ADDRESS, mac,
NULL);
g_byte_array_free (mac, TRUE);
}
} else {
g_object_unref (wireless_setting);
@ -979,18 +977,14 @@ make_wireless_connection_setting (const char *conn_name,
/* BSSID setting */
value = wpa_get_value (conn_name, "bssid");
if (value) {
GByteArray *bssid;
bssid = nm_utils_hwaddr_atoba (value, ETH_ALEN);
if (!bssid) {
if (!nm_utils_hwaddr_valid (value, ETH_ALEN)) {
g_set_error (error, ifnet_plugin_error_quark (), 0,
"Invalid BSSID '%s'", value);
goto error;
}
g_object_set (wireless_setting, NM_SETTING_WIRELESS_BSSID,
bssid, NULL);
g_byte_array_free (bssid, TRUE);
value, NULL);
}
@ -2230,8 +2224,8 @@ write_wireless_setting (NMConnection *connection,
GError **error)
{
NMSettingWireless *s_wireless;
const GByteArray *ssid, *mac, *bssid;
const char *mode;
const GByteArray *ssid;
const char *mac, *bssid, *mode;
char buf[33];
guint32 mtu, i;
gboolean adhoc = FALSE, hex_ssid = FALSE;
@ -2291,11 +2285,8 @@ write_wireless_setting (NMConnection *connection,
ifnet_set_data (ssid_str, "mac", NULL);
mac = nm_setting_wireless_get_mac_address (s_wireless);
if (mac) {
tmp = nm_utils_hwaddr_ntoa (mac->data, mac->len);
ifnet_set_data (ssid_str, "mac", tmp);
g_free (tmp);
}
if (mac)
ifnet_set_data (ssid_str, "mac", mac);
ifnet_set_data (ssid_str, "mtu", NULL);
mtu = nm_setting_wireless_get_mtu (s_wireless);
@ -2320,11 +2311,8 @@ write_wireless_setting (NMConnection *connection,
wpa_set_data (ssid_str, "bssid", NULL);
bssid = nm_setting_wireless_get_bssid (s_wireless);
if (bssid) {
tmp = nm_utils_hwaddr_ntoa (bssid->data, bssid->len);
wpa_set_data (ssid_str, "bssid", tmp);
g_free (tmp);
}
if (bssid)
wpa_set_data (ssid_str, "bssid", bssid);
if (nm_connection_get_setting_wireless_security (connection)) {
if (!write_wireless_security_setting
@ -2345,7 +2333,7 @@ write_wired_setting (NMConnection *connection,
GError **error)
{
NMSettingWired *s_wired;
const GByteArray *mac;
const char *mac;
char *tmp;
guint32 mtu;
@ -2359,11 +2347,8 @@ write_wired_setting (NMConnection *connection,
ifnet_set_data (conn_name, "mac", NULL);
mac = nm_setting_wired_get_mac_address (s_wired);
if (mac) {
tmp = nm_utils_hwaddr_ntoa (mac->data, mac->len);
ifnet_set_data (conn_name, "mac", tmp);
g_free (tmp);
}
if (mac)
ifnet_set_data (conn_name, "mac", mac);
ifnet_set_data (conn_name, "mtu", NULL);
mtu = nm_setting_wired_get_mtu (s_wired);

9
src/settings/plugins/ifupdown/plugin.c
View file

@ -185,7 +185,6 @@ bind_device_to_connection (SCPluginIfupdown *self,
GUdevDevice *device,
NMIfupdownConnection *exported)
{
GByteArray *mac_address;
NMSettingWired *s_wired;
NMSettingWireless *s_wifi;
const char *iface, *address;
@ -202,8 +201,7 @@ bind_device_to_connection (SCPluginIfupdown *self,
return;
}
mac_address = nm_utils_hwaddr_atoba (address, ETH_ALEN);
if (!mac_address) {
if (!nm_utils_hwaddr_valid (address, ETH_ALEN)) {
nm_log_warn (LOGD_SETTINGS, "failed to parse MAC address '%s' for %s",
address, iface);
return;
@ -213,12 +211,11 @@ bind_device_to_connection (SCPluginIfupdown *self,
s_wifi = nm_connection_get_setting_wireless (NM_CONNECTION (exported));
if (s_wired) {
nm_log_info (LOGD_SETTINGS, "locking wired connection setting");
g_object_set (s_wired, NM_SETTING_WIRED_MAC_ADDRESS, mac_address, NULL);
g_object_set (s_wired, NM_SETTING_WIRED_MAC_ADDRESS, address, NULL);
} else if (s_wifi) {
nm_log_info (LOGD_SETTINGS, "locking wireless connection setting");
g_object_set (s_wifi, NM_SETTING_WIRELESS_MAC_ADDRESS, mac_address, NULL);
g_object_set (s_wifi, NM_SETTING_WIRELESS_MAC_ADDRESS, address, NULL);
}
g_byte_array_free (mac_address, TRUE);
nm_settings_connection_commit_changes (NM_SETTINGS_CONNECTION (exported), NULL, NULL);
}

13
src/settings/plugins/keyfile/reader.c
View file

@ -534,7 +534,7 @@ static void
mac_address_parser (NMSetting *setting, const char *key, GKeyFile *keyfile, const char *keyfile_path, gsize enforce_length)
{
const char *setting_name = nm_setting_get_name (setting);
char *tmp_string = NULL, *p;
char *tmp_string = NULL, *p, *mac_str;
gint *tmp_list;
GByteArray *array = NULL;
gsize length;
@ -587,13 +587,16 @@ mac_address_parser (NMSetting *setting, const char *key, GKeyFile *keyfile, cons
g_free (tmp_list);
}
if (array) {
g_object_set (setting, key, array, NULL);
g_byte_array_free (array, TRUE);
} else {
if (!array) {
nm_log_warn (LOGD_SETTINGS, "%s: ignoring invalid MAC address for %s / %s",
__func__, setting_name, key);
return;
}
mac_str = nm_utils_hwaddr_ntoa (array->data, array->len);
g_object_set (setting, key, mac_str, NULL);
g_free (mac_str);
g_byte_array_free (array, TRUE);
}
static void

143
src/settings/plugins/keyfile/tests/test-keyfile.c
View file

@ -139,7 +139,7 @@ test_read_valid_wired_connection (void)
NMSettingIP4Config *s_ip4;
NMSettingIP6Config *s_ip6;
GError *error = NULL;
const GByteArray *array;
const char *mac;
char expected_mac_address[ETH_ALEN] = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55 };
const char *tmp;
const char *expected_id = "Test Wired Connection";
@ -250,18 +250,13 @@ test_read_valid_wired_connection (void)
NM_SETTING_WIRED_SETTING_NAME);
/* MAC address */
array = nm_setting_wired_get_mac_address (s_wired);
ASSERT (array != NULL,
mac = nm_setting_wired_get_mac_address (s_wired);
ASSERT (mac != NULL,
"connection-verify-wired", "failed to verify %s: missing %s / %s key",
TEST_WIRED_FILE,
NM_SETTING_WIRED_SETTING_NAME,
NM_SETTING_WIRED_MAC_ADDRESS);
ASSERT (array->len == ETH_ALEN,
"connection-verify-wired", "failed to verify %s: unexpected %s / %s key value length",
TEST_WIRED_FILE,
NM_SETTING_WIRED_SETTING_NAME,
NM_SETTING_WIRED_MAC_ADDRESS);
ASSERT (memcmp (array->data, &expected_mac_address[0], sizeof (expected_mac_address)) == 0,
ASSERT (nm_utils_hwaddr_matches (mac, -1, expected_mac_address, sizeof (expected_mac_address)),
"connection-verify-wired", "failed to verify %s: unexpected %s / %s key value",
TEST_WIRED_FILE,
NM_SETTING_WIRED_SETTING_NAME,
@ -539,8 +534,7 @@ test_write_wired_connection (void)
NMSettingIP4Config *s_ip4;
NMSettingIP6Config *s_ip6;
char *uuid;
GByteArray *mac;
unsigned char tmpmac[] = { 0x99, 0x88, 0x77, 0x66, 0x55, 0x44 };
const char *mac = "99:88:77:66:55:44";
gboolean success;
NMConnection *reread;
char *testfile = NULL;
@ -599,13 +593,10 @@ test_write_wired_connection (void)
s_wired = NM_SETTING_WIRED (nm_setting_wired_new ());
nm_connection_add_setting (connection, NM_SETTING (s_wired));
mac = g_byte_array_sized_new (ETH_ALEN);
g_byte_array_append (mac, &tmpmac[0], sizeof (tmpmac));
g_object_set (s_wired,
NM_SETTING_WIRED_MAC_ADDRESS, mac,
NM_SETTING_WIRED_MTU, 900,
NULL);
g_byte_array_free (mac, TRUE);
/* IP4 setting */
@ -899,7 +890,7 @@ test_read_wired_mac_case (void)
NMSettingConnection *s_con;
NMSettingWired *s_wired;
GError *error = NULL;
const GByteArray *array;
const char *mac;
char expected_mac_address[ETH_ALEN] = { 0x00, 0x11, 0xaa, 0xbb, 0xcc, 0x55 };
const char *tmp;
const char *expected_id = "Test Wired Connection MAC Case";
@ -962,18 +953,13 @@ test_read_wired_mac_case (void)
NM_SETTING_WIRED_SETTING_NAME);
/* MAC address */
array = nm_setting_wired_get_mac_address (s_wired);
ASSERT (array != NULL,
mac = nm_setting_wired_get_mac_address (s_wired);
ASSERT (mac != NULL,
"connection-verify-wired", "failed to verify %s: missing %s / %s key",
TEST_WIRED_MAC_CASE_FILE,
NM_SETTING_WIRED_SETTING_NAME,
NM_SETTING_WIRED_MAC_ADDRESS);
ASSERT (array->len == ETH_ALEN,
"connection-verify-wired", "failed to verify %s: unexpected %s / %s key value length",
TEST_WIRED_MAC_CASE_FILE,
NM_SETTING_WIRED_SETTING_NAME,
NM_SETTING_WIRED_MAC_ADDRESS);
ASSERT (memcmp (array->data, &expected_mac_address[0], sizeof (expected_mac_address)) == 0,
ASSERT (nm_utils_hwaddr_matches (mac, -1, expected_mac_address, sizeof (expected_mac_address)),
"connection-verify-wired", "failed to verify %s: unexpected %s / %s key value",
TEST_WIRED_MAC_CASE_FILE,
NM_SETTING_WIRED_SETTING_NAME,
@ -991,7 +977,7 @@ test_read_mac_old_format (void)
NMSettingWired *s_wired;
GError *error = NULL;
gboolean success;
const GByteArray *array;
const char *mac;
char expected_mac[ETH_ALEN] = { 0x00, 0x11, 0xaa, 0xbb, 0xcc, 0x55 };
char expected_cloned_mac[ETH_ALEN] = { 0x00, 0x16, 0xaa, 0xbb, 0xcc, 0xfe };
@ -1007,16 +993,14 @@ test_read_mac_old_format (void)
g_assert (s_wired);
/* MAC address */
array = nm_setting_wired_get_mac_address (s_wired);
g_assert (array);
g_assert_cmpint (array->len, ==, ETH_ALEN);
g_assert (memcmp (array->data, expected_mac, ETH_ALEN) == 0);
mac = nm_setting_wired_get_mac_address (s_wired);
g_assert (mac);
g_assert (nm_utils_hwaddr_matches (mac, -1, expected_mac, ETH_ALEN));
/* Cloned MAC address */
array = nm_setting_wired_get_cloned_mac_address (s_wired);
g_assert (array);
g_assert_cmpint (array->len, ==, ETH_ALEN);
g_assert (memcmp (array->data, expected_cloned_mac, ETH_ALEN) == 0);
mac = nm_setting_wired_get_cloned_mac_address (s_wired);
g_assert (mac);
g_assert (nm_utils_hwaddr_matches (mac, -1, expected_cloned_mac, ETH_ALEN));
g_object_unref (connection);
}
@ -1030,7 +1014,7 @@ test_read_mac_ib_old_format (void)
NMSettingInfiniband *s_ib;
GError *error = NULL;
gboolean success;
const GByteArray *array;
const char *mac;
guint8 expected_mac[INFINIBAND_ALEN] = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66,
0x77, 0x88, 0x99, 0x01, 0x12, 0x23, 0x34, 0x45, 0x56, 0x67, 0x78, 0x89,
0x90 };
@ -1047,10 +1031,9 @@ test_read_mac_ib_old_format (void)
g_assert (s_ib);
/* MAC address */
array = nm_setting_infiniband_get_mac_address (s_ib);
g_assert (array);
g_assert_cmpint (array->len, ==, INFINIBAND_ALEN);
g_assert_cmpint (memcmp (array->data, expected_mac, sizeof (expected_mac)), ==, 0);
mac = nm_setting_infiniband_get_mac_address (s_ib);
g_assert (mac);
g_assert (nm_utils_hwaddr_matches (mac, -1, expected_mac, sizeof (expected_mac)));
g_object_unref (connection);
}
@ -1063,8 +1046,8 @@ test_read_valid_wireless_connection (void)
NMSettingWireless *s_wireless;
NMSettingIP4Config *s_ip4;
GError *error = NULL;
const GByteArray *array;
char expected_bssid[ETH_ALEN] = { 0x00, 0x1a, 0x33, 0x44, 0x99, 0x82 };
const char *bssid;
const guint8 expected_bssid[ETH_ALEN] = { 0x00, 0x1a, 0x33, 0x44, 0x99, 0x82 };
const char *tmp;
const char *expected_id = "Test Wireless Connection";
const char *expected_uuid = "2f962388-e5f3-45af-a62c-ac220b8f7baa";
@ -1136,18 +1119,13 @@ test_read_valid_wireless_connection (void)
NM_SETTING_WIRED_SETTING_NAME);
/* BSSID */
array = nm_setting_wireless_get_bssid (s_wireless);
ASSERT (array != NULL,
bssid = nm_setting_wireless_get_bssid (s_wireless);
ASSERT (bssid != NULL,
"connection-verify-wireless", "failed to verify %s: missing %s / %s key",
TEST_WIRELESS_FILE,
NM_SETTING_WIRELESS_SETTING_NAME,
NM_SETTING_WIRELESS_BSSID);
ASSERT (array->len == ETH_ALEN,
"connection-verify-wireless", "failed to verify %s: unexpected %s / %s key value length",
TEST_WIRELESS_FILE,
NM_SETTING_WIRELESS_SETTING_NAME,
NM_SETTING_WIRELESS_BSSID);
ASSERT (memcmp (array->data, &expected_bssid[0], sizeof (expected_bssid)) == 0,
ASSERT (nm_utils_hwaddr_matches (bssid, -1, expected_bssid, sizeof (expected_bssid)),
"connection-verify-wireless", "failed to verify %s: unexpected %s / %s key value",
TEST_WIRELESS_FILE,
NM_SETTING_WIRELESS_SETTING_NAME,
@ -1181,8 +1159,7 @@ test_write_wireless_connection (void)
NMSettingIP4Config *s_ip4;
NMSettingIP6Config *s_ip6;
char *uuid;
GByteArray *bssid;
unsigned char tmpbssid[] = { 0xaa, 0xb9, 0xa1, 0x74, 0x55, 0x44 };
const char *bssid = "aa:b9:a1:74:55:44";
GByteArray *ssid;
unsigned char tmpssid[] = { 0x31, 0x33, 0x33, 0x37 };
gboolean success;
@ -1215,9 +1192,6 @@ test_write_wireless_connection (void)
s_wireless = NM_SETTING_WIRELESS (nm_setting_wireless_new ());
nm_connection_add_setting (connection, NM_SETTING (s_wireless));
bssid = g_byte_array_sized_new (ETH_ALEN);
g_byte_array_append (bssid, &tmpbssid[0], sizeof (tmpbssid));
ssid = g_byte_array_sized_new (sizeof (tmpssid));
g_byte_array_append (ssid, &tmpssid[0], sizeof (tmpssid));
@ -1227,7 +1201,6 @@ test_write_wireless_connection (void)
NM_SETTING_WIRED_MTU, 1000,
NULL);
g_byte_array_free (bssid, TRUE);
g_byte_array_free (ssid, TRUE);
/* IP4 setting */
@ -1775,8 +1748,8 @@ test_read_bt_dun_connection (void)
NMSettingSerial *s_serial;
NMSettingGsm *s_gsm;
GError *error = NULL;
const GByteArray *array;
char expected_bdaddr[ETH_ALEN] = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55 };
const char *bdaddr;
const guint8 expected_bdaddr[ETH_ALEN] = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55 };
const char *tmp;
const char *expected_id = "AT&T Data Connect BT";
const char *expected_uuid = "089130ab-ce28-46e4-ad77-d44869b03d19";
@ -1834,18 +1807,13 @@ test_read_bt_dun_connection (void)
NM_SETTING_WIRED_SETTING_NAME);
/* BDADDR */
array = nm_setting_bluetooth_get_bdaddr (s_bluetooth);
ASSERT (array != NULL,
bdaddr = nm_setting_bluetooth_get_bdaddr (s_bluetooth);
ASSERT (bdaddr != NULL,
"connection-verify-bt", "failed to verify %s: missing %s / %s key",
TEST_BT_DUN_FILE,
NM_SETTING_BLUETOOTH_SETTING_NAME,
NM_SETTING_BLUETOOTH_BDADDR);
ASSERT (array->len == ETH_ALEN,
"connection-verify-bt", "failed to verify %s: unexpected %s / %s key value length",
TEST_BT_DUN_FILE,
NM_SETTING_BLUETOOTH_SETTING_NAME,
NM_SETTING_BLUETOOTH_BDADDR);
ASSERT (memcmp (array->data, &expected_bdaddr[0], sizeof (expected_bdaddr)) == 0,
ASSERT (nm_utils_hwaddr_matches (bdaddr, -1, expected_bdaddr, sizeof (expected_bdaddr)),
"connection-verify-bt", "failed to verify %s: unexpected %s / %s key value",
TEST_BT_DUN_FILE,
NM_SETTING_BLUETOOTH_SETTING_NAME,
@ -1931,8 +1899,7 @@ test_write_bt_dun_connection (void)
NMSettingIP4Config *s_ip4;
NMSettingGsm *s_gsm;
char *uuid;
GByteArray *bdaddr;
unsigned char tmpbdaddr[] = { 0xaa, 0xb9, 0xa1, 0x74, 0x55, 0x44 };
const char *bdaddr = "aa:b9:a1:74:55:44";
gboolean success;
NMConnection *reread;
char *testfile = NULL;
@ -1963,16 +1930,11 @@ test_write_bt_dun_connection (void)
s_bt = NM_SETTING_BLUETOOTH (nm_setting_bluetooth_new ());
nm_connection_add_setting (connection, NM_SETTING (s_bt));
bdaddr = g_byte_array_sized_new (ETH_ALEN);
g_byte_array_append (bdaddr, &tmpbdaddr[0], sizeof (tmpbdaddr));
g_object_set (s_bt,
NM_SETTING_BLUETOOTH_BDADDR, bdaddr,
NM_SETTING_BLUETOOTH_TYPE, NM_SETTING_BLUETOOTH_TYPE_DUN,
NULL);
g_byte_array_free (bdaddr, TRUE);
/* IP4 setting */
s_ip4 = NM_SETTING_IP4_CONFIG (nm_setting_ip4_config_new ());
@ -2776,7 +2738,7 @@ test_read_infiniband_connection (void)
NMSettingConnection *s_con;
NMSettingInfiniband *s_ib;
GError *error = NULL;
const GByteArray *array;
const char *mac;
guint8 expected_mac[INFINIBAND_ALEN] = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66,
0x77, 0x88, 0x99, 0x01, 0x12, 0x23, 0x34, 0x45, 0x56, 0x67, 0x78, 0x89,
0x90 };
@ -2801,10 +2763,9 @@ test_read_infiniband_connection (void)
s_ib = nm_connection_get_setting_infiniband (connection);
g_assert (s_ib);
array = nm_setting_infiniband_get_mac_address (s_ib);
g_assert (array);
g_assert_cmpint (array->len, ==, INFINIBAND_ALEN);
g_assert_cmpint (memcmp (array->data, expected_mac, sizeof (expected_mac)), ==, 0);
mac = nm_setting_infiniband_get_mac_address (s_ib);
g_assert (mac);
g_assert (nm_utils_hwaddr_matches (mac, -1, expected_mac, sizeof (expected_mac)));
g_object_unref (connection);
}
@ -2818,10 +2779,7 @@ test_write_infiniband_connection (void)
NMSettingIP4Config *s_ip4;
NMSettingIP6Config *s_ip6;
char *uuid;
GByteArray *mac;
guint8 tmpmac[] = { 0x99, 0x88, 0x77, 0x66, 0x55, 0x44, 0xab, 0xbc,
0xcd, 0xde, 0xef, 0xf0, 0x0a, 0x1b, 0x2c, 0x3d, 0x4e, 0x5f, 0x6f, 0xba
};
const char *mac = "99:88:77:66:55:44:ab:bc:cd:de:ef:f0:0a:1b:2c:3d:4e:5f:6f:ba";
gboolean success;
NMConnection *reread;
char *testfile = NULL;
@ -2852,14 +2810,11 @@ test_write_infiniband_connection (void)
g_assert (s_ib);
nm_connection_add_setting (connection, NM_SETTING (s_ib));
mac = g_byte_array_sized_new (sizeof (tmpmac));
g_byte_array_append (mac, &tmpmac[0], sizeof (tmpmac));
g_object_set (s_ib,
NM_SETTING_INFINIBAND_MAC_ADDRESS, mac,
NM_SETTING_INFINIBAND_MTU, 900,
NM_SETTING_INFINIBAND_TRANSPORT_MODE, "datagram",
NULL);
g_byte_array_free (mac, TRUE);
/* IP4 setting */
s_ip4 = (NMSettingIP4Config *) nm_setting_ip4_config_new ();
@ -3028,7 +2983,7 @@ test_read_bridge_component (void)
NMSettingConnection *s_con;
NMSettingBridgePort *s_port;
NMSettingWired *s_wired;
const GByteArray *array;
const char *mac;
guint8 expected_mac[ETH_ALEN] = { 0x00, 0x22, 0x15, 0x59, 0x62, 0x97 };
GError *error = NULL;
const char *expected_id = "Test Bridge Component";
@ -3053,10 +3008,9 @@ test_read_bridge_component (void)
/* Wired setting */
s_wired = nm_connection_get_setting_wired (connection);
g_assert (s_wired);
array = nm_setting_wired_get_mac_address (s_wired);
g_assert (array);
g_assert_cmpint (array->len, ==, ETH_ALEN);
g_assert_cmpint (memcmp (array->data, expected_mac, sizeof (expected_mac)), ==, 0);
mac = nm_setting_wired_get_mac_address (s_wired);
g_assert (mac);
g_assert (nm_utils_hwaddr_matches (mac, -1, expected_mac, sizeof (expected_mac)));
/* BridgePort setting */
s_port = nm_connection_get_setting_bridge_port (connection);
@ -3076,8 +3030,7 @@ test_write_bridge_component (void)
NMSettingBridgePort *s_port;
NMSettingWired *s_wired;
char *uuid;
GByteArray *mac;
guint8 tmpmac[] = { 0x99, 0x88, 0x77, 0x66, 0x55, 0x44 };
const char *mac = "99:88:77:66:55:44";
gboolean success;
NMConnection *reread;
char *testfile = NULL;
@ -3109,13 +3062,10 @@ test_write_bridge_component (void)
g_assert (s_wired);
nm_connection_add_setting (connection, NM_SETTING (s_wired));
mac = g_byte_array_sized_new (ETH_ALEN);
g_byte_array_append (mac, &tmpmac[0], sizeof (tmpmac));
g_object_set (s_wired,
NM_SETTING_WIRED_MAC_ADDRESS, mac,
NM_SETTING_WIRED_MTU, 1300,
NULL);
g_byte_array_free (mac, TRUE);
/* BridgePort setting */
s_port = (NMSettingBridgePort *) nm_setting_bridge_port_new ();
@ -3154,7 +3104,7 @@ test_read_new_wired_group_name (void)
{
NMConnection *connection;
NMSettingWired *s_wired;
const GByteArray *array;
const char *mac;
guint8 expected_mac[ETH_ALEN] = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55 };
GError *error = NULL;
gboolean success;
@ -3171,10 +3121,9 @@ test_read_new_wired_group_name (void)
g_assert (s_wired);
g_assert_cmpint (nm_setting_wired_get_mtu (s_wired), ==, 1400);
array = nm_setting_wired_get_mac_address (s_wired);
g_assert (array);
g_assert_cmpint (array->len, ==, ETH_ALEN);
g_assert_cmpint (memcmp (array->data, expected_mac, sizeof (expected_mac)), ==, 0);
mac = nm_setting_wired_get_mac_address (s_wired);
g_assert (mac);
g_assert (nm_utils_hwaddr_matches (mac, -1, expected_mac, sizeof (expected_mac)));
g_object_unref (connection);
}

50
src/settings/plugins/keyfile/writer.c
View file

@ -402,29 +402,6 @@ ip6_route_writer (GKeyFile *file,
}
static void
mac_address_writer (GKeyFile *file,
const char *keyfile_dir,
const char *uuid,
NMSetting *setting,
const char *key,
const GValue *value)
{
GByteArray *array;
const char *setting_name = nm_setting_get_name (setting);
char *mac;
g_return_if_fail (G_VALUE_HOLDS (value, DBUS_TYPE_G_UCHAR_ARRAY));
array = (GByteArray *) g_value_get_boxed (value);
if (!array || !array->len)
return;
mac = nm_utils_hwaddr_ntoa (array->data, array->len);
nm_keyfile_plugin_kf_set_string (file, setting_name, key, mac);
g_free (mac);
}
static void
write_hash_of_string (GKeyFile *file,
NMSetting *setting,
@ -773,9 +750,6 @@ static KeyWriter key_writers[] = {
{ NM_SETTING_CONNECTION_SETTING_NAME,
NM_SETTING_CONNECTION_TYPE,
setting_alias_writer },
{ NM_SETTING_BRIDGE_SETTING_NAME,
NM_SETTING_BRIDGE_MAC_ADDRESS,
mac_address_writer },
{ NM_SETTING_IP4_CONFIG_SETTING_NAME,
NM_SETTING_IP4_CONFIG_ADDRESSES,
ip4_addr_writer },
@ -797,30 +771,6 @@ static KeyWriter key_writers[] = {
{ NM_SETTING_IP6_CONFIG_SETTING_NAME,
NM_SETTING_IP6_CONFIG_DNS,
ip6_dns_writer },
{ NM_SETTING_WIRED_SETTING_NAME,
NM_SETTING_WIRED_MAC_ADDRESS,
mac_address_writer },
{ NM_SETTING_WIRED_SETTING_NAME,
NM_SETTING_WIRED_CLONED_MAC_ADDRESS,
mac_address_writer },
{ NM_SETTING_WIRELESS_SETTING_NAME,
NM_SETTING_WIRELESS_MAC_ADDRESS,
mac_address_writer },
{ NM_SETTING_WIRELESS_SETTING_NAME,
NM_SETTING_WIRELESS_CLONED_MAC_ADDRESS,
mac_address_writer },
{ NM_SETTING_WIRELESS_SETTING_NAME,
NM_SETTING_WIRELESS_BSSID,
mac_address_writer },
{ NM_SETTING_BLUETOOTH_SETTING_NAME,
NM_SETTING_BLUETOOTH_BDADDR,
mac_address_writer },
{ NM_SETTING_INFINIBAND_SETTING_NAME,
NM_SETTING_INFINIBAND_MAC_ADDRESS,
mac_address_writer },
{ NM_SETTING_WIMAX_SETTING_NAME,
NM_SETTING_WIMAX_MAC_ADDRESS,
mac_address_writer },
{ NM_SETTING_WIRELESS_SETTING_NAME,
NM_SETTING_WIRELESS_SSID,
ssid_writer },

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

@ -327,9 +327,6 @@ nm_supplicant_config_get_blobs (NMSupplicantConfig * self)
return NM_SUPPLICANT_CONFIG_GET_PRIVATE (self)->blobs;
}
#define MAC_FMT "%02x:%02x:%02x:%02x:%02x:%02x"
#define MAC_ARG(x) ((guint8*)(x))[0],((guint8*)(x))[1],((guint8*)(x))[2],((guint8*)(x))[3],((guint8*)(x))[4],((guint8*)(x))[5]
#define TWO_GHZ_FREQS "2412,2417,2422,2427,2432,2437,2442,2447,2452,2457,2462,2467,2472,2484"
#define FIVE_GHZ_FREQS "4915,4920,4925,4935,4940,4945,4960,4980,5035,5040,5045,5055,5060,5080," \
"5170,5180,5190,5200,5210,5220,5230,5240,5260,5280,5300,5320,5500," \
@ -345,7 +342,8 @@ nm_supplicant_config_add_setting_wireless (NMSupplicantConfig * self,
NMSupplicantConfigPrivate *priv;
gboolean is_adhoc, is_ap;
const char *mode, *band;
const GByteArray *id;
const GByteArray *ssid;
const char *bssid;
g_return_val_if_fail (NM_IS_SUPPLICANT_CONFIG (self), FALSE);
g_return_val_if_fail (setting != NULL, FALSE);
@ -360,8 +358,8 @@ nm_supplicant_config_add_setting_wireless (NMSupplicantConfig * self,
else
priv->ap_scan = 1;
id = nm_setting_wireless_get_ssid (setting);
if (!nm_supplicant_config_add_option (self, "ssid", (char *) id->data, id->len, FALSE)) {
ssid = nm_setting_wireless_get_ssid (setting);
if (!nm_supplicant_config_add_option (self, "ssid", (char *) ssid->data, ssid->len, FALSE)) {
nm_log_warn (LOGD_SUPPLICANT, "Error adding SSID to supplicant config.");
return FALSE;
}
@ -400,19 +398,14 @@ nm_supplicant_config_add_setting_wireless (NMSupplicantConfig * self,
return FALSE;
}
id = nm_setting_wireless_get_bssid (setting);
if (id && id->len) {
char *str_bssid;
str_bssid = g_strdup_printf (MAC_FMT, MAC_ARG (id->data));
bssid = nm_setting_wireless_get_bssid (setting);
if (bssid) {
if (!nm_supplicant_config_add_option (self, "bssid",
str_bssid, strlen (str_bssid),
bssid, strlen (bssid),
FALSE)) {
g_free (str_bssid);
nm_log_warn (LOGD_SUPPLICANT, "Error adding BSSID to supplicant config.");
return FALSE;
}
g_free (str_bssid);
}
band = nm_setting_wireless_get_band (setting);

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

@ -122,8 +122,6 @@ test_wifi_open (void)
GError *error = NULL;
GByteArray *ssid;
const unsigned char ssid_data[] = { 0x54, 0x65, 0x73, 0x74, 0x20, 0x53, 0x53, 0x49, 0x44 };
GByteArray *bssid;
const unsigned char bssid_data[] = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66 };
const char *bssid_str = "11:22:33:44:55:66";
connection = nm_simple_connection_new ();
@ -147,18 +145,15 @@ test_wifi_open (void)
ssid = g_byte_array_sized_new (sizeof (ssid_data));
g_byte_array_append (ssid, ssid_data, sizeof (ssid_data));
bssid = g_byte_array_sized_new (sizeof (bssid_data));
g_byte_array_append (bssid, bssid_data, sizeof (bssid_data));
g_object_set (s_wifi,
NM_SETTING_WIRELESS_SSID, ssid,
NM_SETTING_WIRELESS_BSSID, bssid,
NM_SETTING_WIRELESS_BSSID, bssid_str,
NM_SETTING_WIRELESS_MODE, "infrastructure",
NM_SETTING_WIRELESS_BAND, "bg",
NULL);
g_byte_array_free (ssid, TRUE);
g_byte_array_free (bssid, TRUE);
/* IP4 setting */
s_ip4 = (NMSettingIP4Config *) nm_setting_ip4_config_new ();
@ -223,8 +218,6 @@ test_wifi_wep_key (const char *detail,
GError *error = NULL;
GByteArray *ssid;
const unsigned char ssid_data[] = { 0x54, 0x65, 0x73, 0x74, 0x20, 0x53, 0x53, 0x49, 0x44 };
GByteArray *bssid;
const unsigned char bssid_data[] = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66 };
const char *bssid_str = "11:22:33:44:55:66";
connection = nm_simple_connection_new ();
@ -248,18 +241,15 @@ test_wifi_wep_key (const char *detail,
ssid = g_byte_array_sized_new (sizeof (ssid_data));
g_byte_array_append (ssid, ssid_data, sizeof (ssid_data));
bssid = g_byte_array_sized_new (sizeof (bssid_data));
g_byte_array_append (bssid, bssid_data, sizeof (bssid_data));
g_object_set (s_wifi,
NM_SETTING_WIRELESS_SSID, ssid,
NM_SETTING_WIRELESS_BSSID, bssid,
NM_SETTING_WIRELESS_BSSID, bssid_str,
NM_SETTING_WIRELESS_MODE, "infrastructure",
NM_SETTING_WIRELESS_BAND, "bg",
NULL);
g_byte_array_free (ssid, TRUE);
g_byte_array_free (bssid, TRUE);
/* Wifi Security setting */
s_wsec = (NMSettingWirelessSecurity *) nm_setting_wireless_security_new ();
@ -366,8 +356,6 @@ test_wifi_wpa_psk (const char *detail,
GError *error = NULL;
GByteArray *ssid;
const unsigned char ssid_data[] = { 0x54, 0x65, 0x73, 0x74, 0x20, 0x53, 0x53, 0x49, 0x44 };
GByteArray *bssid;
const unsigned char bssid_data[] = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66 };
const char *bssid_str = "11:22:33:44:55:66";
connection = nm_simple_connection_new ();
@ -391,18 +379,15 @@ test_wifi_wpa_psk (const char *detail,
ssid = g_byte_array_sized_new (sizeof (ssid_data));
g_byte_array_append (ssid, ssid_data, sizeof (ssid_data));
bssid = g_byte_array_sized_new (sizeof (bssid_data));
g_byte_array_append (bssid, bssid_data, sizeof (bssid_data));
g_object_set (s_wifi,
NM_SETTING_WIRELESS_SSID, ssid,
NM_SETTING_WIRELESS_BSSID, bssid,
NM_SETTING_WIRELESS_BSSID, bssid_str,
NM_SETTING_WIRELESS_MODE, "infrastructure",
NM_SETTING_WIRELESS_BAND, "bg",
NULL);
g_byte_array_free (ssid, TRUE);
g_byte_array_free (bssid, TRUE);
/* Wifi Security setting */
s_wsec = (NMSettingWirelessSecurity *) nm_setting_wireless_security_new ();