diff --git a/src/devices/nm-device-generic.c b/src/devices/nm-device-generic.c index 0be55d54f0..0689d71676 100644 --- a/src/devices/nm-device-generic.c +++ b/src/devices/nm-device-generic.c @@ -138,7 +138,7 @@ constructor (GType type, n_construct_params, construct_params); - nm_device_set_unmanaged_initial (NM_DEVICE (object), NM_UNMANAGED_DEFAULT, TRUE); + nm_device_set_unmanaged_flags_initial (NM_DEVICE (object), NM_UNMANAGED_DEFAULT, TRUE); return object; } diff --git a/src/devices/nm-device-vlan.c b/src/devices/nm-device-vlan.c index 734a483bdc..3cd7d9c6ac 100644 --- a/src/devices/nm-device-vlan.c +++ b/src/devices/nm-device-vlan.c @@ -77,7 +77,7 @@ parent_state_changed (NMDevice *parent, if (reason == NM_DEVICE_STATE_REASON_CARRIER) return; - nm_device_set_unmanaged (NM_DEVICE (self), NM_UNMANAGED_PARENT, !nm_device_get_managed (parent), reason); + nm_device_set_unmanaged_flags (NM_DEVICE (self), NM_UNMANAGED_PARENT, !nm_device_get_managed (parent), reason); } static void @@ -134,10 +134,10 @@ nm_device_vlan_set_parent (NMDeviceVlan *self, NMDevice *parent) G_CALLBACK (parent_hwaddr_changed), device); /* Set parent-dependent unmanaged flag */ - nm_device_set_unmanaged (device, - NM_UNMANAGED_PARENT, - !nm_device_get_managed (parent), - NM_DEVICE_STATE_REASON_PARENT_MANAGED_CHANGED); + nm_device_set_unmanaged_flags (device, + NM_UNMANAGED_PARENT, + !nm_device_get_managed (parent), + NM_DEVICE_STATE_REASON_PARENT_MANAGED_CHANGED); } /* Recheck availability now that the parent has changed */ diff --git a/src/devices/nm-device.c b/src/devices/nm-device.c index 2011bcbb06..9995009dcf 100644 --- a/src/devices/nm-device.c +++ b/src/devices/nm-device.c @@ -1174,7 +1174,7 @@ nm_device_finish_init (NMDevice *self) && priv->ifindex > 0 && ( !priv->up || !priv->platform_link_initialized)) - nm_device_set_unmanaged_initial (self, NM_UNMANAGED_EXTERNAL_DOWN, TRUE); + nm_device_set_unmanaged_flags_initial (self, NM_UNMANAGED_EXTERNAL_DOWN, TRUE); if (priv->master) nm_device_enslave_slave (priv->master, self, NULL); @@ -1184,19 +1184,19 @@ nm_device_finish_init (NMDevice *self) /* Unmanaged the loopback device with an explicit NM_UNMANAGED_LOOPBACK flag. * Later we might want to manage 'lo' too. Currently that doesn't work because * NetworkManager might down the interface or remove the 127.0.0.1 address. */ - nm_device_set_unmanaged_initial (self, NM_UNMANAGED_LOOPBACK, TRUE); + nm_device_set_unmanaged_flags_initial (self, NM_UNMANAGED_LOOPBACK, TRUE); } else if (priv->platform_link_initialized || (priv->is_nm_owned && nm_device_is_software (self))) { gboolean platform_unmanaged = FALSE; if (nm_platform_link_get_unmanaged (NM_PLATFORM_GET, priv->ifindex, &platform_unmanaged)) - nm_device_set_unmanaged_initial (self, NM_UNMANAGED_DEFAULT, platform_unmanaged); + nm_device_set_unmanaged_flags_initial (self, NM_UNMANAGED_DEFAULT, platform_unmanaged); } else { /* Hardware and externally-created software links stay unmanaged * until they are fully initialized by the platform. NM created * links must be available for activation immediately and thus * do not get the PLATFORM_INIT unmanaged flag set. */ - nm_device_set_unmanaged_initial (self, NM_UNMANAGED_PLATFORM_INIT, TRUE); + nm_device_set_unmanaged_flags_initial (self, NM_UNMANAGED_PLATFORM_INIT, TRUE); } } @@ -1503,16 +1503,16 @@ device_link_changed (NMDevice *self) priv->platform_link_initialized = TRUE; if (nm_platform_link_get_unmanaged (NM_PLATFORM_GET, priv->ifindex, &platform_unmanaged)) { - nm_device_set_unmanaged (self, - NM_UNMANAGED_DEFAULT, - platform_unmanaged, - NM_DEVICE_STATE_REASON_USER_REQUESTED); + nm_device_set_unmanaged_flags (self, + NM_UNMANAGED_DEFAULT, + platform_unmanaged, + NM_DEVICE_STATE_REASON_USER_REQUESTED); } - nm_device_set_unmanaged (self, - NM_UNMANAGED_PLATFORM_INIT, - FALSE, - NM_DEVICE_STATE_REASON_NOW_MANAGED); + nm_device_set_unmanaged_flags (self, + NM_UNMANAGED_PLATFORM_INIT, + FALSE, + NM_DEVICE_STATE_REASON_NOW_MANAGED); emit_link_initialized = TRUE; } @@ -1526,7 +1526,7 @@ device_link_changed (NMDevice *self) /* Manage externally-created software interfaces only when they are IFF_UP */ g_assert (priv->ifindex > 0); if (NM_DEVICE_GET_CLASS (self)->can_unmanaged_external_down (self)) { - gboolean external_down = nm_device_get_unmanaged (self, NM_UNMANAGED_EXTERNAL_DOWN); + gboolean external_down = nm_device_get_unmanaged_flags (self, NM_UNMANAGED_EXTERNAL_DOWN); if (external_down && NM_FLAGS_HAS (info.flags, IFF_UP)) { if (nm_device_get_state (self) < NM_DEVICE_STATE_DISCONNECTED) { @@ -1540,10 +1540,10 @@ device_link_changed (NMDevice *self) * the device before assumption occurs, pass * NM_DEVICE_STATE_REASON_CONNECTION_ASSUMED as the reason. */ - nm_device_set_unmanaged (self, - NM_UNMANAGED_EXTERNAL_DOWN, - FALSE, - NM_DEVICE_STATE_REASON_CONNECTION_ASSUMED); + nm_device_set_unmanaged_flags (self, + NM_UNMANAGED_EXTERNAL_DOWN, + FALSE, + NM_DEVICE_STATE_REASON_CONNECTION_ASSUMED); } else { /* Don't trigger a state change; if the device is in a * state higher than UNAVAILABLE, it is already IFF_UP @@ -1555,10 +1555,10 @@ device_link_changed (NMDevice *self) /* If the device is already disconnected and is set !IFF_UP, * unmanage it. */ - nm_device_set_unmanaged (self, - NM_UNMANAGED_EXTERNAL_DOWN, - TRUE, - NM_DEVICE_STATE_REASON_USER_REQUESTED); + nm_device_set_unmanaged_flags (self, + NM_UNMANAGED_EXTERNAL_DOWN, + TRUE, + NM_DEVICE_STATE_REASON_USER_REQUESTED); } } } @@ -8258,13 +8258,13 @@ nm_device_get_managed (NMDevice *self) } /** - * nm_device_get_unmanaged(): + * nm_device_get_unmanaged_flags(): * @self: the #NMDevice * * Returns: %TRUE if the device is unmanaged for @flag. */ gboolean -nm_device_get_unmanaged (NMDevice *self, NMUnmanagedFlags flag) +nm_device_get_unmanaged_flags (NMDevice *self, NMUnmanagedFlags flag) { return NM_FLAGS_ANY (NM_DEVICE_GET_PRIVATE (self)->unmanaged_flags, flag); } @@ -8278,7 +8278,7 @@ nm_device_get_unmanaged (NMDevice *self, NMUnmanagedFlags flag) static gboolean nm_device_get_default_unmanaged (NMDevice *self) { - return nm_device_get_unmanaged (self, NM_UNMANAGED_DEFAULT); + return nm_device_get_unmanaged_flags (self, NM_UNMANAGED_DEFAULT); } static void @@ -8310,10 +8310,10 @@ _set_unmanaged_flags (NMDevice *self, } void -nm_device_set_unmanaged (NMDevice *self, - NMUnmanagedFlags flag, - gboolean unmanaged, - NMDeviceStateReason reason) +nm_device_set_unmanaged_flags (NMDevice *self, + NMUnmanagedFlags flag, + gboolean unmanaged, + NMDeviceStateReason reason) { NMDevicePrivate *priv; gboolean was_managed, now_managed; @@ -8340,7 +8340,7 @@ nm_device_set_unmanaged (NMDevice *self, } void -nm_device_set_unmanaged_by_device_spec (NMDevice *self, const GSList *unmanaged_specs) +nm_device_set_unmanaged_flags_by_device_spec (NMDevice *self, const GSList *unmanaged_specs) { NMDevicePrivate *priv; gboolean unmanaged; @@ -8353,28 +8353,28 @@ nm_device_set_unmanaged_by_device_spec (NMDevice *self, const GSList *unmanaged_ return; unmanaged = nm_device_spec_match_list (self, unmanaged_specs); - nm_device_set_unmanaged (self, - NM_UNMANAGED_USER, - unmanaged, - unmanaged - ? NM_DEVICE_STATE_REASON_NOW_UNMANAGED - : NM_DEVICE_STATE_REASON_NOW_MANAGED); + nm_device_set_unmanaged_flags (self, + NM_UNMANAGED_USER, + unmanaged, + unmanaged + ? NM_DEVICE_STATE_REASON_NOW_UNMANAGED + : NM_DEVICE_STATE_REASON_NOW_MANAGED); } /** - * nm_device_set_unmanaged_initial(): + * nm_device_set_unmanaged_flags_initial(): * @self: the #NMDevice * @flag: an #NMUnmanagedFlag * @unmanaged: %TRUE or %FALSE to set or clear @flag * - * Like nm_device_set_unmanaged(), but must be set before the device is + * Like nm_device_set_unmanaged_flags(), but must be set before the device is * initialized by nm_device_finish_init(), and does not trigger state changes. * Should only be used when initializing a device. */ void -nm_device_set_unmanaged_initial (NMDevice *self, - NMUnmanagedFlags flag, - gboolean unmanaged) +nm_device_set_unmanaged_flags_initial (NMDevice *self, + NMUnmanagedFlags flag, + gboolean unmanaged) { NMDevicePrivate *priv; @@ -8396,10 +8396,10 @@ nm_device_set_unmanaged_quitting (NMDevice *self) if (nm_device_is_activating (self) || priv->state == NM_DEVICE_STATE_ACTIVATED) _set_state_full (self, NM_DEVICE_STATE_DEACTIVATING, NM_DEVICE_STATE_REASON_NOW_UNMANAGED, TRUE); - nm_device_set_unmanaged (self, - NM_UNMANAGED_INTERNAL, - TRUE, - NM_DEVICE_STATE_REASON_NOW_UNMANAGED); + nm_device_set_unmanaged_flags (self, + NM_UNMANAGED_INTERNAL, + TRUE, + NM_DEVICE_STATE_REASON_NOW_UNMANAGED); } /*****************************************************************************/ @@ -8568,7 +8568,7 @@ _nm_device_check_connection_available (NMDevice *self, if (state < NM_DEVICE_STATE_UNMANAGED) return FALSE; if ( state < NM_DEVICE_STATE_UNAVAILABLE - && nm_device_get_unmanaged (self, NM_UNMANAGED_ALL & ~NM_UNMANAGED_DEFAULT)) + && nm_device_get_unmanaged_flags (self, NM_UNMANAGED_ALL & ~NM_UNMANAGED_DEFAULT)) return FALSE; if ( state < NM_DEVICE_STATE_DISCONNECTED && !nm_device_is_software (self) @@ -10214,10 +10214,10 @@ set_property (GObject *object, guint prop_id, case PROP_MANAGED: val_bool = g_value_get_boolean (value); priv->managed_touched_by_user = TRUE; - nm_device_set_unmanaged (self, - NM_UNMANAGED_USER | (val_bool ? NM_UNMANAGED_DEFAULT : NM_UNMANAGED_NONE), - !val_bool, - NM_DEVICE_STATE_REASON_USER_REQUESTED); + nm_device_set_unmanaged_flags (self, + NM_UNMANAGED_USER | (val_bool ? NM_UNMANAGED_DEFAULT : NM_UNMANAGED_NONE), + !val_bool, + NM_DEVICE_STATE_REASON_USER_REQUESTED); break; case PROP_AUTOCONNECT: nm_device_set_autoconnect (self, g_value_get_boolean (value)); diff --git a/src/devices/nm-device.h b/src/devices/nm-device.h index 37f2229351..57ab9ec89d 100644 --- a/src/devices/nm-device.h +++ b/src/devices/nm-device.h @@ -473,15 +473,15 @@ typedef enum { /*< skip >*/ } NMUnmanagedFlags; gboolean nm_device_get_managed (NMDevice *device); -gboolean nm_device_get_unmanaged (NMDevice *device, NMUnmanagedFlags flag); -void nm_device_set_unmanaged (NMDevice *device, - NMUnmanagedFlags flag, - gboolean unmanaged, - NMDeviceStateReason reason); -void nm_device_set_unmanaged_by_device_spec (NMDevice *self, const GSList *unmanaged_specs); -void nm_device_set_unmanaged_initial (NMDevice *device, - NMUnmanagedFlags flag, - gboolean unmanaged); +gboolean nm_device_get_unmanaged_flags (NMDevice *device, NMUnmanagedFlags flag); +void nm_device_set_unmanaged_flags (NMDevice *device, + NMUnmanagedFlags flag, + gboolean unmanaged, + NMDeviceStateReason reason); +void nm_device_set_unmanaged_flags_by_device_spec (NMDevice *self, const GSList *unmanaged_specs); +void nm_device_set_unmanaged_flags_initial (NMDevice *device, + NMUnmanagedFlags flag, + gboolean unmanaged); void nm_device_set_unmanaged_quitting (NMDevice *device); gboolean nm_device_get_is_nm_owned (NMDevice *device); diff --git a/src/nm-manager.c b/src/nm-manager.c index d76b5a7248..819ec5cc0b 100644 --- a/src/nm-manager.c +++ b/src/nm-manager.c @@ -829,7 +829,7 @@ remove_device (NMManager *manager, if (quitting) nm_device_set_unmanaged_quitting (device); else - nm_device_set_unmanaged (device, NM_UNMANAGED_INTERNAL, TRUE, NM_DEVICE_STATE_REASON_REMOVED); + nm_device_set_unmanaged_flags (device, NM_UNMANAGED_INTERNAL, TRUE, NM_DEVICE_STATE_REASON_REMOVED); } else if (quitting && nm_config_get_configure_and_quit (nm_config_get ())) { nm_device_spawn_iface_helper (device); } @@ -1128,7 +1128,7 @@ system_unmanaged_devices_changed_cb (NMSettings *settings, unmanaged_specs = nm_settings_get_unmanaged_specs (priv->settings); for (iter = priv->devices; iter; iter = g_slist_next (iter)) - nm_device_set_unmanaged_by_device_spec (NM_DEVICE (iter->data), unmanaged_specs); + nm_device_set_unmanaged_flags_by_device_spec (NM_DEVICE (iter->data), unmanaged_specs); } static void @@ -1623,7 +1623,7 @@ can_start_device (NMManager *self, NMDevice *device) { return nm_device_is_real (device) && !manager_sleeping (self) - && !nm_device_get_unmanaged (device, NM_UNMANAGED_ALL & ~NM_UNMANAGED_DEFAULT); + && !nm_device_get_unmanaged_flags (device, NM_UNMANAGED_ALL & ~NM_UNMANAGED_DEFAULT); } static gboolean @@ -1665,7 +1665,7 @@ recheck_assume_connection (NMDevice *device, gpointer user_data) NM_DEVICE_STATE_REASON_CONFIG_FAILED); /* Return default-unmanaged devices to their original state */ - if (nm_device_get_unmanaged (device, NM_UNMANAGED_DEFAULT)) { + if (nm_device_get_unmanaged_flags (device, NM_UNMANAGED_DEFAULT)) { nm_device_state_changed (device, NM_DEVICE_STATE_UNMANAGED, NM_DEVICE_STATE_REASON_CONFIG_FAILED); @@ -1832,12 +1832,12 @@ add_device (NMManager *self, NMDevice *device) nm_log_info (LOGD_HW, "(%s): new %s device", iface, type_desc); unmanaged_specs = nm_settings_get_unmanaged_specs (priv->settings); - nm_device_set_unmanaged_initial (device, - NM_UNMANAGED_USER, - nm_device_spec_match_list (device, unmanaged_specs)); - nm_device_set_unmanaged_initial (device, - NM_UNMANAGED_INTERNAL, - manager_sleeping (self)); + nm_device_set_unmanaged_flags_initial (device, + NM_UNMANAGED_USER, + nm_device_spec_match_list (device, unmanaged_specs)); + nm_device_set_unmanaged_flags_initial (device, + NM_UNMANAGED_INTERNAL, + manager_sleeping (self)); dbus_path = nm_exported_object_export (NM_EXPORTED_OBJECT (device)); nm_log_dbg (LOGD_DEVICE, "(%s): exported as %s", nm_device_get_iface (device), dbus_path); @@ -3746,7 +3746,7 @@ do_sleep_wake (NMManager *self, gboolean sleeping_changed) if (suspending && device_is_wake_on_lan (device)) continue; - nm_device_set_unmanaged (device, NM_UNMANAGED_INTERNAL, TRUE, NM_DEVICE_STATE_REASON_SLEEPING); + nm_device_set_unmanaged_flags (device, NM_UNMANAGED_INTERNAL, TRUE, NM_DEVICE_STATE_REASON_SLEEPING); } } else { nm_log_info (LOGD_SUSPEND, "%s...", waking_from_suspend ? "waking up" : "re-enabling"); @@ -3761,7 +3761,7 @@ do_sleep_wake (NMManager *self, gboolean sleeping_changed) if (nm_device_is_software (device)) continue; if (device_is_wake_on_lan (device)) - nm_device_set_unmanaged (device, NM_UNMANAGED_INTERNAL, TRUE, NM_DEVICE_STATE_REASON_SLEEPING); + nm_device_set_unmanaged_flags (device, NM_UNMANAGED_INTERNAL, TRUE, NM_DEVICE_STATE_REASON_SLEEPING); } } @@ -3797,7 +3797,7 @@ do_sleep_wake (NMManager *self, gboolean sleeping_changed) g_object_set (G_OBJECT (device), NM_DEVICE_AUTOCONNECT, TRUE, NULL); - nm_device_set_unmanaged (device, NM_UNMANAGED_INTERNAL, FALSE, NM_DEVICE_STATE_REASON_NOW_MANAGED); + nm_device_set_unmanaged_flags (device, NM_UNMANAGED_INTERNAL, FALSE, NM_DEVICE_STATE_REASON_NOW_MANAGED); } }