fdo-mirrors/NetworkManager
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/NetworkManager/NetworkManager.git synced 2026-01-30 23:20:35 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

device: merge branch 'th/preserve-fake-perm-hwaddr-bgo772880'

Browse source 
https://bugzilla.gnome.org/show_bug.cgi?id=772880
https://bugzilla.redhat.com/show_bug.cgi?id=1388286

(cherry picked from commit e2b7da7b82)
This commit is contained in:
Thomas Haller 2016-10-28 17:16:26 +02:00
commit 221851436b
29 changed files with 533 additions and 349 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
libnm-core/nm-core-internal.h
View file

@ -123,7 +123,10 @@ guint32 _nm_setting_get_setting_priority (NMSetting *setting);
gboolean _nm_setting_get_property (NMSetting *setting, const char *name, GValue *value);
guint _nm_utils_hwaddr_length (const char *asc);
#define NM_UTILS_HWADDR_LEN_MAX_STR (NM_UTILS_HWADDR_LEN_MAX * 3)
guint8 *_nm_utils_hwaddr_aton (const char *asc, gpointer buffer, gsize buffer_length, gsize *out_length);
const char *nm_utils_hwaddr_ntoa_buf (gconstpointer addr, gsize addr_len, gboolean upper_case, char *buf, gsize buf_len);
char *_nm_utils_bin2str (gconstpointer addr, gsize length, gboolean upper_case);

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

@ -2965,17 +2965,64 @@ nm_utils_wifi_strength_bars (guint8 strength)
gsize
nm_utils_hwaddr_len (int type)
{
g_return_val_if_fail (type == ARPHRD_ETHER || type == ARPHRD_INFINIBAND, 0);
if (type == ARPHRD_ETHER)
return ETH_ALEN;
else if (type == ARPHRD_INFINIBAND)
return INFINIBAND_ALEN;
g_assert_not_reached ();
g_return_val_if_reached (0);
}
#define HEXVAL(c) ((c) <= '9' ? (c) - '0' : ((c) & 0x4F) - 'A' + 10)
static guint8 *
hwaddr_aton (const char *asc, guint8 *buffer, gsize buffer_length, gsize *out_len)
{
const char *in = asc;
guint8 *out = buffer;
guint8 delimiter = '\0';
nm_assert (asc);
nm_assert (buffer);
nm_assert (buffer_length);
nm_assert (out_len);
while (TRUE) {
const guint8 d1 = in[0];
guint8 d2;
if (!g_ascii_isxdigit (d1))
return NULL;
#define HEXVAL(c) ((c) <= '9' ? (c) - '0' : ((c) & 0x4F) - ('A' - 10))
/* If there's no leading zero (ie "aa:b:cc") then fake it */
d2 = in[1];
if (d2 && g_ascii_isxdigit (d2)) {
*out++ = (HEXVAL (d1) << 4) + HEXVAL (d2);
d2 = in[2];
in += 3;
} else {
/* Fake leading zero */
*out++ = HEXVAL (d1);
in += 2;
}
if (!d2)
break;
if (--buffer_length == 0)
return NULL;
if (d2 != delimiter) {
if ( delimiter == '\0'
&& (d2 == ':' || d2 == '-'))
delimiter = d2;
else
return NULL;
}
}
*out_len = out - buffer;
return buffer;
}
/**
* nm_utils_hwaddr_atoba:
@ -2992,18 +3039,52 @@ GByteArray *
nm_utils_hwaddr_atoba (const char *asc, gsize length)
{
GByteArray *ba;
gsize l;
g_return_val_if_fail (asc != NULL, NULL);
g_return_val_if_fail (asc, NULL);
g_return_val_if_fail (length > 0 && length <= NM_UTILS_HWADDR_LEN_MAX, NULL);
ba = g_byte_array_sized_new (length);
g_byte_array_set_size (ba, length);
if (!nm_utils_hwaddr_aton (asc, ba->data, length)) {
g_byte_array_unref (ba);
return NULL;
}
if (!hwaddr_aton (asc, ba->data, length, &l))
goto fail;
if (length != l)
goto fail;
return ba;
fail:
g_byte_array_unref (ba);
return NULL;
}
/**
* _nm_utils_hwaddr_aton:
* @asc: the ASCII representation of a hardware address
* @buffer: buffer to store the result into. Must have
* at least a size of @buffer_length.
* @buffer_length: the length of the input buffer @buffer.
* The result must fit into that buffer, otherwise
* the function fails and returns %NULL.
* @out_length: the output length in case of success.
*
* Parses @asc and converts it to binary form in @buffer.
* Bytes in @asc can be sepatared by colons (:), or hyphens (-), but not mixed.
*
* It is like nm_utils_hwaddr_aton(), but contrary to that it
* can parse addresses of any length. That is, you don't need
* to know the length before-hand.
*
* Return value: @buffer, or %NULL if @asc couldn't be parsed.
*/
guint8 *
_nm_utils_hwaddr_aton (const char *asc, gpointer buffer, gsize buffer_length, gsize *out_length)
{
g_return_val_if_fail (asc, NULL);
g_return_val_if_fail (buffer, NULL);
g_return_val_if_fail (buffer_length > 0, NULL);
g_return_val_if_fail (out_length, NULL);
return hwaddr_aton (asc, buffer, buffer_length, out_length);
}
/**
@ -3022,72 +3103,55 @@ nm_utils_hwaddr_atoba (const char *asc, gsize length)
guint8 *
nm_utils_hwaddr_aton (const char *asc, gpointer buffer, gsize length)
{
const char *in = asc;
guint8 *out = (guint8 *)buffer;
char delimiter = '\0';
gsize l;
g_return_val_if_fail (asc != NULL, NULL);
g_return_val_if_fail (buffer != NULL, NULL);
g_return_val_if_fail (asc, NULL);
g_return_val_if_fail (buffer, NULL);
g_return_val_if_fail (length > 0 && length <= NM_UTILS_HWADDR_LEN_MAX, NULL);
while (length && *in) {
guint8 d1 = in[0], d2 = in[1];
if (!hwaddr_aton (asc, buffer, length, &l))
return NULL;
if (length != l)
return NULL;
return buffer;
}
if (!g_ascii_isxdigit (d1))
return NULL;
static void
_bin2str_buf (gconstpointer addr, gsize length, gboolean upper_case, char *out)
{
const guint8 *in = addr;
const char *LOOKUP = upper_case ? "0123456789ABCDEF" : "0123456789abcdef";
/* If there's no leading zero (ie "aa:b:cc") then fake it */
if (d2 && g_ascii_isxdigit (d2)) {
*out++ = (HEXVAL (d1) << 4) + HEXVAL (d2);
in += 2;
} else {
/* Fake leading zero */
*out++ = (HEXVAL ('0') << 4) + HEXVAL (d1);
in += 1;
}
nm_assert (addr);
nm_assert (out);
nm_assert (length > 0);
/* @out must contain at least @length*3 bytes */
for (;;) {
const guint8 v = *in++;
*out++ = LOOKUP[v >> 4];
*out++ = LOOKUP[v & 0x0F];
length--;
if (*in) {
if (delimiter == '\0') {
if (*in == ':' || *in == '-')
delimiter = *in;
else
return NULL;
} else {
if (*in != delimiter)
return NULL;
}
in++;
}
if (!length)
break;
*out++ = ':';
}
if (length == 0 && !*in)
return buffer;
else
return NULL;
*out = 0;
}
static char *
_bin2str (gconstpointer addr, gsize length, gboolean upper_case)
{
const guint8 *in = addr;
char *out, *result;
const char *LOOKUP = upper_case ? "0123456789ABCDEF" : "0123456789abcdef";
char *result;
g_return_val_if_fail (addr != NULL, g_strdup (""));
g_return_val_if_fail (length > 0, g_strdup (""));
nm_assert (addr);
nm_assert (length > 0);
result = out = g_malloc (length * 3);
while (length--) {
guint8 v = *in++;
*out++ = LOOKUP[v >> 4];
*out++ = LOOKUP[v & 0x0F];
if (length)
*out++ = ':';
}
*out = 0;
result = g_malloc (length * 3);
_bin2str_buf (addr, length, upper_case, result);
return result;
}
@ -3103,9 +3167,25 @@ _bin2str (gconstpointer addr, gsize length, gboolean upper_case)
char *
nm_utils_hwaddr_ntoa (gconstpointer addr, gsize length)
{
g_return_val_if_fail (addr, g_strdup (""));
g_return_val_if_fail (length > 0, g_strdup (""));
return _bin2str (addr, length, TRUE);
}
const char *
nm_utils_hwaddr_ntoa_buf (gconstpointer addr, gsize addr_len, gboolean upper_case, char *buf, gsize buf_len)
{
g_return_val_if_fail (addr, NULL);
g_return_val_if_fail (addr_len > 0, NULL);
g_return_val_if_fail (buf, NULL);
if (buf_len < addr_len * 3)
g_return_val_if_reached (NULL);
_bin2str_buf (addr, addr_len, TRUE, buf);
return buf;
}
/**
* _nm_utils_bin2str:
* @addr: (type guint8) (array length=length): a binary hardware address
@ -3119,51 +3199,12 @@ nm_utils_hwaddr_ntoa (gconstpointer addr, gsize length)
char *
_nm_utils_bin2str (gconstpointer addr, gsize length, gboolean upper_case)
{
g_return_val_if_fail (addr, g_strdup (""));
g_return_val_if_fail (length > 0, g_strdup (""));
return _bin2str (addr, length, upper_case);
}
static int
hwaddr_binary_len (const char *asc)
{
int octets = 1;
if (!*asc)
return 0;
for (; *asc; asc++) {
if (*asc == ':' || *asc == '-')
octets++;
}
return octets;
}
/**
* _nm_utils_hwaddr_length:
* @asc: the ASCII representation of the hardware address
*
* Validates that @asc is a valid representation of a hardware
* address up to (including) %NM_UTILS_HWADDR_LEN_MAX bytes.
*
* Returns: binary length of the hardware address @asc or
* 0 on error.
*/
guint
_nm_utils_hwaddr_length (const char *asc)
{
int l;
if (!asc)
return 0;
l = hwaddr_binary_len (asc);
if (l <= 0 || l > NM_UTILS_HWADDR_LEN_MAX)
return 0;
if (!nm_utils_hwaddr_valid (asc, l))
return 0;
return l;
}
/**
* nm_utils_hwaddr_valid:
* @asc: the ASCII representation of a hardware address
@ -3180,17 +3221,18 @@ gboolean
nm_utils_hwaddr_valid (const char *asc, gssize length)
{
guint8 buf[NM_UTILS_HWADDR_LEN_MAX];
gsize l;
g_return_val_if_fail (asc != NULL, FALSE);
g_return_val_if_fail (length == -1 || (length > 0 && length <= NM_UTILS_HWADDR_LEN_MAX), FALSE);
if (length == -1) {
length = hwaddr_binary_len (asc);
if (length == 0 || length > NM_UTILS_HWADDR_LEN_MAX)
if (length > 0 && length <= NM_UTILS_HWADDR_LEN_MAX) {
if (!hwaddr_aton (asc, buf, length, &l))
return FALSE;
}
return nm_utils_hwaddr_aton (asc, buf, length) != NULL;
return length == l;
} else if (length == -1) {
return !!hwaddr_aton (asc, buf, sizeof (buf), &l);
} else
g_return_val_if_reached (FALSE);
}
/**
@ -3210,20 +3252,23 @@ char *
nm_utils_hwaddr_canonical (const char *asc, gssize length)
{
guint8 buf[NM_UTILS_HWADDR_LEN_MAX];
gsize l;
g_return_val_if_fail (asc != NULL, NULL);
g_return_val_if_fail (asc, NULL);
g_return_val_if_fail (length == -1 || (length > 0 && length <= NM_UTILS_HWADDR_LEN_MAX), NULL);
if (length == -1) {
length = hwaddr_binary_len (asc);
if (length == 0 || length > NM_UTILS_HWADDR_LEN_MAX)
if (length > 0 && length <= NM_UTILS_HWADDR_LEN_MAX) {
if (!hwaddr_aton (asc, buf, length, &l))
return NULL;
}
if (l != length)
return NULL;
} else if (length == -1) {
if (!hwaddr_aton (asc, buf, NM_UTILS_HWADDR_LEN_MAX, &l))
return NULL;
} else
g_return_val_if_reached (NULL);
if (nm_utils_hwaddr_aton (asc, buf, length) == NULL)
return NULL;
return nm_utils_hwaddr_ntoa (buf, length);
return nm_utils_hwaddr_ntoa (buf, l);
}
/* This is used to possibly canonicalize values passed to MAC address property
@ -3287,17 +3332,17 @@ nm_utils_hwaddr_matches (gconstpointer hwaddr1,
gssize hwaddr2_len)
{
guint8 buf1[NM_UTILS_HWADDR_LEN_MAX], buf2[NM_UTILS_HWADDR_LEN_MAX];
gsize l;
if (hwaddr1_len == -1) {
g_return_val_if_fail (hwaddr1 != NULL, FALSE);
hwaddr1_len = hwaddr_binary_len (hwaddr1);
if (hwaddr1_len == 0 || hwaddr1_len > NM_UTILS_HWADDR_LEN_MAX)
if (!hwaddr_aton (hwaddr1, buf1, sizeof (buf1), &l)) {
g_return_val_if_fail ((hwaddr2_len == -1 && hwaddr2) || (hwaddr2_len > 0 && hwaddr2_len <= NM_UTILS_HWADDR_LEN_MAX), FALSE);
return FALSE;
if (!nm_utils_hwaddr_aton (hwaddr1, buf1, hwaddr1_len))
return FALSE;
}
hwaddr1 = buf1;
hwaddr1_len = l;
} else {
g_return_val_if_fail (hwaddr1_len > 0 && hwaddr1_len <= NM_UTILS_HWADDR_LEN_MAX, FALSE);
@ -3310,23 +3355,24 @@ nm_utils_hwaddr_matches (gconstpointer hwaddr1,
if (hwaddr2_len == -1) {
g_return_val_if_fail (hwaddr2 != NULL, FALSE);
if (!nm_utils_hwaddr_aton (hwaddr2, buf2, hwaddr1_len))
if (!hwaddr_aton (hwaddr2, buf2, sizeof (buf2), &l))
return FALSE;
if (l != hwaddr1_len)
return FALSE;
hwaddr2 = buf2;
hwaddr2_len = hwaddr1_len;
} else {
g_return_val_if_fail (hwaddr2_len > 0 && hwaddr2_len <= NM_UTILS_HWADDR_LEN_MAX, FALSE);
if (hwaddr2_len != hwaddr1_len)
return FALSE;
if (!hwaddr2) {
memset (buf2, 0, hwaddr2_len);
hwaddr2 = buf2;
}
}
if (hwaddr1_len != hwaddr2_len)
return FALSE;
if (hwaddr1_len == INFINIBAND_ALEN) {
hwaddr1 = (guint8 *)hwaddr1 + INFINIBAND_ALEN - 8;
hwaddr2 = (guint8 *)hwaddr2 + INFINIBAND_ALEN - 8;
@ -3342,16 +3388,11 @@ static GVariant *
_nm_utils_hwaddr_to_dbus_impl (const char *str)
{
guint8 buf[NM_UTILS_HWADDR_LEN_MAX];
int len;
gsize len;
if (!str)
return NULL;
len = _nm_utils_hwaddr_length (str);
if (len == 0)
return NULL;
if (!nm_utils_hwaddr_aton (str, buf, len))
if (!hwaddr_aton (str, buf, sizeof (buf), &len))
return NULL;
return g_variant_new_fixed_array (G_VARIANT_TYPE_BYTE, buf, len, 1);

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

@ -2527,7 +2527,7 @@ test_setting_compare_wireless_cloned_mac_address (void)
g_assert_cmpstr ("stable-bia", ==, nm_setting_wireless_get_cloned_mac_address ((NMSettingWireless *) new));
g_object_get (new, NM_SETTING_WIRELESS_CLONED_MAC_ADDRESS, &str1, NULL);
g_assert_cmpstr ("stable-bia", ==, str1);
g_clear_pointer (&str1, g_free);
nm_clear_g_free (&str1);
success = nm_setting_compare (old, new, NM_SETTING_COMPARE_FLAG_EXACT);
g_assert (!success);

23
shared/nm-utils/nm-macros-internal.h
View file

@ -300,9 +300,11 @@ nm_strdup_not_empty (const char *str)
#if NM_MORE_ASSERTS
#define nm_assert(cond) G_STMT_START { g_assert (cond); } G_STMT_END
#define nm_assert_se(cond) G_STMT_START { if (G_LIKELY (cond)) { ; } else { g_assert (FALSE && (cond)); } } G_STMT_END
#define nm_assert_not_reached() G_STMT_START { g_assert_not_reached (); } G_STMT_END
#else
#define nm_assert(cond) G_STMT_START { if (FALSE) { if (cond) { } } } G_STMT_END
#define nm_assert_se(cond) G_STMT_START { if (G_LIKELY (cond)) { ; } } G_STMT_END
#define nm_assert_not_reached() G_STMT_START { ; } G_STMT_END
#endif
@ -366,6 +368,27 @@ nm_g_object_unref (gpointer obj)
g_object_unref (obj);
}
/* basically, replaces
* g_clear_pointer (&location, g_free)
* with
* nm_clear_g_free (&location)
*
* Another advantage is that by using a macro and typeof(), it is more
* typesafe and gives you for example a compiler warning when pp is a const
* pointer or points to a const-pointer.
*/
#define nm_clear_g_free(pp) \
({ \
typeof (*(pp)) *_pp = (pp); \
typeof (**_pp) *_p = *_pp; \
\
if (_p) { \
*_pp = NULL; \
g_free (_p); \
} \
!!_p; \
})
static inline gboolean
nm_clear_g_source (guint *id)
{

14
src/devices/adsl/nm-atm-manager.c
View file

@ -68,7 +68,7 @@ dev_get_attrs (GUdevDevice *udev_device,
path = g_udev_device_get_sysfs_path (udev_device);
if (!path) {
nm_log_warn (LOGD_HW, "couldn't determine device path; ignoring...");
nm_log_warn (LOGD_PLATFORM, "couldn't determine device path; ignoring...");
return FALSE;
}
@ -110,11 +110,11 @@ adsl_add (NMAtmManager *self, GUdevDevice *udev_device)
ifname = g_udev_device_get_name (udev_device);
if (!ifname) {
nm_log_warn (LOGD_HW, "failed to get device's interface name");
nm_log_warn (LOGD_PLATFORM, "failed to get device's interface name");
return;
}
nm_log_dbg (LOGD_HW, "(%s): found ATM device", ifname);
nm_log_dbg (LOGD_PLATFORM, "(%s): found ATM device", ifname);
atm_index_path = g_strdup_printf ("/sys/class/atm/%s/atmindex",
NM_ASSERT_VALID_PATH_COMPONENT (ifname));
@ -123,12 +123,12 @@ adsl_add (NMAtmManager *self, GUdevDevice *udev_device)
10, 0, G_MAXINT,
-1);
if (atm_index < 0) {
nm_log_warn (LOGD_HW, "(%s): failed to get ATM index", ifname);
nm_log_warn (LOGD_PLATFORM, "(%s): failed to get ATM index", ifname);
return;
}
if (!dev_get_attrs (udev_device, &sysfs_path, &driver)) {
nm_log_warn (LOGD_HW, "(%s): failed to get ATM attributes", ifname);
nm_log_warn (LOGD_PLATFORM, "(%s): failed to get ATM attributes", ifname);
return;
}
@ -153,7 +153,7 @@ adsl_remove (NMAtmManager *self, GUdevDevice *udev_device)
const char *iface = g_udev_device_get_name (udev_device);
GSList *iter;
nm_log_dbg (LOGD_HW, "(%s): removing ATM device", iface);
nm_log_dbg (LOGD_PLATFORM, "(%s): removing ATM device", iface);
for (iter = priv->devices; iter; iter = iter->next) {
NMDevice *device = iter->data;
@ -210,7 +210,7 @@ handle_uevent (GUdevClient *client,
ifindex = g_udev_device_get_property (device, "IFINDEX");
seqnum = g_udev_device_get_seqnum (device);
nm_log_dbg (LOGD_HW, "UDEV event: action '%s' subsys '%s' device '%s' (%s); seqnum=%" G_GUINT64_FORMAT,
nm_log_dbg (LOGD_PLATFORM, "UDEV event: action '%s' subsys '%s' device '%s' (%s); seqnum=%" G_GUINT64_FORMAT,
action, subsys, g_udev_device_get_name (device), ifindex ? ifindex : "unknown", seqnum);
if (!strcmp (action, "add"))

2
src/devices/nm-device-bond.c
View file

@ -129,7 +129,7 @@ set_bond_attr (NMDevice *device, NMBondMode mode, const char *attr, const char *
ret = nm_platform_sysctl_master_set_option (NM_PLATFORM_GET, ifindex, attr, value);
if (!ret)
_LOGW (LOGD_HW, "failed to set bonding attribute '%s' to '%s'", attr, value);
_LOGW (LOGD_PLATFORM, "failed to set bonding attribute '%s' to '%s'", attr, value);
return ret;
}

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

@ -188,7 +188,7 @@ _update_s390_subchannels (NMDeviceEthernet *self)
parent_path = g_udev_device_get_sysfs_path (parent);
dir = g_dir_open (parent_path, 0, &error);
if (!dir) {
_LOGW (LOGD_DEVICE | LOGD_HW, "update-s390: failed to open directory '%s': %s",
_LOGW (LOGD_DEVICE | LOGD_PLATFORM, "update-s390: failed to open directory '%s': %s",
parent_path, error->message);
g_clear_error (&error);
return;
@ -218,11 +218,11 @@ _update_s390_subchannels (NMDeviceEthernet *self)
g_hash_table_insert (priv->s390_options, g_strdup (item), value);
value = NULL;
} else
_LOGW (LOGD_DEVICE | LOGD_HW, "update-s390: error reading %s", path);
_LOGW (LOGD_DEVICE | LOGD_PLATFORM, "update-s390: error reading %s", path);
}
if (error) {
_LOGW (LOGD_DEVICE | LOGD_HW, "update-s390: failed reading sysfs for %s (%s)", item, error->message);
_LOGW (LOGD_DEVICE | LOGD_PLATFORM, "update-s390: failed reading sysfs for %s (%s)", item, error->message);
g_clear_error (&error);
}
}
@ -247,7 +247,7 @@ _update_s390_subchannels (NMDeviceEthernet *self)
priv->subchannels_dbus[2] = g_strdup (priv->subchan3);
priv->subchannels_dbus[3] = NULL;
_LOGI (LOGD_DEVICE | LOGD_HW, "update-s390: found s390 '%s' subchannels [%s]",
_LOGI (LOGD_DEVICE | LOGD_PLATFORM, "update-s390: found s390 '%s' subchannels [%s]",
nm_device_get_driver ((NMDevice *) self) ?: "(unknown driver)",
priv->subchannels);
@ -311,7 +311,7 @@ get_generic_capabilities (NMDevice *device)
if (nm_platform_link_supports_carrier_detect (NM_PLATFORM_GET, nm_device_get_ifindex (device)))
return NM_DEVICE_CAP_CARRIER_DETECT;
else {
_LOGI (LOGD_HW, "driver '%s' does not support carrier detection.",
_LOGI (LOGD_PLATFORM, "driver '%s' does not support carrier detection.",
nm_device_get_driver (device));
return NM_DEVICE_CAP_NONE;
}
@ -396,7 +396,7 @@ check_connection_compatible (NMDevice *device, NMConnection *connection)
if (!match_subchans (self, s_wired, &try_mac))
return FALSE;
perm_hw_addr = nm_device_get_permanent_hw_address (device, TRUE);
perm_hw_addr = nm_device_get_permanent_hw_address (device);
mac = nm_setting_wired_get_mac_address (s_wired);
if (perm_hw_addr) {
if (try_mac && mac && !nm_utils_hwaddr_matches (mac, -1, perm_hw_addr, -1))
@ -1324,7 +1324,7 @@ deactivate (NMDevice *device)
s_dcb = (NMSettingDcb *) nm_device_get_applied_setting (device, NM_TYPE_SETTING_DCB);
if (s_dcb) {
if (!nm_dcb_cleanup (nm_device_get_iface (device), &error)) {
_LOGW (LOGD_DEVICE | LOGD_HW, "failed to disable DCB/FCoE: %s",
_LOGW (LOGD_DEVICE | LOGD_PLATFORM, "failed to disable DCB/FCoE: %s",
error->message);
g_clear_error (&error);
}
@ -1346,6 +1346,7 @@ complete_connection (NMDevice *device,
NMSettingPppoe *s_pppoe;
const char *setting_mac;
const char *perm_hw_addr;
gboolean perm_hw_addr_is_fake;
s_pppoe = nm_connection_get_setting_pppoe (connection);
@ -1373,8 +1374,8 @@ complete_connection (NMDevice *device,
nm_connection_add_setting (connection, NM_SETTING (s_wired));
}
perm_hw_addr = nm_device_get_permanent_hw_address (device, FALSE);
if (perm_hw_addr) {
perm_hw_addr = nm_device_get_permanent_hw_address_full (device, TRUE, &perm_hw_addr_is_fake);
if (perm_hw_addr && !perm_hw_addr_is_fake) {
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 */
@ -1410,7 +1411,7 @@ new_default_connection (NMDevice *self)
if (nm_config_get_no_auto_default_for_device (nm_config_get (), self))
return NULL;
perm_hw_addr = nm_device_get_permanent_hw_address (self, TRUE);
perm_hw_addr = nm_device_get_permanent_hw_address (self);
if (!perm_hw_addr)
return NULL;
@ -1470,7 +1471,8 @@ update_connection (NMDevice *device, NMConnection *connection)
{
NMDeviceEthernetPrivate *priv = NM_DEVICE_ETHERNET_GET_PRIVATE ((NMDeviceEthernet *) device);
NMSettingWired *s_wired = nm_connection_get_setting_wired (connection);
const char *perm_hw_addr = nm_device_get_permanent_hw_address (device, FALSE);
gboolean perm_hw_addr_is_fake;
const char *perm_hw_addr;
const char *mac = nm_device_get_hw_address (device);
const char *mac_prop = NM_SETTING_WIRED_MAC_ADDRESS;
GHashTableIter iter;
@ -1489,7 +1491,8 @@ update_connection (NMDevice *device, NMConnection *connection)
/* If the device reports a permanent address, use that for the MAC address
* and the current MAC, if different, is the cloned MAC.
*/
if (perm_hw_addr) {
perm_hw_addr = nm_device_get_permanent_hw_address_full (device, TRUE, &perm_hw_addr_is_fake);
if (perm_hw_addr && !perm_hw_addr_is_fake) {
g_object_set (s_wired, NM_SETTING_WIRED_MAC_ADDRESS, perm_hw_addr, NULL);
mac_prop = NULL;
@ -1529,7 +1532,7 @@ get_link_speed (NMDevice *device)
priv->speed = speed;
_notify (self, PROP_SPEED);
_LOGD (LOGD_HW | LOGD_ETHER, "speed is now %d Mb/s", speed);
_LOGD (LOGD_PLATFORM | LOGD_ETHER, "speed is now %d Mb/s", speed);
}
static void

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

@ -369,7 +369,7 @@ read_device_factory_paths (void)
dir = g_dir_open (NMPLUGINDIR, 0, &error);
if (!dir) {
nm_log_warn (LOGD_HW, "device plugin: failed to open directory %s: %s",
nm_log_warn (LOGD_PLATFORM, "device plugin: failed to open directory %s: %s",
NMPLUGINDIR,
error->message);
g_clear_error (&error);
@ -391,17 +391,17 @@ read_device_factory_paths (void)
if (stat (data.path, &data.st) != 0) {
errsv = errno;
nm_log_warn (LOGD_HW, "device plugin: skip invalid file %s (error during stat: %s)", data.path, strerror (errsv));
nm_log_warn (LOGD_PLATFORM, "device plugin: skip invalid file %s (error during stat: %s)", data.path, strerror (errsv));
goto NEXT;
}
if (!S_ISREG (data.st.st_mode))
goto NEXT;
if (data.st.st_uid != 0) {
nm_log_warn (LOGD_HW, "device plugin: skip invalid file %s (file must be owned by root)", data.path);
nm_log_warn (LOGD_PLATFORM, "device plugin: skip invalid file %s (file must be owned by root)", data.path);
goto NEXT;
}
if (data.st.st_mode & (S_IWGRP | S_IWOTH | S_ISUID)) {
nm_log_warn (LOGD_HW, "device plugin: skip invalid file %s (invalid file permissions)", data.path);
nm_log_warn (LOGD_PLATFORM, "device plugin: skip invalid file %s (invalid file permissions)", data.path);
goto NEXT;
}
@ -443,7 +443,7 @@ _add_factory (NMDeviceFactory *factory,
if (check_duplicates) {
found = find_factory (link_types, setting_types);
if (found) {
nm_log_warn (LOGD_HW, "Loading device plugin failed: multiple plugins "
nm_log_warn (LOGD_PLATFORM, "Loading device plugin failed: multiple plugins "
"for same type (using '%s' instead of '%s')",
(char *) g_object_get_data (G_OBJECT (found), PLUGIN_PATH_TAG),
path);
@ -459,7 +459,7 @@ _add_factory (NMDeviceFactory *factory,
callback (factory, user_data);
nm_log_info (LOGD_HW, "Loaded device plugin: %s (%s)", G_OBJECT_TYPE_NAME (factory), path);
nm_log_info (LOGD_PLATFORM, "Loaded device plugin: %s (%s)", G_OBJECT_TYPE_NAME (factory), path);
return TRUE;
}
@ -502,12 +502,12 @@ nm_device_factory_manager_load_factories (NMDeviceFactoryManagerFactoryFunc call
plugin = g_module_open (*path, G_MODULE_BIND_LOCAL);
if (!plugin) {
nm_log_warn (LOGD_HW, "(%s): failed to load plugin: %s", item, g_module_error ());
nm_log_warn (LOGD_PLATFORM, "(%s): failed to load plugin: %s", item, g_module_error ());
continue;
}
if (!g_module_symbol (plugin, "nm_device_factory_create", (gpointer) &create_func)) {
nm_log_warn (LOGD_HW, "(%s): failed to find device factory creator: %s", item, g_module_error ());
nm_log_warn (LOGD_PLATFORM, "(%s): failed to find device factory creator: %s", item, g_module_error ());
g_module_close (plugin);
continue;
}
@ -518,7 +518,7 @@ nm_device_factory_manager_load_factories (NMDeviceFactoryManagerFactoryFunc call
factory = create_func (&error);
if (!factory) {
nm_log_warn (LOGD_HW, "(%s): failed to initialize device factory: %s",
nm_log_warn (LOGD_PLATFORM, "(%s): failed to initialize device factory: %s",
item, NM_G_ERROR_MSG (error));
g_clear_error (&error);
continue;

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

@ -151,7 +151,7 @@ check_connection_compatible (NMDevice *device, NMConnection *connection)
mac = nm_setting_infiniband_get_mac_address (s_infiniband);
if (mac) {
hw_addr = nm_device_get_permanent_hw_address (device, TRUE);
hw_addr = nm_device_get_permanent_hw_address (device);
if ( !hw_addr
|| !nm_utils_hwaddr_matches (mac, -1, hw_addr, -1))
return FALSE;
@ -188,7 +188,7 @@ complete_connection (NMDevice *device,
}
setting_mac = nm_setting_infiniband_get_mac_address (s_infiniband);
hw_address = nm_device_get_permanent_hw_address (device, TRUE);
hw_address = nm_device_get_permanent_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, -1, hw_address, -1)) {
@ -214,7 +214,7 @@ static void
update_connection (NMDevice *device, NMConnection *connection)
{
NMSettingInfiniband *s_infiniband = nm_connection_get_setting_infiniband (connection);
const char *mac = nm_device_get_permanent_hw_address (device, TRUE);
const char *mac = nm_device_get_permanent_hw_address (device);
const char *transport_mode = "datagram";
int ifindex;

8
src/devices/nm-device-ip-tunnel.c
View file

@ -160,7 +160,7 @@ clear:
lnk = nm_platform_link_get_lnk_gre (NM_PLATFORM_GET, ifindex, NULL);
if (!lnk) {
_LOGW (LOGD_HW, "could not read %s properties", "gre");
_LOGW (LOGD_PLATFORM, "could not read %s properties", "gre");
goto clear;
}
@ -205,7 +205,7 @@ clear:
lnk = nm_platform_link_get_lnk_sit (NM_PLATFORM_GET, ifindex, NULL);
if (!lnk) {
_LOGW (LOGD_HW, "could not read %s properties", "sit");
_LOGW (LOGD_PLATFORM, "could not read %s properties", "sit");
goto clear;
}
@ -220,7 +220,7 @@ clear:
lnk = nm_platform_link_get_lnk_ipip (NM_PLATFORM_GET, ifindex, NULL);
if (!lnk) {
_LOGW (LOGD_HW, "could not read %s properties", "ipip");
_LOGW (LOGD_PLATFORM, "could not read %s properties", "ipip");
goto clear;
}
@ -236,7 +236,7 @@ clear:
lnk = nm_platform_link_get_lnk_ip6tnl (NM_PLATFORM_GET, ifindex, NULL);
if (!lnk) {
_LOGW (LOGD_HW, "could not read %s properties", "ip6tnl");
_LOGW (LOGD_PLATFORM, "could not read %s properties", "ip6tnl");
goto clear;
}

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

@ -180,7 +180,7 @@ update_properties (NMDevice *device)
props = nm_platform_link_get_lnk_macvlan (NM_PLATFORM_GET, nm_device_get_ifindex (device), &plink);
if (!props) {
_LOGW (LOGD_HW, "could not get %s properties", priv->props.tap ? "macvtap" : "macvlan");
_LOGW (LOGD_PLATFORM, "could not get %s properties", priv->props.tap ? "macvtap" : "macvlan");
return;
}
@ -373,7 +373,7 @@ match_hwaddr (NMDevice *device, NMConnection *connection, gboolean fail_if_no_hw
if (!priv->parent)
return !fail_if_no_hwaddr;
parent_mac = nm_device_get_permanent_hw_address (priv->parent, FALSE);
parent_mac = nm_device_get_permanent_hw_address (priv->parent);
return parent_mac && nm_utils_hwaddr_matches (setting_mac, -1, parent_mac, -1);
}

2
src/devices/nm-device-tun.c
View file

@ -171,7 +171,7 @@ update_connection (NMDevice *device, NMConnection *connection)
}
if (!nm_platform_link_tun_get_properties (NM_PLATFORM_GET, nm_device_get_ifindex (device), &props)) {
_LOGW (LOGD_HW, "failed to get TUN interface info while updating connection.");
_LOGW (LOGD_PLATFORM, "failed to get TUN interface info while updating connection.");
return;
}

2
src/devices/nm-device-veth.c
View file

@ -91,7 +91,7 @@ get_peer (NMDeviceVeth *self)
return priv->peer;
if (!nm_platform_link_veth_get_properties (NM_PLATFORM_GET, nm_device_get_ifindex (device), &peer_ifindex)) {
_LOGW (LOGD_HW, "could not read veth properties");
_LOGW (LOGD_PLATFORM, "could not read veth properties");
return NULL;
}

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

@ -391,7 +391,7 @@ match_hwaddr (NMDevice *device, NMConnection *connection, gboolean fail_if_no_hw
if (!priv->parent)
return !fail_if_no_hwaddr;
parent_mac = nm_device_get_permanent_hw_address (priv->parent, FALSE);
parent_mac = nm_device_get_permanent_hw_address (priv->parent);
return parent_mac && nm_utils_hwaddr_matches (setting_mac, -1, parent_mac, -1);
}

2
src/devices/nm-device-vxlan.c
View file

@ -84,7 +84,7 @@ update_properties (NMDevice *device)
props = nm_platform_link_get_lnk_vxlan (NM_PLATFORM_GET, nm_device_get_ifindex (device), NULL);
if (!props) {
_LOGW (LOGD_HW, "could not get vxlan properties");
_LOGW (LOGD_PLATFORM, "could not get vxlan properties");
return;
}

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

@ -226,10 +226,18 @@ typedef struct _NMDevicePrivate {
char * iface; /* may change, could be renamed by user */
int ifindex;
guint hw_addr_len;
union {
const guint8 hw_addr_len; /* read-only */
guint8 hw_addr_len_;
};
guint8 /*HwAddrType*/ hw_addr_type;
bool real;
bool real:1;
/* there was a IP config change, but no idle action was scheduled because device
* is still not platform-init */
bool queued_ip4_config_pending:1;
bool queued_ip6_config_pending:1;
char * ip_iface;
int ip_ifindex;
@ -756,7 +764,7 @@ nm_device_set_ip_iface (NMDevice *self, const char *iface)
nm_platform_link_set_up (NM_PLATFORM_GET, priv->ip_ifindex, NULL);
} else {
/* Device IP interface must always be a kernel network interface */
_LOGW (LOGD_HW, "failed to look up interface index");
_LOGW (LOGD_PLATFORM, "failed to look up interface index");
}
}
@ -899,7 +907,7 @@ get_ip_iface_identifier (NMDevice *self, NMUtilsIPv6IfaceId *out_iid)
priv->dev_id,
out_iid);
if (!success) {
_LOGW (LOGD_HW, "failed to generate interface identifier "
_LOGW (LOGD_PLATFORM, "failed to generate interface identifier "
"for link type %u hwaddr_len %u", pllink->type, (unsigned) pllink->addr.len);
}
return success;
@ -1818,7 +1826,7 @@ device_link_changed (NMDevice *self)
had_hw_addr = (priv->hw_addr != NULL);
nm_device_update_hw_address (self);
got_hw_addr = (!had_hw_addr && priv->hw_addr);
nm_device_update_permanent_hw_address (self);
nm_device_update_permanent_hw_address (self, FALSE);
if (info.name[0] && strcmp (priv->iface, info.name) != 0) {
_LOGI (LOGD_DEVICE, "interface index %d renamed iface from '%s' to '%s'",
@ -1830,7 +1838,7 @@ device_link_changed (NMDevice *self)
ip_ifname_changed = !priv->ip_iface;
if (nm_device_get_unmanaged_flags (self, NM_UNMANAGED_PLATFORM_INIT))
nm_device_set_unmanaged_by_user_settings (self, nm_settings_get_unmanaged_specs (priv->settings));
nm_device_set_unmanaged_by_user_settings (self);
else
update_unmanaged_specs = TRUE;
@ -1909,7 +1917,7 @@ device_link_changed (NMDevice *self)
}
if (update_unmanaged_specs)
nm_device_set_unmanaged_by_user_settings (self, nm_settings_get_unmanaged_specs (priv->settings));
nm_device_set_unmanaged_by_user_settings (self);
if ( got_hw_addr
&& !priv->up
@ -2278,13 +2286,12 @@ realize_start_setup (NMDevice *self, const NMPlatformLink *plink)
_notify (self, PROP_UDI);
}
/* trigger initial ip config change to initialize ip-config */
priv->queued_ip4_config_id = g_idle_add (queued_ip4_config_change, self);
priv->queued_ip6_config_id = g_idle_add (queued_ip6_config_change, self);
priv->queued_ip4_config_pending = TRUE;
priv->queued_ip6_config_pending = TRUE;
nm_device_update_hw_address (self);
nm_device_update_initial_hw_address (self);
nm_device_update_permanent_hw_address (self);
nm_device_update_permanent_hw_address (self, FALSE);
/* Note: initial hardware address must be read before calling get_ignore_carrier() */
config = nm_config_get ();
@ -2298,7 +2305,7 @@ realize_start_setup (NMDevice *self, const NMPlatformLink *plink)
if (nm_device_has_capability (self, NM_DEVICE_CAP_CARRIER_DETECT)) {
check_carrier (self);
_LOGD (LOGD_HW,
_LOGD (LOGD_PLATFORM,
"carrier is %s%s",
priv->carrier ? "ON" : "OFF",
priv->ignore_carrier ? " (but ignored)" : "");
@ -2474,11 +2481,6 @@ nm_device_unrealize (NMDevice *self, gboolean remove_resources, GError **error)
g_clear_pointer (&priv->udi, g_free);
_notify (self, PROP_UDI);
}
if (priv->hw_addr) {
priv->hw_addr_len = 0;
g_clear_pointer (&priv->hw_addr, g_free);
_notify (self, PROP_HW_ADDRESS);
}
if (priv->physical_port_id) {
g_clear_pointer (&priv->physical_port_id, g_free);
_notify (self, PROP_PHYSICAL_PORT_ID);
@ -2487,9 +2489,12 @@ nm_device_unrealize (NMDevice *self, gboolean remove_resources, GError **error)
nm_clear_g_source (&priv->stats.timeout_id);
_stats_update_counters (self, 0, 0);
priv->hw_addr_len_ = 0;
if (nm_clear_g_free (&priv->hw_addr))
_notify (self, PROP_HW_ADDRESS);
priv->hw_addr_type = HW_ADDR_TYPE_UNSET;
g_clear_pointer (&priv->hw_addr_perm, g_free);
_notify (self, PROP_PERM_HW_ADDRESS);
if (nm_clear_g_free (&priv->hw_addr_perm))
_notify (self, PROP_PERM_HW_ADDRESS);
g_clear_pointer (&priv->hw_addr_initial, g_free);
priv->capabilities = NM_DEVICE_CAP_NM_SUPPORTED;
@ -7625,6 +7630,7 @@ _cleanup_ip4_pre (NMDevice *self, CleanupType cleanup_type)
if (nm_clear_g_source (&priv->queued_ip4_config_id))
_LOGD (LOGD_DEVICE, "clearing queued IP4 config change");
priv->queued_ip4_config_pending = FALSE;
dhcp4_cleanup (self, cleanup_type, FALSE);
arp_cleanup (self);
@ -7641,6 +7647,7 @@ _cleanup_ip6_pre (NMDevice *self, CleanupType cleanup_type)
if (nm_clear_g_source (&priv->queued_ip6_config_id))
_LOGD (LOGD_DEVICE, "clearing queued IP6 config change");
priv->queued_ip6_config_pending = FALSE;
g_clear_object (&priv->dad6_ip6_config);
dhcp6_cleanup (self, cleanup_type, FALSE);
@ -9033,7 +9040,7 @@ nm_device_bring_up (NMDevice *self, gboolean block, gboolean *no_firmware)
g_return_val_if_fail (NM_IS_DEVICE (self), FALSE);
_LOGD (LOGD_HW, "bringing up device");
_LOGD (LOGD_PLATFORM, "bringing up device");
if (NM_DEVICE_GET_CLASS (self)->bring_up) {
if (!NM_DEVICE_GET_CLASS (self)->bring_up (self, no_firmware))
@ -9059,9 +9066,9 @@ nm_device_bring_up (NMDevice *self, gboolean block, gboolean *no_firmware)
if (!device_is_up) {
if (block)
_LOGW (LOGD_HW, "device not up after timeout!");
_LOGW (LOGD_PLATFORM, "device not up after timeout!");
else
_LOGD (LOGD_HW, "device not up immediately");
_LOGD (LOGD_PLATFORM, "device not up immediately");
return FALSE;
}
@ -9125,7 +9132,7 @@ nm_device_take_down (NMDevice *self, gboolean block)
g_return_if_fail (NM_IS_DEVICE (self));
_LOGD (LOGD_HW, "taking down device");
_LOGD (LOGD_PLATFORM, "taking down device");
if (NM_DEVICE_GET_CLASS (self)->take_down) {
if (!NM_DEVICE_GET_CLASS (self)->take_down (self))
@ -9147,9 +9154,9 @@ nm_device_take_down (NMDevice *self, gboolean block)
if (device_is_up) {
if (block)
_LOGW (LOGD_HW, "device not down after timeout!");
_LOGW (LOGD_PLATFORM, "device not down after timeout!");
else
_LOGD (LOGD_HW, "device not down immediately");
_LOGD (LOGD_PLATFORM, "device not down immediately");
}
}
@ -9162,7 +9169,7 @@ take_down (NMDevice *self)
return nm_platform_link_set_down (NM_PLATFORM_GET, ifindex);
/* devices without ifindex are always up. */
_LOGD (LOGD_HW, "cannot take down device without ifindex");
_LOGD (LOGD_PLATFORM, "cannot take down device without ifindex");
return FALSE;
}
@ -9340,6 +9347,7 @@ update_ip4_config (NMDevice *self, gboolean initial)
&& activation_source_is_scheduled (self,
activate_stage5_ip4_config_commit,
AF_INET)) {
priv->queued_ip4_config_pending = FALSE;
priv->queued_ip4_config_id = g_idle_add (queued_ip4_config_change, self);
_LOGT (LOGD_DEVICE, "IP4 update was postponed");
return;
@ -9430,6 +9438,7 @@ update_ip6_config (NMDevice *self, gboolean initial)
&& activation_source_is_scheduled (self,
activate_stage5_ip6_config_commit,
AF_INET6)) {
priv->queued_ip6_config_pending = FALSE;
priv->queued_ip6_config_id = g_idle_add (queued_ip6_config_change, self);
_LOGT (LOGD_DEVICE, "IP6 update was postponed");
return;
@ -9507,6 +9516,8 @@ queued_ip4_config_change (gpointer user_data)
priv = NM_DEVICE_GET_PRIVATE (self);
nm_assert (!priv->queued_ip4_config_pending);
/* Wait for any queued state changes */
if (priv->queued_state.id)
return TRUE;
@ -9531,6 +9542,8 @@ queued_ip6_config_change (gpointer user_data)
priv = NM_DEVICE_GET_PRIVATE (self);
nm_assert (!priv->queued_ip4_config_pending);
/* Wait for any queued state changes */
if (priv->queued_state.id)
return TRUE;
@ -9608,7 +9621,11 @@ device_ipx_changed (NMPlatform *platform,
switch (obj_type) {
case NMP_OBJECT_TYPE_IP4_ADDRESS:
case NMP_OBJECT_TYPE_IP4_ROUTE:
if (!priv->queued_ip4_config_id) {
if (nm_device_get_unmanaged_flags (self, NM_UNMANAGED_PLATFORM_INIT)) {
priv->queued_ip4_config_pending = TRUE;
nm_assert_se (!nm_clear_g_source (&priv->queued_ip4_config_id));
} else if (!priv->queued_ip4_config_id) {
priv->queued_ip4_config_pending = FALSE;
priv->queued_ip4_config_id = g_idle_add (queued_ip4_config_change, self);
_LOGD (LOGD_DEVICE, "queued IP4 config change");
}
@ -9625,7 +9642,11 @@ device_ipx_changed (NMPlatform *platform,
}
/* fallthrough */
case NMP_OBJECT_TYPE_IP6_ROUTE:
if (!priv->queued_ip6_config_id) {
if (nm_device_get_unmanaged_flags (self, NM_UNMANAGED_PLATFORM_INIT)) {
priv->queued_ip6_config_pending = TRUE;
nm_assert_se (!nm_clear_g_source (&priv->queued_ip6_config_id));
} else if (!priv->queued_ip6_config_id) {
priv->queued_ip6_config_pending = FALSE;
priv->queued_ip6_config_id = g_idle_add (queued_ip6_config_change, self);
_LOGD (LOGD_DEVICE, "queued IP6 config change");
}
@ -9867,6 +9888,33 @@ _set_unmanaged_flags (NMDevice *self,
allow_state_transition = FALSE;
was_managed = allow_state_transition && nm_device_get_managed (self, FALSE);
if ( NM_FLAGS_HAS (priv->unmanaged_flags, NM_UNMANAGED_PLATFORM_INIT)
&& NM_FLAGS_HAS (flags, NM_UNMANAGED_PLATFORM_INIT)
&& NM_IN_SET (set_op, NM_UNMAN_FLAG_OP_SET_MANAGED)) {
/* we are clearing the platform-init flags. This triggers additional actions. */
if (!NM_FLAGS_HAS (flags, NM_UNMANAGED_USER_SETTINGS)) {
gboolean unmanaged;
unmanaged = nm_device_spec_match_list (self,
nm_settings_get_unmanaged_specs (NM_DEVICE_GET_PRIVATE (self)->settings));
nm_device_set_unmanaged_flags (self,
NM_UNMANAGED_USER_SETTINGS,
!!unmanaged);
}
if (priv->queued_ip4_config_pending) {
priv->queued_ip4_config_pending = FALSE;
nm_assert_se (!nm_clear_g_source (&priv->queued_ip4_config_id));
priv->queued_ip4_config_id = g_idle_add (queued_ip4_config_change, self);
}
if (priv->queued_ip6_config_pending) {
priv->queued_ip6_config_pending = FALSE;
nm_assert_se (!nm_clear_g_source (&priv->queued_ip6_config_id));
priv->queued_ip6_config_id = g_idle_add (queued_ip6_config_change, self);
}
}
old_flags = priv->unmanaged_flags;
old_mask = priv->unmanaged_mask;
@ -9981,20 +10029,30 @@ nm_device_set_unmanaged_by_flags_queue (NMDevice *self,
}
void
nm_device_set_unmanaged_by_user_settings (NMDevice *self, const GSList *unmanaged_specs)
nm_device_set_unmanaged_by_user_settings (NMDevice *self)
{
NMDevicePrivate *priv;
gboolean unmanaged;
g_return_if_fail (NM_IS_DEVICE (self));
priv = NM_DEVICE_GET_PRIVATE (self);
if (nm_device_get_unmanaged_flags (self, NM_UNMANAGED_PLATFORM_INIT)) {
/* the device is already unmanaged due to platform-init.
*
* We want to delay evaluating the device spec, because it will freeze
* the permanent MAC address. That should not be done, before the platform
* link is fully initialized (via UDEV).
*
* Note that when clearing NM_UNMANAGED_PLATFORM_INIT, we will re-evaluate
* whether the device is unmanaged by user-settings. */
return;
}
unmanaged = nm_device_spec_match_list (self, unmanaged_specs);
unmanaged = nm_device_spec_match_list (self,
nm_settings_get_unmanaged_specs (NM_DEVICE_GET_PRIVATE (self)->settings));
nm_device_set_unmanaged_by_flags (self,
NM_UNMANAGED_USER_SETTINGS,
unmanaged,
!!unmanaged,
unmanaged
? NM_DEVICE_STATE_REASON_NOW_UNMANAGED
: NM_DEVICE_STATE_REASON_NOW_MANAGED);
@ -11150,7 +11208,7 @@ _set_state_full (NMDevice *self,
if (reason != NM_DEVICE_STATE_REASON_CONNECTION_ASSUMED) {
if (old_state == NM_DEVICE_STATE_UNMANAGED || priv->firmware_missing) {
if (!nm_device_bring_up (self, TRUE, &no_firmware) && no_firmware)
_LOGW (LOGD_HW, "firmware may be missing.");
_LOGW (LOGD_PLATFORM, "firmware may be missing.");
nm_device_set_firmware_missing (self, no_firmware ? TRUE : FALSE);
}
@ -11499,11 +11557,17 @@ const char *
nm_device_get_hw_address (NMDevice *self)
{
NMDevicePrivate *priv;
char buf[NM_UTILS_HWADDR_LEN_MAX];
gsize l;
g_return_val_if_fail (NM_IS_DEVICE (self), NULL);
priv = NM_DEVICE_GET_PRIVATE (self);
nm_assert ((!priv->hw_addr) ^ (priv->hw_addr_len > 0));
nm_assert ( (!priv->hw_addr && priv->hw_addr_len == 0)
|| ( priv->hw_addr
&& _nm_utils_hwaddr_aton (priv->hw_addr, buf, sizeof (buf), &l)
&& l == priv->hw_addr_len));
return priv->hw_addr;
}
@ -11514,7 +11578,6 @@ nm_device_update_hw_address (NMDevice *self)
NMDevicePrivate *priv;
const guint8 *hwaddr;
gsize hwaddrlen = 0;
gboolean changed = FALSE;
priv = NM_DEVICE_GET_PRIVATE (self);
if (priv->ifindex <= 0)
@ -11527,38 +11590,46 @@ nm_device_update_hw_address (NMDevice *self)
&& nm_utils_hwaddr_matches (hwaddr, hwaddrlen, nm_ip_addr_zero.addr_eth, sizeof (nm_ip_addr_zero.addr_eth)))
hwaddrlen = 0;
if (hwaddrlen) {
priv->hw_addr_len = hwaddrlen;
if (!priv->hw_addr || !nm_utils_hwaddr_matches (priv->hw_addr, -1, hwaddr, hwaddrlen)) {
g_free (priv->hw_addr);
priv->hw_addr = nm_utils_hwaddr_ntoa (hwaddr, hwaddrlen);
if (!hwaddrlen)
return FALSE;
_LOGD (LOGD_HW | LOGD_DEVICE, "hw-addr: hardware address now %s", priv->hw_addr);
_notify (self, PROP_HW_ADDRESS);
if ( priv->hw_addr_len
&& priv->hw_addr_len != hwaddrlen) {
char s_buf[NM_UTILS_HWADDR_LEN_MAX_STR];
if ( !priv->hw_addr_initial
|| ( priv->hw_addr_type == HW_ADDR_TYPE_UNSET
&& priv->state < NM_DEVICE_STATE_PREPARE
&& !nm_device_is_activating (self))) {
/* when we get a hw_addr the first time or while the device
* is not activated (with no explict hw address set), always
* update our inital hw-address as well. */
nm_device_update_initial_hw_address (self);
}
changed = TRUE;
}
} else {
/* Invalid or no hardware address */
if (priv->hw_addr_len != 0) {
_LOGD (LOGD_HW | LOGD_DEVICE,
"hw-addr: failed reading current MAC address (stay with %s)",
priv->hw_addr);
} else {
_LOGD (LOGD_HW | LOGD_DEVICE,
"hw-addr: failed reading current MAC address");
}
/* we cannot change the address length of a device once it is set (except
* unrealizing the device).
*
* The reason is that the permanent and initial MAC addresses also must have the
* same address length, so it's unclear what it would mean that the length changes. */
_LOGD (LOGD_PLATFORM | LOGD_DEVICE,
"hw-addr: read a MAC address with differing length (%s vs. %s)",
priv->hw_addr,
nm_utils_hwaddr_ntoa_buf (hwaddr, hwaddrlen, TRUE, s_buf, sizeof (s_buf)));
return FALSE;
}
return changed;
if ( priv->hw_addr
&& nm_utils_hwaddr_matches (priv->hw_addr, -1, hwaddr, hwaddrlen))
return FALSE;
g_free (priv->hw_addr);
priv->hw_addr_len_ = hwaddrlen;
priv->hw_addr = nm_utils_hwaddr_ntoa (hwaddr, hwaddrlen);
_LOGD (LOGD_PLATFORM | LOGD_DEVICE, "hw-addr: hardware address now %s", priv->hw_addr);
_notify (self, PROP_HW_ADDRESS);
if ( !priv->hw_addr_initial
|| ( priv->hw_addr_type == HW_ADDR_TYPE_UNSET
&& priv->state < NM_DEVICE_STATE_PREPARE
&& !nm_device_is_activating (self))) {
/* when we get a hw_addr the first time or while the device
* is not activated (with no explict hw address set), always
* update our inital hw-address as well. */
nm_device_update_initial_hw_address (self);
}
return TRUE;
}
void
@ -11582,12 +11653,14 @@ nm_device_update_initial_hw_address (NMDevice *self)
}
void
nm_device_update_permanent_hw_address (NMDevice *self)
nm_device_update_permanent_hw_address (NMDevice *self, gboolean force_freeze)
{
NMDevicePrivate *priv = NM_DEVICE_GET_PRIVATE (self);
guint8 buf[NM_UTILS_HWADDR_LEN_MAX];
size_t len = 0;
gboolean success_read;
int ifindex;
const NMPlatformLink *pllink;
if (priv->hw_addr_perm) {
/* the permanent hardware address is only read once and not
@ -11598,35 +11671,60 @@ nm_device_update_permanent_hw_address (NMDevice *self)
return;
}
if (priv->ifindex <= 0)
ifindex = priv->ifindex;
if (ifindex <= 0)
return;
if (!priv->hw_addr_len) {
nm_device_update_hw_address (self);
if (!priv->hw_addr_len)
/* the user is advised to configure stable MAC addresses for software devices via
* UDEV. Thus, check whether the link is fully initialized. */
pllink = nm_platform_link_get (NM_PLATFORM_GET, ifindex);
if ( !pllink
|| !pllink->initialized) {
if (!force_freeze) {
/* we can afford to wait. Back off and leave the permanent MAC address
* undecided for now. */
return;
}
/* try to refresh the link just to give UDEV a bit more time... */
nm_platform_link_refresh (NM_PLATFORM_GET, ifindex);
/* maybe the MAC address changed... */
nm_device_update_hw_address (self);
} else if (!priv->hw_addr_len)
nm_device_update_hw_address (self);
if (!priv->hw_addr_len) {
/* we need the current MAC address because we require the permanent MAC address
* to have the same length as the current address.
*
* Abort if there is no current MAC address. */
return;
}
success_read = nm_platform_link_get_permanent_address (NM_PLATFORM_GET, priv->ifindex, buf, &len);
if (!success_read || len != priv->hw_addr_len) {
/* Fall back to current address. We use the fake address and keep it
* until the device unrealizes.
*
* In some cases it might be necessary to know whether this is a "real" or
* a temporary address (fake). */
_LOGD (LOGD_HW | LOGD_ETHER, "hw-addr: %s (use current: %s)",
success_read
? "read HW addr length of permanent MAC address differs"
: "unable to read permanent MAC address",
priv->hw_addr);
priv->hw_addr_perm_fake = TRUE;
priv->hw_addr_perm = g_strdup (priv->hw_addr);
} else {
success_read = nm_platform_link_get_permanent_address (NM_PLATFORM_GET, ifindex, buf, &len);
if (success_read && priv->hw_addr_len == len) {
priv->hw_addr_perm_fake = FALSE;
priv->hw_addr_perm = nm_utils_hwaddr_ntoa (buf, len);
_LOGD (LOGD_DEVICE, "hw-addr: read permanent MAC address '%s'",
priv->hw_addr_perm);
goto notify_and_out;
}
/* we failed to read a permanent MAC address, thus we use a fake address,
* that is the current MAC address of the device.
*
* Note that the permanet MAC address of a NMDevice instance does not change
* after being set once. Thus, we use now a fake address and stick to that
* (until we unrealize the device). */
priv->hw_addr_perm_fake = TRUE;
_LOGD (LOGD_PLATFORM | LOGD_ETHER, "hw-addr: %s (use current: %s)",
success_read
? "read HW addr length of permanent MAC address differs"
: "unable to read permanent MAC address",
priv->hw_addr);
priv->hw_addr_perm = g_strdup (priv->hw_addr);
notify_and_out:
_notify (self, PROP_PERM_HW_ADDRESS);
}
@ -11718,25 +11816,25 @@ nm_device_hw_addr_is_explict (NMDevice *self)
}
static gboolean
_hw_addr_matches (NMDevice *self, const char *addr)
_hw_addr_matches (NMDevice *self, const guint8 *addr, gsize addr_len)
{
const char *cur_addr;
cur_addr = nm_device_get_hw_address (self);
return cur_addr && nm_utils_hwaddr_matches (cur_addr, -1, addr, -1);
return cur_addr && nm_utils_hwaddr_matches (addr, addr_len, cur_addr, -1);
}
static gboolean
_hw_addr_set (NMDevice *self,
const char *addr,
const char *operation,
const char *detail)
const char *const addr,
const char *const operation,
const char *const detail)
{
NMDevicePrivate *priv;
gboolean success = FALSE;
NMPlatformError plerr;
guint8 addr_bytes[NM_UTILS_HWADDR_LEN_MAX];
guint hw_addr_len;
gsize addr_len;
gboolean was_up;
nm_assert (NM_IS_DEVICE (self));
@ -11745,17 +11843,17 @@ _hw_addr_set (NMDevice *self,
priv = NM_DEVICE_GET_PRIVATE (self);
if (!_nm_utils_hwaddr_aton (addr, addr_bytes, sizeof (addr_bytes), &addr_len))
g_return_val_if_reached (FALSE);
/* Do nothing if current MAC is same */
if (_hw_addr_matches (self, addr)) {
if (_hw_addr_matches (self, addr_bytes, addr_len)) {
_LOGT (LOGD_DEVICE, "set-hw-addr: no MAC address change needed (%s)", addr);
return TRUE;
}
hw_addr_len = priv->hw_addr_len;
if (!hw_addr_len)
hw_addr_len = _nm_utils_hwaddr_length (addr);
if ( !hw_addr_len
|| !nm_utils_hwaddr_aton (addr, addr_bytes, hw_addr_len))
if ( priv->hw_addr_len
&& priv->hw_addr_len != addr_len)
g_return_val_if_reached (FALSE);
_LOGT (LOGD_DEVICE, "set-hw-addr: setting MAC address to '%s' (%s, %s)...", addr, operation, detail);
@ -11766,12 +11864,12 @@ _hw_addr_set (NMDevice *self,
nm_device_take_down (self, FALSE);
}
plerr = nm_platform_link_set_address (NM_PLATFORM_GET, nm_device_get_ip_ifindex (self), addr_bytes, hw_addr_len);
plerr = nm_platform_link_set_address (NM_PLATFORM_GET, nm_device_get_ip_ifindex (self), addr_bytes, addr_len);
success = (plerr == NM_PLATFORM_ERROR_SUCCESS);
if (success) {
/* MAC address succesfully changed; update the current MAC to match */
nm_device_update_hw_address (self);
if (_hw_addr_matches (self, addr)) {
if (_hw_addr_matches (self, addr_bytes, addr_len)) {
_LOGI (LOGD_DEVICE, "set-hw-addr: %s MAC address to %s (%s)",
operation, addr, detail);
} else {
@ -11801,7 +11899,7 @@ _hw_addr_set (NMDevice *self,
goto handle_fail;
if (!nm_device_update_hw_address (self))
goto handle_wait;
if (!_hw_addr_matches (self, addr))
if (!_hw_addr_matches (self, addr_bytes, addr_len))
goto handle_fail;
break;
@ -11884,7 +11982,7 @@ nm_device_hw_addr_set_cloned (NMDevice *self, NMConnection *connection, gboolean
}
if (nm_streq (addr, NM_CLONED_MAC_PERMANENT)) {
addr = nm_device_get_permanent_hw_address (self, TRUE);
addr = nm_device_get_permanent_hw_address (self);
if (!addr)
return FALSE;
priv->hw_addr_type = HW_ADDR_TYPE_PERMANENT;
@ -11928,9 +12026,8 @@ nm_device_hw_addr_set_cloned (NMDevice *self, NMConnection *connection, gboolean
addr = hw_addr_generated;
} else {
/* this must be a valid address. Otherwise, we shouldn't come here. */
if (_nm_utils_hwaddr_length (addr) <= 0) {
if (!nm_utils_hwaddr_valid (addr, -1))
g_return_val_if_reached (FALSE);
}
priv->hw_addr_type = HW_ADDR_TYPE_EXPLICIT;
}
@ -11962,21 +12059,32 @@ nm_device_hw_addr_reset (NMDevice *self, const char *detail)
}
const char *
nm_device_get_permanent_hw_address (NMDevice *self, gboolean fallback_fake)
nm_device_get_permanent_hw_address_full (NMDevice *self, gboolean force_freeze, gboolean *out_is_fake)
{
NMDevicePrivate *priv;
g_return_val_if_fail (NM_IS_DEVICE (self), NULL);
priv = NM_DEVICE_GET_PRIVATE (self);
if (!priv->hw_addr_perm)
return NULL;
if ( priv->hw_addr_perm_fake
&& !fallback_fake)
return NULL;
if ( !priv->hw_addr_perm
&& force_freeze) {
/* somebody requests a permanent MAC address, but we don't have it set
* yet. We cannot delay it any longer and try to get it without waiting
* for UDEV. */
nm_device_update_permanent_hw_address (self, TRUE);
}
NM_SET_OUT (out_is_fake, priv->hw_addr_perm && priv->hw_addr_perm_fake);
return priv->hw_addr_perm;
}
const char *
nm_device_get_permanent_hw_address (NMDevice *self)
{
return nm_device_get_permanent_hw_address_full (self, TRUE, NULL);
}
const char *
nm_device_get_initial_hw_address (NMDevice *self)
{
@ -12031,7 +12139,7 @@ spec_match_list (NMDevice *self, const GSList *specs)
}
}
hw_addr_perm = nm_device_get_permanent_hw_address (self, FALSE);
hw_addr_perm = nm_device_get_permanent_hw_address (self);
if (hw_addr_perm) {
m = nm_match_spec_hwaddr (specs, hw_addr_perm);
matched = MAX (matched, m);
@ -12127,13 +12235,16 @@ constructor (GType type,
}
if (priv->hw_addr_perm) {
priv->hw_addr_len = _nm_utils_hwaddr_length (priv->hw_addr_perm);
if (!priv->hw_addr_len) {
guint8 buf[NM_UTILS_HWADDR_LEN_MAX];
gsize l;
if (!_nm_utils_hwaddr_aton (priv->hw_addr_perm, buf, sizeof (buf), &l)) {
g_clear_pointer (&priv->hw_addr_perm, g_free);
g_return_val_if_reached (object);
}
priv->hw_addr = g_strdup (priv->hw_addr_perm);
priv->hw_addr_len_ = l;
priv->hw_addr = nm_utils_hwaddr_ntoa (buf, l);
_LOGT (LOGD_DEVICE, "hw-addr: has permanent hw-address '%s'", priv->hw_addr_perm);
}
@ -12502,10 +12613,15 @@ get_property (GObject *object, guint prop_id,
case PROP_HW_ADDRESS:
g_value_set_string (value, priv->hw_addr);
break;
case PROP_PERM_HW_ADDRESS:
case PROP_PERM_HW_ADDRESS: {
const char *perm_hw_addr;
gboolean perm_hw_addr_is_fake;
perm_hw_addr = nm_device_get_permanent_hw_address_full (self, FALSE, &perm_hw_addr_is_fake);
/* this property is exposed on D-Bus for NMDeviceEthernet and NMDeviceWifi. */
g_value_set_string (value, nm_device_get_permanent_hw_address (self, FALSE));
g_value_set_string (value, perm_hw_addr && !perm_hw_addr_is_fake ? perm_hw_addr : NULL);
break;
}
case PROP_HAS_PENDING_ACTION:
g_value_set_boolean (value, nm_device_has_pending_action (self));
break;

10
src/devices/nm-device.h
View file

@ -364,8 +364,10 @@ guint32 nm_device_get_ip4_route_metric (NMDevice *dev);
guint32 nm_device_get_ip6_route_metric (NMDevice *dev);
const char * nm_device_get_hw_address (NMDevice *dev);
const char * nm_device_get_permanent_hw_address (NMDevice *dev,
gboolean fallback_fake);
const char * nm_device_get_permanent_hw_address (NMDevice *self);
const char * nm_device_get_permanent_hw_address_full (NMDevice *self,
gboolean force_freeze,
gboolean *out_is_fake);
const char * nm_device_get_initial_hw_address (NMDevice *dev);
NMDhcp4Config * nm_device_get_dhcp4_config (NMDevice *dev);
@ -507,7 +509,7 @@ void nm_device_set_unmanaged_by_flags_queue (NMDevice *self,
NMUnmanagedFlags flags,
NMUnmanFlagOp set_op,
NMDeviceStateReason reason);
void nm_device_set_unmanaged_by_user_settings (NMDevice *self, const GSList *unmanaged_specs);
void nm_device_set_unmanaged_by_user_settings (NMDevice *self);
void nm_device_set_unmanaged_by_user_udev (NMDevice *self);
void nm_device_set_unmanaged_by_quitting (NMDevice *device);
@ -590,7 +592,7 @@ void nm_device_reactivate_ip6_config (NMDevice *device,
gboolean nm_device_update_hw_address (NMDevice *self);
void nm_device_update_initial_hw_address (NMDevice *self);
void nm_device_update_permanent_hw_address (NMDevice *self);
void nm_device_update_permanent_hw_address (NMDevice *self, gboolean force_freeze);
void nm_device_update_dynamic_ip_setup (NMDevice *self);
#endif /* __NETWORKMANAGER_DEVICE_H__ */

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

@ -203,7 +203,7 @@ constructed (GObject *object)
G_OBJECT_CLASS (nm_device_wifi_parent_class)->constructed (object);
if (priv->capabilities & NM_WIFI_DEVICE_CAP_AP)
_LOGI (LOGD_HW | LOGD_WIFI, "driver supports Access Point (AP) mode");
_LOGI (LOGD_PLATFORM | LOGD_WIFI, "driver supports Access Point (AP) mode");
/* Connect to the supplicant manager */
priv->sup_mgr = g_object_ref (nm_supplicant_manager_get ());
@ -615,7 +615,7 @@ check_connection_compatible (NMDevice *device, NMConnection *connection)
if (!s_wireless)
return FALSE;
perm_hw_addr = nm_device_get_permanent_hw_address (device, FALSE);
perm_hw_addr = nm_device_get_permanent_hw_address (device);
mac = nm_setting_wireless_get_mac_address (s_wireless);
if (perm_hw_addr) {
if (mac && !nm_utils_hwaddr_matches (mac, -1, perm_hw_addr, -1))
@ -907,7 +907,7 @@ complete_connection (NMDevice *device,
if (hidden)
g_object_set (s_wifi, NM_SETTING_WIRELESS_HIDDEN, TRUE, NULL);
perm_hw_addr = nm_device_get_permanent_hw_address (device, FALSE);
perm_hw_addr = nm_device_get_permanent_hw_address (device);
if (perm_hw_addr) {
setting_mac = nm_setting_wireless_get_mac_address (s_wifi);
if (setting_mac) {

2
src/devices/wifi/nm-wifi-factory.c
View file

@ -76,7 +76,7 @@ create_device (NMDeviceFactory *factory,
if (!nm_platform_wifi_get_capabilities (NM_PLATFORM_GET,
plink->ifindex,
&capabilities)) {
nm_log_warn (LOGD_HW | LOGD_WIFI, "(%s) failed to initialize Wi-Fi driver for ifindex %d", iface, plink->ifindex);
nm_log_warn (LOGD_PLATFORM | LOGD_WIFI, "(%s) failed to initialize Wi-Fi driver for ifindex %d", iface, plink->ifindex);
return NULL;
}

4
src/devices/wwan/nm-modem.c
View file

@ -1355,12 +1355,12 @@ constructor (GType type,
priv = NM_MODEM_GET_PRIVATE (object);
if (!priv->data_port && !priv->control_port) {
nm_log_err (LOGD_HW, "neither modem command nor data interface provided");
nm_log_err (LOGD_PLATFORM, "neither modem command nor data interface provided");
goto err;
}
if (!priv->path) {
nm_log_err (LOGD_HW, "D-Bus path not provided");
nm_log_err (LOGD_PLATFORM, "D-Bus path not provided");
goto err;
}

2
src/nm-config.c
View file

@ -399,7 +399,7 @@ nm_config_set_no_auto_default_for_device (NMConfig *self, NMDevice *device)
priv = NM_CONFIG_GET_PRIVATE (self);
hw_address = nm_device_get_permanent_hw_address (device, FALSE);
hw_address = nm_device_get_permanent_hw_address (device);
if (!hw_address)
return;

7
src/nm-core-utils.c
View file

@ -1272,7 +1272,7 @@ nm_match_spec_hwaddr (const GSList *specs, const char *hwaddr)
{
const GSList *iter;
NMMatchSpecMatchType match = NM_MATCH_SPEC_NO_MATCH;
guint hwaddr_len = 0;
gsize hwaddr_len = 0;
guint8 hwaddr_bin[NM_UTILS_HWADDR_LEN_MAX];
nm_assert (nm_utils_hwaddr_valid (hwaddr, -1));
@ -1297,11 +1297,8 @@ nm_match_spec_hwaddr (const GSList *specs, const char *hwaddr)
continue;
if (G_UNLIKELY (hwaddr_len == 0)) {
hwaddr_len = _nm_utils_hwaddr_length (hwaddr);
if (!hwaddr_len)
if (!_nm_utils_hwaddr_aton (hwaddr, hwaddr_bin, sizeof (hwaddr_bin), &hwaddr_len))
g_return_val_if_reached (NM_MATCH_SPEC_NO_MATCH);
if (!nm_utils_hwaddr_aton (hwaddr, hwaddr_bin, hwaddr_len))
nm_assert_not_reached ();
}
if (nm_utils_hwaddr_matches (spec_str, -1, hwaddr_bin, hwaddr_len)) {

1
src/nm-logging.h
View file

@ -78,7 +78,6 @@ typedef enum { /*< skip >*/
/* aliases: */
LOGD_DHCP = LOGD_DHCP4 | LOGD_DHCP6,
LOGD_IP = LOGD_IP4 | LOGD_IP6,
LOGD_HW = LOGD_PLATFORM,
} NMLogDomain;
/* Log levels */

23
src/nm-manager.c
View file

@ -610,7 +610,7 @@ find_device_by_permanent_hw_addr (NMManager *manager, const char *hwaddr)
if (nm_utils_hwaddr_valid (hwaddr, -1)) {
for (iter = NM_MANAGER_GET_PRIVATE (manager)->devices; iter; iter = iter->next) {
device_addr = nm_device_get_permanent_hw_address (NM_DEVICE (iter->data), FALSE);
device_addr = nm_device_get_permanent_hw_address (NM_DEVICE (iter->data));
if (device_addr && nm_utils_hwaddr_matches (hwaddr, -1, device_addr, -1))
return NM_DEVICE (iter->data);
}
@ -1320,11 +1320,10 @@ system_unmanaged_devices_changed_cb (NMSettings *settings,
{
NMManager *self = NM_MANAGER (user_data);
NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
const GSList *unmanaged_specs, *iter;
const GSList *iter;
unmanaged_specs = nm_settings_get_unmanaged_specs (priv->settings);
for (iter = priv->devices; iter; iter = g_slist_next (iter))
nm_device_set_unmanaged_by_user_settings (NM_DEVICE (iter->data), unmanaged_specs);
nm_device_set_unmanaged_by_user_settings (NM_DEVICE (iter->data));
}
static void
@ -1993,7 +1992,7 @@ add_device (NMManager *self, NMDevice *device, GError **error)
type_desc = nm_device_get_type_desc (device);
g_assert (type_desc);
nm_device_set_unmanaged_by_user_settings (device, nm_settings_get_unmanaged_specs (priv->settings));
nm_device_set_unmanaged_by_user_settings (device);
nm_device_set_unmanaged_flags (device,
NM_UNMANAGED_SLEEPING,
@ -2127,10 +2126,10 @@ platform_link_added (NMManager *self,
device = nm_device_factory_create_device (factory, plink->name, plink, NULL, &ignore, &error);
if (!device) {
if (!ignore) {
_LOGW (LOGD_HW, "%s: factory failed to create device: %s",
_LOGW (LOGD_PLATFORM, "%s: factory failed to create device: %s",
plink->name, error->message);
} else {
_LOGD (LOGD_HW, "%s: factory failed to create device: %s",
_LOGD (LOGD_PLATFORM, "%s: factory failed to create device: %s",
plink->name, error->message);
}
return;
@ -2144,7 +2143,7 @@ platform_link_added (NMManager *self,
case NM_LINK_TYPE_OLPC_MESH:
case NM_LINK_TYPE_TEAM:
case NM_LINK_TYPE_WIFI:
_LOGI (LOGD_HW, "(%s): '%s' plugin not available; creating generic device",
_LOGI (LOGD_PLATFORM, "(%s): '%s' plugin not available; creating generic device",
plink->name, nm_link_type_to_string (plink->type));
nm_plugin_missing = TRUE;
/* fall through */
@ -2812,15 +2811,15 @@ unmanaged_to_disconnected (NMDevice *device)
if (nm_device_get_state (device) == NM_DEVICE_STATE_UNMANAGED) {
nm_device_state_changed (device,
NM_DEVICE_STATE_UNAVAILABLE,
NM_DEVICE_STATE_REASON_USER_REQUESTED);
NM_DEVICE_STATE_UNAVAILABLE,
NM_DEVICE_STATE_REASON_USER_REQUESTED);
}
if ( nm_device_is_available (device, NM_DEVICE_CHECK_DEV_AVAILABLE_FOR_USER_REQUEST)
&& (nm_device_get_state (device) == NM_DEVICE_STATE_UNAVAILABLE)) {
nm_device_state_changed (device,
NM_DEVICE_STATE_DISCONNECTED,
NM_DEVICE_STATE_REASON_USER_REQUESTED);
NM_DEVICE_STATE_DISCONNECTED,
NM_DEVICE_STATE_REASON_USER_REQUESTED);
}
}

2
src/nm-rfkill-manager.c
View file

@ -347,7 +347,7 @@ handle_uevent (GUdevClient *client,
subsys = g_udev_device_get_subsystem (device);
g_return_if_fail (!g_strcmp0 (subsys, "rfkill"));
nm_log_dbg (LOGD_HW, "udev rfkill event: action '%s' device '%s'",
nm_log_dbg (LOGD_PLATFORM, "udev rfkill event: action '%s' device '%s'",
action, g_udev_device_get_name (device));
if (!strcmp (action, "add"))

16
src/platform/wifi/wifi-utils-nl80211.c
View file

@ -1003,7 +1003,7 @@ static int nl80211_wiphy_info_handler (struct nl_msg *msg, void *arg)
case WLAN_CIPHER_SUITE_SMS4:
break;
default:
nm_log_dbg (LOGD_HW | LOGD_WIFI, "Don't know the meaning of NL80211_ATTR_CIPHER_SUITE %#8.8x.", ciphers[i]);
nm_log_dbg (LOGD_PLATFORM | LOGD_WIFI, "Don't know the meaning of NL80211_ATTR_CIPHER_SUITE %#8.8x.", ciphers[i]);
break;
}
}
@ -1071,42 +1071,42 @@ wifi_nl80211_init (const char *iface, int ifindex)
if (nl80211_send_and_recv (nl80211, msg, nl80211_wiphy_info_handler,
&device_info) < 0) {
nm_log_dbg (LOGD_HW | LOGD_WIFI,
nm_log_dbg (LOGD_PLATFORM | LOGD_WIFI,
"(%s): NL80211_CMD_GET_WIPHY request failed",
nl80211->parent.iface);
goto error;
}
if (!device_info.success) {
nm_log_dbg (LOGD_HW | LOGD_WIFI,
nm_log_dbg (LOGD_PLATFORM | LOGD_WIFI,
"(%s): NL80211_CMD_GET_WIPHY request indicated failure",
nl80211->parent.iface);
goto error;
}
if (!device_info.supported) {
nm_log_dbg (LOGD_HW | LOGD_WIFI,
nm_log_dbg (LOGD_PLATFORM | LOGD_WIFI,
"(%s): driver does not fully support nl80211, falling back to WEXT",
nl80211->parent.iface);
goto error;
}
if (!device_info.can_scan_ssid) {
nm_log_err (LOGD_HW | LOGD_WIFI,
nm_log_err (LOGD_PLATFORM | LOGD_WIFI,
"(%s): driver does not support SSID scans",
nl80211->parent.iface);
goto error;
}
if (device_info.num_freqs == 0 || device_info.freqs == NULL) {
nm_log_err (LOGD_HW | LOGD_WIFI,
nm_log_err (LOGD_PLATFORM | LOGD_WIFI,
"(%s): driver reports no supported frequencies",
nl80211->parent.iface);
goto error;
}
if (device_info.caps == 0) {
nm_log_err (LOGD_HW | LOGD_WIFI,
nm_log_err (LOGD_PLATFORM | LOGD_WIFI,
"(%s): driver doesn't report support of any encryption",
nl80211->parent.iface);
goto error;
@ -1120,7 +1120,7 @@ wifi_nl80211_init (const char *iface, int ifindex)
if (device_info.can_wowlan)
nl80211->parent.get_wowlan = wifi_nl80211_get_wowlan;
nm_log_info (LOGD_HW | LOGD_WIFI,
nm_log_info (LOGD_PLATFORM | LOGD_WIFI,
"(%s): using nl80211 for WiFi device control",
nl80211->parent.iface);

32
src/platform/wifi/wifi-utils-wext.c
View file

@ -105,7 +105,7 @@ wifi_wext_get_mode (WifiData *data)
if (ioctl (wext->fd, SIOCGIWMODE, &wrq) < 0) {
if (errno != ENODEV) {
nm_log_warn (LOGD_HW | LOGD_WIFI,
nm_log_warn (LOGD_PLATFORM | LOGD_WIFI,
"(%s): error %d getting card mode",
wext->parent.iface, errno);
}
@ -154,7 +154,7 @@ wifi_wext_set_mode (WifiData *data, const NM80211Mode mode)
nm_utils_ifname_cpy (wrq.ifr_name, wext->parent.iface);
if (ioctl (wext->fd, SIOCSIWMODE, &wrq) < 0) {
if (errno != ENODEV) {
nm_log_err (LOGD_HW | LOGD_WIFI, "(%s): error setting mode %d",
nm_log_err (LOGD_PLATFORM | LOGD_WIFI, "(%s): error setting mode %d",
wext->parent.iface, mode);
}
return FALSE;
@ -178,7 +178,7 @@ wifi_wext_set_powersave (WifiData *data, guint32 powersave)
nm_utils_ifname_cpy (wrq.ifr_name, wext->parent.iface);
if (ioctl (wext->fd, SIOCSIWPOWER, &wrq) < 0) {
if (errno != ENODEV) {
nm_log_err (LOGD_HW | LOGD_WIFI, "(%s): error setting powersave %" G_GUINT32_FORMAT,
nm_log_err (LOGD_PLATFORM | LOGD_WIFI, "(%s): error setting powersave %" G_GUINT32_FORMAT,
wext->parent.iface, powersave);
}
return FALSE;
@ -196,7 +196,7 @@ wifi_wext_get_freq (WifiData *data)
memset (&wrq, 0, sizeof (struct iwreq));
nm_utils_ifname_cpy (wrq.ifr_name, wext->parent.iface);
if (ioctl (wext->fd, SIOCGIWFREQ, &wrq) < 0) {
nm_log_warn (LOGD_HW | LOGD_WIFI,
nm_log_warn (LOGD_PLATFORM | LOGD_WIFI,
"(%s): error getting frequency: %s",
wext->parent.iface, strerror (errno));
return 0;
@ -230,7 +230,7 @@ wifi_wext_get_bssid (WifiData *data, guint8 *out_bssid)
memset (&wrq, 0, sizeof (wrq));
nm_utils_ifname_cpy (wrq.ifr_name, wext->parent.iface);
if (ioctl (wext->fd, SIOCGIWAP, &wrq) < 0) {
nm_log_warn (LOGD_HW | LOGD_WIFI,
nm_log_warn (LOGD_PLATFORM | LOGD_WIFI,
"(%s): error getting associated BSSID: %s",
wext->parent.iface, strerror (errno));
return FALSE;
@ -360,7 +360,7 @@ wifi_wext_get_qual (WifiData *data)
nm_utils_ifname_cpy (wrq.ifr_name, wext->parent.iface);
if (ioctl (wext->fd, SIOCGIWSTATS, &wrq) < 0) {
nm_log_warn (LOGD_HW | LOGD_WIFI,
nm_log_warn (LOGD_PLATFORM | LOGD_WIFI,
"(%s): error getting signal strength: %s",
wext->parent.iface, strerror (errno));
return -1;
@ -403,7 +403,7 @@ wifi_wext_set_mesh_channel (WifiData *data, guint32 channel)
}
if (ioctl (wext->fd, SIOCSIWFREQ, &wrq) < 0) {
nm_log_err (LOGD_HW | LOGD_WIFI | LOGD_OLPC,
nm_log_err (LOGD_PLATFORM | LOGD_WIFI | LOGD_OLPC,
"(%s): error setting channel to %d: %s",
wext->parent.iface, channel, strerror (errno));
return FALSE;
@ -431,7 +431,7 @@ wifi_wext_set_mesh_ssid (WifiData *data, const guint8 *ssid, gsize len)
return TRUE;
if (errno != ENODEV) {
nm_log_err (LOGD_HW | LOGD_WIFI | LOGD_OLPC,
nm_log_err (LOGD_PLATFORM | LOGD_WIFI | LOGD_OLPC,
"(%s): error setting SSID to '%s': %s",
wext->parent.iface,
ssid ? nm_utils_escape_ssid (ssid, len) : "(null)",
@ -482,7 +482,7 @@ wext_get_range (WifiDataWext *wext,
success = TRUE;
break;
} else if (errno != EAGAIN) {
nm_log_err (LOGD_HW | LOGD_WIFI,
nm_log_err (LOGD_PLATFORM | LOGD_WIFI,
"(%s): couldn't get driver range information (%d).",
wext->parent.iface, errno);
break;
@ -492,7 +492,7 @@ wext_get_range (WifiDataWext *wext,
}
if (i <= 0) {
nm_log_warn (LOGD_HW | LOGD_WIFI,
nm_log_warn (LOGD_PLATFORM | LOGD_WIFI,
"(%s): driver took too long to respond to IWRANGE query.",
wext->parent.iface);
}
@ -583,13 +583,13 @@ wifi_wext_init (const char *iface, int ifindex, gboolean check_scan)
memset (&range, 0, sizeof (struct iw_range));
if (wext_get_range (wext, &range, &response_len) == FALSE) {
nm_log_info (LOGD_HW | LOGD_WIFI, "(%s): driver WEXT range request failed",
nm_log_info (LOGD_PLATFORM | LOGD_WIFI, "(%s): driver WEXT range request failed",
wext->parent.iface);
goto error;
}
if ((response_len < 300) || (range.we_version_compiled < 21)) {
nm_log_info (LOGD_HW | LOGD_WIFI,
nm_log_info (LOGD_PLATFORM | LOGD_WIFI,
"(%s): driver WEXT version too old (got %d, expected >= 21)",
wext->parent.iface,
range.we_version_compiled);
@ -613,7 +613,7 @@ wifi_wext_init (const char *iface, int ifindex, gboolean check_scan)
/* Check for scanning capability; cards that can't scan are not supported */
if (check_scan && (wext_can_scan (wext) == FALSE)) {
nm_log_info (LOGD_HW | LOGD_WIFI,
nm_log_info (LOGD_PLATFORM | LOGD_WIFI,
"(%s): drivers that cannot scan are unsupported",
wext->parent.iface);
goto error;
@ -625,12 +625,12 @@ wifi_wext_init (const char *iface, int ifindex, gboolean check_scan)
*/
scan_capa_range = (struct iw_range_with_scan_capa *) &range;
if (scan_capa_range->scan_capa & NM_IW_SCAN_CAPA_ESSID) {
nm_log_info (LOGD_HW | LOGD_WIFI,
nm_log_info (LOGD_PLATFORM | LOGD_WIFI,
"(%s): driver supports SSID scans (scan_capa 0x%02X).",
wext->parent.iface,
scan_capa_range->scan_capa);
} else {
nm_log_info (LOGD_HW | LOGD_WIFI,
nm_log_info (LOGD_PLATFORM | LOGD_WIFI,
"(%s): driver does not support SSID scans (scan_capa 0x%02X).",
wext->parent.iface,
scan_capa_range->scan_capa);
@ -644,7 +644,7 @@ wifi_wext_init (const char *iface, int ifindex, gboolean check_scan)
if (has_5ghz)
wext->parent.caps |= NM_WIFI_DEVICE_CAP_FREQ_5GHZ;
nm_log_info (LOGD_HW | LOGD_WIFI,
nm_log_info (LOGD_PLATFORM | LOGD_WIFI,
"(%s): using WEXT for WiFi device control",
wext->parent.iface);

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

@ -1874,7 +1874,7 @@ have_connection_for_device (NMSettings *self, NMDevice *device)
g_return_val_if_fail (NM_IS_SETTINGS (self), FALSE);
perm_hw_addr = nm_device_get_permanent_hw_address (device, FALSE);
perm_hw_addr = nm_device_get_permanent_hw_address (device);
/* Find a wired connection locked to the given MAC address, if any */
g_hash_table_iter_init (&iter, priv->connections);

1
tools/run-test-valgrind.sh
View file

@ -91,6 +91,7 @@ if [ "$NMTST_LAUNCH_DBUS" == "yes" ]; then
fi
if [ "$NMTST_NO_VALGRIND" != "" ]; then
"${NMTST_DBUS_RUN_SESSION[@]}" \
"$TEST" "$@"
exit $?
fi