diff --git a/docs/internal/device.md b/docs/internal/device.md index 0042fdc55..c28257d60 100644 --- a/docs/internal/device.md +++ b/docs/internal/device.md @@ -304,8 +304,8 @@ Note that the unmanaged flags are tracked via two variables practice a tri-state variable with possible values TRUE (unmanaged), FALSE (managed) and UNSET. -External devices and sys-iface-state ------------------------------------- +External devices and managed-type +--------------------------------- Even if a device is managed, that doesn't mean that NetworkManager is actively configuring it. When a device is created externally (for @@ -314,7 +314,7 @@ creates a in-memory connection representing the configuration parameters on the interface such as IP addresses, routes, DNS, etc.; the connection appears as active but NetworkManager doesn't actually touch the interface. The external status is tracked in the -`sys-iface-state` member, which can have the following values: +`managed-type` member, which can have the following values: - EXTERNAL: the interface is not touched by NM. - ASSUME: this value is deprecated; it used to mean that NM should manage the device without fully reconfiguring it. Now, the interface is either managed on external. diff --git a/src/core/devices/nm-device-bond.c b/src/core/devices/nm-device-bond.c index 06a02d1a7..b60dd3f17 100644 --- a/src/core/devices/nm-device-bond.c +++ b/src/core/devices/nm-device-bond.c @@ -608,12 +608,12 @@ act_stage1_prepare(NMDevice *device, NMDeviceStateReason *out_failure_reason) s_bond = nm_connection_get_setting_bond(connection); g_return_val_if_fail(s_bond, NM_ACT_STAGE_RETURN_FAILURE); - if (nm_device_sys_iface_state_is_external(device)) + if (nm_device_managed_type_is_external(device)) return NM_ACT_STAGE_RETURN_SUCCESS; _balance_slb_setup(self, connection); - if (nm_device_sys_iface_state_is_external_or_assume(device)) + if (nm_device_managed_type_is_external_or_assume(device)) return NM_ACT_STAGE_RETURN_SUCCESS; _platform_lnk_bond_init_from_setting(s_bond, &props); diff --git a/src/core/devices/nm-device-bridge.c b/src/core/devices/nm-device-bridge.c index 7a496d965..a237c0b73 100644 --- a/src/core/devices/nm-device-bridge.c +++ b/src/core/devices/nm-device-bridge.c @@ -1049,7 +1049,7 @@ attach_port(NMDevice *device, nm_assert(s_bridge); s_port = nm_connection_get_setting_bridge_port(connection); - if (!nm_device_sys_iface_state_is_external(device)) + if (!nm_device_managed_type_is_external(device)) bridge_set_vlan_options(device, s_bridge, FALSE); if (nm_setting_bridge_get_vlan_filtering(s_bridge)) { diff --git a/src/core/devices/nm-device-ethernet.c b/src/core/devices/nm-device-ethernet.c index 8c2a96430..169925245 100644 --- a/src/core/devices/nm-device-ethernet.c +++ b/src/core/devices/nm-device-ethernet.c @@ -988,8 +988,8 @@ act_stage1_prepare(NMDevice *device, NMDeviceStateReason *out_failure_reason) NMDeviceEthernet *self = NM_DEVICE_ETHERNET(device); NMDeviceEthernetPrivate *priv = NM_DEVICE_ETHERNET_GET_PRIVATE(self); - if (nm_device_sys_iface_state_is_external_or_assume(device)) { - if (!priv->ethtool_prev_set && !nm_device_sys_iface_state_is_external(device)) { + if (nm_device_managed_type_is_external_or_assume(device)) { + if (!priv->ethtool_prev_set && !nm_device_managed_type_is_external(device)) { NMSettingWired *s_wired; /* During restart of NetworkManager service we forget the original auto diff --git a/src/core/devices/nm-device-utils.c b/src/core/devices/nm-device-utils.c index 4597ba85e..5f10431f7 100644 --- a/src/core/devices/nm-device-utils.c +++ b/src/core/devices/nm-device-utils.c @@ -152,14 +152,13 @@ NM_UTILS_LOOKUP_STR_DEFINE(nm_device_mtu_source_to_string, NM_UTILS_LOOKUP_STR_ITEM(NM_DEVICE_MTU_SOURCE_CONNECTION, "connection"), ); -NM_UTILS_LOOKUP_STR_DEFINE(nm_device_sys_iface_state_to_string, - NMDeviceSysIfaceState, +NM_UTILS_LOOKUP_STR_DEFINE(nm_device_managed_type_to_string, + NMDeviceManagedType, NM_UTILS_LOOKUP_DEFAULT_NM_ASSERT("unknown"), - NM_UTILS_LOOKUP_STR_ITEM(NM_DEVICE_SYS_IFACE_STATE_EXTERNAL, "external"), - NM_UTILS_LOOKUP_STR_ITEM(NM_DEVICE_SYS_IFACE_STATE_ASSUME, "assume"), - NM_UTILS_LOOKUP_STR_ITEM(NM_DEVICE_SYS_IFACE_STATE_MANAGED, "managed"), - NM_UTILS_LOOKUP_STR_ITEM(NM_DEVICE_SYS_IFACE_STATE_REMOVED, - "removed"), ); + NM_UTILS_LOOKUP_STR_ITEM(NM_DEVICE_MANAGED_TYPE_EXTERNAL, "external"), + NM_UTILS_LOOKUP_STR_ITEM(NM_DEVICE_MANAGED_TYPE_ASSUME, "assume"), + NM_UTILS_LOOKUP_STR_ITEM(NM_DEVICE_MANAGED_TYPE_MANAGED, "managed"), + NM_UTILS_LOOKUP_STR_ITEM(NM_DEVICE_MANAGED_TYPE_REMOVED, "removed"), ); NM_UTILS_LOOKUP_STR_DEFINE(nm_device_ip_state_to_string, NMDeviceIPState, diff --git a/src/core/devices/nm-device-utils.h b/src/core/devices/nm-device-utils.h index 7b879c907..887ee5408 100644 --- a/src/core/devices/nm-device-utils.h +++ b/src/core/devices/nm-device-utils.h @@ -57,19 +57,19 @@ const char *nm_device_mtu_source_to_string(NMDeviceMtuSource mtu_source); /*****************************************************************************/ typedef enum _nm_packed { - NM_DEVICE_SYS_IFACE_STATE_EXTERNAL, - NM_DEVICE_SYS_IFACE_STATE_ASSUME, - NM_DEVICE_SYS_IFACE_STATE_MANAGED, + NM_DEVICE_MANAGED_TYPE_EXTERNAL, + NM_DEVICE_MANAGED_TYPE_ASSUME, + NM_DEVICE_MANAGED_TYPE_MANAGED, /* the REMOVED state applies when the device is manually set to unmanaged * or the link was externally removed. In both cases, we move the device * to UNMANAGED state, without touching the link -- be it, because the link * is already gone or because we want to release it (give it up). */ - NM_DEVICE_SYS_IFACE_STATE_REMOVED, -} NMDeviceSysIfaceState; + NM_DEVICE_MANAGED_TYPE_REMOVED, +} NMDeviceManagedType; -const char *nm_device_sys_iface_state_to_string(NMDeviceSysIfaceState sys_iface_state); +const char *nm_device_managed_type_to_string(NMDeviceManagedType managed_type); /*****************************************************************************/ diff --git a/src/core/devices/nm-device-vlan.c b/src/core/devices/nm-device-vlan.c index cc649ec9d..d46309995 100644 --- a/src/core/devices/nm-device-vlan.c +++ b/src/core/devices/nm-device-vlan.c @@ -72,7 +72,7 @@ parent_hwaddr_maybe_changed(NMDevice *parent, GParamSpec *pspec, gpointer user_d const char *new_mac; /* Never touch assumed devices */ - if (nm_device_sys_iface_state_is_external_or_assume(device)) + if (nm_device_managed_type_is_external_or_assume(device)) return; connection = nm_device_get_applied_connection(device); diff --git a/src/core/devices/nm-device-wireguard.c b/src/core/devices/nm-device-wireguard.c index dd40d11e4..00a8c7187 100644 --- a/src/core/devices/nm-device-wireguard.c +++ b/src/core/devices/nm-device-wireguard.c @@ -1586,26 +1586,25 @@ act_stage2_config(NMDevice *device, NMDeviceStateReason *out_failure_reason) { NMDeviceWireGuard *self = NM_DEVICE_WIREGUARD(device); NMDeviceWireGuardPrivate *priv = NM_DEVICE_WIREGUARD_GET_PRIVATE(self); - NMDeviceSysIfaceState sys_iface_state; + NMDeviceManagedType managed_type; NMDeviceStateReason failure_reason; NMActStageReturn ret; - sys_iface_state = nm_device_sys_iface_state_get(device); + managed_type = nm_device_managed_type_get(device); - if (sys_iface_state == NM_DEVICE_SYS_IFACE_STATE_EXTERNAL) { + if (managed_type == NM_DEVICE_MANAGED_TYPE_EXTERNAL) { NM_SET_OUT(out_failure_reason, NM_DEVICE_STATE_REASON_NONE); return NM_ACT_STAGE_RETURN_SUCCESS; } - ret = - link_config(NM_DEVICE_WIREGUARD(device), - "configure", - (sys_iface_state == NM_DEVICE_SYS_IFACE_STATE_ASSUME) ? LINK_CONFIG_MODE_ASSUME - : LINK_CONFIG_MODE_FULL, - &failure_reason); + ret = link_config(NM_DEVICE_WIREGUARD(device), + "configure", + (managed_type == NM_DEVICE_MANAGED_TYPE_ASSUME) ? LINK_CONFIG_MODE_ASSUME + : LINK_CONFIG_MODE_FULL, + &failure_reason); if (ret == NM_ACT_STAGE_RETURN_FAILURE) { - if (sys_iface_state == NM_DEVICE_SYS_IFACE_STATE_ASSUME) { + if (managed_type == NM_DEVICE_MANAGED_TYPE_ASSUME) { /* this never fails. */ return NM_ACT_STAGE_RETURN_SUCCESS; } diff --git a/src/core/devices/nm-device.c b/src/core/devices/nm-device.c index 3c8cdec71..141760163 100644 --- a/src/core/devices/nm-device.c +++ b/src/core/devices/nm-device.c @@ -571,11 +571,11 @@ typedef struct _NMDevicePrivate { }; union { - const NMDeviceSysIfaceState sys_iface_state; - NMDeviceSysIfaceState sys_iface_state_; + const NMDeviceManagedType managed_type; + NMDeviceManagedType managed_type_; }; - NMDeviceSysIfaceState sys_iface_state_before_sleep; + NMDeviceManagedType managed_type_before_sleep; bool carrier : 1; bool ignore_carrier : 1; @@ -3357,47 +3357,47 @@ nm_device_create_l3_config_data_from_connection(NMDevice *self, NMConnection *co /*****************************************************************************/ -NMDeviceSysIfaceState -nm_device_sys_iface_state_get(NMDevice *self) +NMDeviceManagedType +nm_device_managed_type_get(NMDevice *self) { - g_return_val_if_fail(NM_IS_DEVICE(self), NM_DEVICE_SYS_IFACE_STATE_EXTERNAL); + g_return_val_if_fail(NM_IS_DEVICE(self), NM_DEVICE_MANAGED_TYPE_EXTERNAL); - return NM_DEVICE_GET_PRIVATE(self)->sys_iface_state; + return NM_DEVICE_GET_PRIVATE(self)->managed_type; } gboolean -nm_device_sys_iface_state_is_external(NMDevice *self) +nm_device_managed_type_is_external(NMDevice *self) { - return NM_IN_SET(nm_device_sys_iface_state_get(self), NM_DEVICE_SYS_IFACE_STATE_EXTERNAL); + return NM_IN_SET(nm_device_managed_type_get(self), NM_DEVICE_MANAGED_TYPE_EXTERNAL); } gboolean -nm_device_sys_iface_state_is_external_or_assume(NMDevice *self) +nm_device_managed_type_is_external_or_assume(NMDevice *self) { - return NM_IN_SET(nm_device_sys_iface_state_get(self), - NM_DEVICE_SYS_IFACE_STATE_EXTERNAL, - NM_DEVICE_SYS_IFACE_STATE_ASSUME); + return NM_IN_SET(nm_device_managed_type_get(self), + NM_DEVICE_MANAGED_TYPE_EXTERNAL, + NM_DEVICE_MANAGED_TYPE_ASSUME); } void -nm_device_sys_iface_state_set(NMDevice *self, NMDeviceSysIfaceState sys_iface_state) +nm_device_managed_type_set(NMDevice *self, NMDeviceManagedType managed_type) { NMDevicePrivate *priv; g_return_if_fail(NM_IS_DEVICE(self)); - g_return_if_fail(NM_IN_SET(sys_iface_state, - NM_DEVICE_SYS_IFACE_STATE_EXTERNAL, - NM_DEVICE_SYS_IFACE_STATE_ASSUME, - NM_DEVICE_SYS_IFACE_STATE_MANAGED, - NM_DEVICE_SYS_IFACE_STATE_REMOVED)); + g_return_if_fail(NM_IN_SET(managed_type, + NM_DEVICE_MANAGED_TYPE_EXTERNAL, + NM_DEVICE_MANAGED_TYPE_ASSUME, + NM_DEVICE_MANAGED_TYPE_MANAGED, + NM_DEVICE_MANAGED_TYPE_REMOVED)); priv = NM_DEVICE_GET_PRIVATE(self); - if (priv->sys_iface_state != sys_iface_state) { + if (priv->managed_type != managed_type) { _LOGT(LOGD_DEVICE, "managed-type: %s -> %s", - nm_device_sys_iface_state_to_string(priv->sys_iface_state), - nm_device_sys_iface_state_to_string(sys_iface_state)); - priv->sys_iface_state_ = sys_iface_state; + nm_device_managed_type_to_string(priv->managed_type), + nm_device_managed_type_to_string(managed_type)); + priv->managed_type_ = managed_type; _dev_l3_cfg_commit_type_reset(self); nm_device_l3cfg_commit(self, NM_L3_CFG_COMMIT_TYPE_AUTO, FALSE); } @@ -3406,7 +3406,7 @@ nm_device_sys_iface_state_set(NMDevice *self, NMDeviceSysIfaceState sys_iface_st * * If you change this, make sure that all callers are fine with such actions. */ - nm_assert(priv->sys_iface_state == sys_iface_state); + nm_assert(priv->managed_type == managed_type); } void @@ -3414,15 +3414,15 @@ nm_device_notify_sleeping(NMDevice *self) { NMDevicePrivate *priv = NM_DEVICE_GET_PRIVATE(self); - priv->sys_iface_state_before_sleep = priv->sys_iface_state; + priv->managed_type_before_sleep = priv->managed_type; } -NMDeviceSysIfaceState -nm_device_get_sys_iface_state_before_sleep(NMDevice *self) +NMDeviceManagedType +nm_device_get_managed_type_before_sleep(NMDevice *self) { NMDevicePrivate *priv = NM_DEVICE_GET_PRIVATE(self); - return priv->sys_iface_state_before_sleep; + return priv->managed_type_before_sleep; } static void @@ -3820,7 +3820,7 @@ _dev_ip_state_check(NMDevice *self, int addr_family) goto got_ip_state; } - if (nm_device_sys_iface_state_is_external(self)) { + if (nm_device_managed_type_is_external(self)) { ip_state = NM_DEVICE_IP_STATE_READY; goto got_ip_state; } @@ -4005,7 +4005,7 @@ got_ip_state: /* If both IP states failed, or one failed and the other is disabled * then it's a failure. may-fail does not mean that both families may * fail, instead it means that at least one family must succeed. */ - if (nm_device_sys_iface_state_is_external_or_assume(self)) { + if (nm_device_managed_type_is_external_or_assume(self)) { _dev_ip_state_set_state(self, AF_INET, NM_DEVICE_IP_STATE_READY, "assumed"); _dev_ip_state_set_state(self, AF_INET6, NM_DEVICE_IP_STATE_READY, "assumed"); combinedip_state = NM_DEVICE_IP_STATE_READY; @@ -4458,7 +4458,7 @@ _dev_l3_register_l3cds(NMDevice *self, if (!l3cfg) return FALSE; - is_external = nm_device_sys_iface_state_is_external(self); + is_external = nm_device_managed_type_is_external(self); changed = FALSE; for (i = 0; i < (int) G_N_ELEMENTS(priv->l3cds); i++) { @@ -4530,7 +4530,7 @@ update_external_connection(NMDevice *self) /* Update external connections with configuration from platform */ - if (!nm_device_sys_iface_state_is_external(self)) + if (!nm_device_managed_type_is_external(self)) return; settings_connection = nm_device_get_settings_connection(self); @@ -4726,17 +4726,17 @@ _dev_l3_cfg_commit_type_reset(NMDevice *self) if (!priv->l3cfg) return; - switch (priv->sys_iface_state) { - case NM_DEVICE_SYS_IFACE_STATE_EXTERNAL: - case NM_DEVICE_SYS_IFACE_STATE_REMOVED: + switch (priv->managed_type) { + case NM_DEVICE_MANAGED_TYPE_EXTERNAL: + case NM_DEVICE_MANAGED_TYPE_REMOVED: commit_type = NM_L3_CFG_COMMIT_TYPE_NONE; goto do_set; - case NM_DEVICE_SYS_IFACE_STATE_ASSUME: - /* TODO: NM_DEVICE_SYS_IFACE_STATE_ASSUME, will be dropped from the code. + case NM_DEVICE_MANAGED_TYPE_ASSUME: + /* TODO: NM_DEVICE_MANAGED_TYPE_ASSUME, will be dropped from the code. * Meanwhile, the commit type must be updated. */ commit_type = NM_L3_CFG_COMMIT_TYPE_UPDATE; goto do_set; - case NM_DEVICE_SYS_IFACE_STATE_MANAGED: + case NM_DEVICE_MANAGED_TYPE_MANAGED: commit_type = NM_L3_CFG_COMMIT_TYPE_UPDATE; goto do_set; } @@ -6365,7 +6365,7 @@ concheck_update_state(NMDevice *self, _notify(self, IS_IPv4 ? PROP_IP4_CONNECTIVITY : PROP_IP6_CONNECTIVITY); - if (priv->state == NM_DEVICE_STATE_ACTIVATED && !nm_device_sys_iface_state_is_external(self)) + if (priv->state == NM_DEVICE_STATE_ACTIVATED && !nm_device_managed_type_is_external(self)) _dev_l3_register_l3cds(self, priv->l3cfg, TRUE, NM_TERNARY_DEFAULT); } @@ -6850,7 +6850,7 @@ nm_device_controller_release_port(NMDevice *self, nm_clear_g_cancellable(&info->cancellable); /* first, let subclasses handle the release ... */ - if (info->port_is_attached || nm_device_sys_iface_state_is_external(port) + if (info->port_is_attached || nm_device_managed_type_is_external(port) || release_type >= RELEASE_PORT_TYPE_CONFIG_FORCE) { NMTernary ret; @@ -7286,7 +7286,7 @@ device_update_interface_flags(NMDevice *self, const NMPlatformLink *plink) /* * Returns the reason for managing a device. The suffix "external" indicates * that the reason mainly depends on whether we want to make the device - * sys-iface-state=external or not. + * managed_type=external or not. */ NMDeviceStateReason nm_device_get_manage_reason_external(NMDevice *self) @@ -7294,14 +7294,14 @@ nm_device_get_manage_reason_external(NMDevice *self) NMDeviceStateReason reason; /* By default we return reason NOW_MANAGED, which makes the device fully - * managed by NM (sys-iface-state=managed). */ + * managed by NM (managed_type=managed). */ reason = NM_DEVICE_STATE_REASON_NOW_MANAGED; /* If the device is an external-down candidate but no longer has the flag * set, then the device is an externally created interface that previously * had no addresses or no controller and now has. * We need to set CONNECTION_ASSUMED as the reason, so that the device - * is managed but is not touched by NM (sys-iface-state=external). */ + * is managed but is not touched by NM (managed_type=external). */ if (nm_device_get_unmanaged_mask(self, NM_UNMANAGED_EXTERNAL_DOWN) && !nm_device_get_unmanaged_flags(self, NM_UNMANAGED_EXTERNAL_DOWN)) { /* user-udev overwrites external-down, so we only assume the device @@ -7449,7 +7449,7 @@ device_link_changed(gpointer user_data) * NMVpnConnection should become like a regular device, akin to NMDevicePpp). */ if (priv->state >= NM_DEVICE_STATE_IP_CONFIG && priv->state <= NM_DEVICE_STATE_ACTIVATED - && !nm_device_sys_iface_state_is_external(self)) + && !nm_device_managed_type_is_external(self)) nm_device_l3cfg_commit(self, NM_L3_CFG_COMMIT_TYPE_REAPPLY, FALSE); /* If the device is active without a carrier (probably because it is @@ -8041,7 +8041,7 @@ realize_start_setup(NMDevice *self, _assume_state_set(self, assume_state_guess_assume, assume_state_connection_uuid); - nm_device_sys_iface_state_set(self, NM_DEVICE_SYS_IFACE_STATE_EXTERNAL); + nm_device_managed_type_set(self, NM_DEVICE_MANAGED_TYPE_EXTERNAL); if (plink) nm_device_update_from_platform_link(self, plink); @@ -8469,9 +8469,9 @@ port_state_changed(NMDevice *port, } if (release) { - configure = (priv->sys_iface_state == NM_DEVICE_SYS_IFACE_STATE_MANAGED - && nm_device_sys_iface_state_get(port) != NM_DEVICE_SYS_IFACE_STATE_EXTERNAL) - || nm_device_sys_iface_state_get(port) == NM_DEVICE_SYS_IFACE_STATE_MANAGED; + configure = (priv->managed_type == NM_DEVICE_MANAGED_TYPE_MANAGED + && nm_device_managed_type_get(port) != NM_DEVICE_MANAGED_TYPE_EXTERNAL) + || nm_device_managed_type_get(port) == NM_DEVICE_MANAGED_TYPE_MANAGED; nm_device_controller_release_port(self, port, @@ -8610,7 +8610,7 @@ nm_device_controller_release_ports_all(NMDevice *self) PortInfo *safe; /* Don't release the ports if this connection doesn't belong to NM. */ - if (nm_device_sys_iface_state_is_external(self)) + if (nm_device_managed_type_is_external(self)) return; reason = priv->state_reason; @@ -8619,7 +8619,7 @@ nm_device_controller_release_ports_all(NMDevice *self) c_list_for_each_entry_safe (info, safe, &priv->ports, lst_port) { if (priv->activation_state_preserve_external_ports - && nm_device_sys_iface_state_is_external(info->port)) { + && nm_device_managed_type_is_external(info->port)) { _LOGT(LOGD_DEVICE, "controller: preserve external port %s", nm_device_get_iface(info->port)); @@ -8821,9 +8821,9 @@ nm_device_removed(NMDevice *self, gboolean unconfigure_ip_config) * commit type NONE, that doesn't emit a l3cd-changed. Do it manually, * to ensure that entries are removed from the DNS manager. */ if (priv->l3cfg - && NM_IN_SET(priv->sys_iface_state, - NM_DEVICE_SYS_IFACE_STATE_REMOVED, - NM_DEVICE_SYS_IFACE_STATE_EXTERNAL)) { + && NM_IN_SET(priv->managed_type, + NM_DEVICE_MANAGED_TYPE_REMOVED, + NM_DEVICE_MANAGED_TYPE_EXTERNAL)) { l3cd_old = nm_l3cfg_get_combined_l3cd(priv->l3cfg, TRUE); if (l3cd_old) g_signal_emit(self, signals[L3CD_CHANGED], 0, l3cd_old, NULL); @@ -9937,7 +9937,7 @@ controller_ready(NMDevice *self, NMActiveConnection *active) /* If the controller didn't change, add-port only rechecks whether to assume a connection. */ nm_device_controller_add_port(controller, self, - !nm_device_sys_iface_state_is_external_or_assume(self)); + !nm_device_managed_type_is_external_or_assume(self)); } static void @@ -10093,7 +10093,7 @@ activate_stage1_device_prepare(NMDevice *self) if (priv->stage1_sriov_state != NM_DEVICE_STAGE_STATE_COMPLETED) { NMSettingSriov *s_sriov = NULL; - if (nm_device_sys_iface_state_is_external_or_assume(self)) { + if (nm_device_managed_type_is_external_or_assume(self)) { /* pass */ } else if (priv->stage1_sriov_state == NM_DEVICE_STAGE_STATE_PENDING) { return; @@ -10163,7 +10163,7 @@ activate_stage1_device_prepare(NMDevice *self) klass = NM_DEVICE_GET_CLASS(self); if (klass->act_stage1_prepare_set_hwaddr_ethernet - && !nm_device_sys_iface_state_is_external_or_assume(self)) { + && !nm_device_managed_type_is_external_or_assume(self)) { if (!nm_device_hw_addr_set_cloned(self, nm_device_get_applied_connection(self), FALSE)) { nm_device_state_changed(self, NM_DEVICE_STATE_FAILED, @@ -10173,7 +10173,7 @@ activate_stage1_device_prepare(NMDevice *self) } if (klass->act_stage1_prepare_also_for_external_or_assume - || !nm_device_sys_iface_state_is_external_or_assume(self)) { + || !nm_device_managed_type_is_external_or_assume(self)) { nm_assert(!klass->act_stage1_prepare_also_for_external_or_assume || klass->act_stage1_prepare); if (klass->act_stage1_prepare) { @@ -10460,12 +10460,12 @@ activate_stage2_device_config(NMDevice *self) nm_device_state_changed(self, NM_DEVICE_STATE_CONFIG, NM_DEVICE_STATE_REASON_NONE); - if (!nm_device_sys_iface_state_is_external(self)) { + if (!nm_device_managed_type_is_external(self)) { _ethtool_state_set(self); nm_device_link_properties_set(self, FALSE); } - if (!nm_device_sys_iface_state_is_external(self)) { + if (!nm_device_managed_type_is_external(self)) { if (!priv->tc_committed && !tc_commit(self)) { _LOGW(LOGD_DEVICE, "failed applying traffic control rules"); nm_device_state_changed(self, @@ -10478,7 +10478,7 @@ activate_stage2_device_config(NMDevice *self) _routing_rules_sync(self, NM_TERNARY_TRUE); - if (!nm_device_sys_iface_state_is_external_or_assume(self)) { + if (!nm_device_managed_type_is_external_or_assume(self)) { if (!nm_device_bring_up_full(self, FALSE, TRUE, &no_firmware)) { nm_device_state_changed(self, NM_DEVICE_STATE_FAILED, @@ -10490,7 +10490,7 @@ activate_stage2_device_config(NMDevice *self) klass = NM_DEVICE_GET_CLASS(self); if (klass->act_stage2_config_also_for_external_or_assume - || !nm_device_sys_iface_state_is_external_or_assume(self)) { + || !nm_device_managed_type_is_external_or_assume(self)) { NMDeviceStateReason failure_reason = NM_DEVICE_STATE_REASON_NONE; ret = klass->act_stage2_config(self, &failure_reason); @@ -10511,7 +10511,7 @@ activate_stage2_device_config(NMDevice *self) nm_device_controller_attach_port(self, info->port, nm_device_get_applied_connection(info->port)); - else if (priv->act_request.obj && nm_device_sys_iface_state_is_external(self) + else if (priv->act_request.obj && nm_device_managed_type_is_external(self) && port_state <= NM_DEVICE_STATE_DISCONNECTED) nm_device_queue_recheck_assume(info->port); } @@ -11136,7 +11136,7 @@ _dev_ipdhcpx_start(NMDevice *self, int addr_family) return; } - if (nm_device_sys_iface_state_is_external(self)) { + if (nm_device_managed_type_is_external(self)) { fail_reason = nm_assert_unreachable_val("cannot run DHCP on external interface"); goto out_fail; } @@ -11745,7 +11745,7 @@ _dev_ipll6_start(NMDevice *self) connection = nm_device_get_applied_connection(self); - assume = nm_device_sys_iface_state_is_external_or_assume(self); + assume = nm_device_managed_type_is_external_or_assume(self); if (_prop_get_ipv6_addr_gen_mode(self) == NM_SETTING_IP6_CONFIG_ADDR_GEN_MODE_STABLE_PRIVACY) { NMUtilsStableType stable_type; @@ -11977,7 +11977,7 @@ _commit_mtu(NMDevice *self) if (ifindex <= 0) return; - if (!nm_device_get_applied_connection(self) || nm_device_sys_iface_state_is_external(self)) { + if (!nm_device_get_applied_connection(self) || nm_device_managed_type_is_external(self)) { /* we don't tamper with the MTU of disconnected and external devices. */ return; } @@ -12703,7 +12703,7 @@ activate_stage3_ip_config_for_addr_family(NMDevice *self, int addr_family, const NMConnection *connection; int ip_ifindex; - if (nm_device_sys_iface_state_is_external(self)) + if (nm_device_managed_type_is_external(self)) goto out; connection = nm_device_get_applied_connection(self); @@ -12940,7 +12940,7 @@ activate_stage3_ip_config(NMDevice *self) /* Add the interface to the specified firewall zone */ switch (priv->fw_state) { case FIREWALL_STATE_UNMANAGED: - if (nm_device_sys_iface_state_is_external(self)) { + if (nm_device_managed_type_is_external(self)) { /* fake success */ priv->fw_state = FIREWALL_STATE_INITIALIZED; } else if (ifindex > 0) { @@ -12970,7 +12970,7 @@ activate_stage3_ip_config(NMDevice *self) ipv6_method = nm_device_get_effective_ip_config_method(self, AF_INET6); if (!g_file_test("/proc/sys/net/ipv6", G_FILE_TEST_IS_DIR)) { - _NMLOG_ip((nm_device_sys_iface_state_is_external(self) + _NMLOG_ip((nm_device_managed_type_is_external(self) || NM_IN_STRSET(ipv6_method, NM_SETTING_IP6_CONFIG_METHOD_AUTO, NM_SETTING_IP6_CONFIG_METHOD_DISABLED, @@ -13010,7 +13010,7 @@ activate_stage3_ip_config(NMDevice *self) nm_device_state_changed(self, NM_DEVICE_STATE_IP_CONFIG, NM_DEVICE_STATE_REASON_NONE); /* Device should be up before we can do anything with it */ - if (!nm_device_sys_iface_state_is_external(self) && ifindex > 0 + if (!nm_device_managed_type_is_external(self) && ifindex > 0 && !nm_platform_link_is_up(nm_device_get_platform(self), ifindex)) _LOGW(LOGD_DEVICE, "interface %s not up for IP configuration", @@ -13026,7 +13026,7 @@ activate_stage3_ip_config(NMDevice *self) * let's do it! */ _commit_mtu(self); - if (!nm_device_sys_iface_state_is_external(self) + if (!nm_device_managed_type_is_external(self) && (!klass->ready_for_ip_config || klass->ready_for_ip_config(self, TRUE))) { if (priv->ipmanual_data.state_6 == NM_DEVICE_IP_STATE_NONE && !NM_IN_STRSET(ipv6_method, @@ -13042,7 +13042,7 @@ activate_stage3_ip_config(NMDevice *self) * IPv6LL if this is not an assumed connection, since assumed connections * will already have IPv6 set up. */ - if (!nm_device_sys_iface_state_is_external_or_assume(self)) + if (!nm_device_managed_type_is_external_or_assume(self)) _dev_addrgenmode6_set(self, NM_IN6_ADDR_GEN_MODE_NONE); /* Re-enable IPv6 on the interface */ @@ -13396,15 +13396,15 @@ act_request_set(NMDevice *self, NMActRequest *act_request) case NM_ACTIVATION_TYPE_EXTERNAL: break; case NM_ACTIVATION_TYPE_ASSUME: - if (priv->sys_iface_state == NM_DEVICE_SYS_IFACE_STATE_EXTERNAL) - nm_device_sys_iface_state_set(self, NM_DEVICE_SYS_IFACE_STATE_ASSUME); + if (priv->managed_type == NM_DEVICE_MANAGED_TYPE_EXTERNAL) + nm_device_managed_type_set(self, NM_DEVICE_MANAGED_TYPE_ASSUME); break; case NM_ACTIVATION_TYPE_MANAGED: - if (NM_IN_SET_TYPED(NMDeviceSysIfaceState, - priv->sys_iface_state, - NM_DEVICE_SYS_IFACE_STATE_EXTERNAL, - NM_DEVICE_SYS_IFACE_STATE_ASSUME)) - nm_device_sys_iface_state_set(self, NM_DEVICE_SYS_IFACE_STATE_MANAGED); + if (NM_IN_SET_TYPED(NMDeviceManagedType, + priv->managed_type, + NM_DEVICE_MANAGED_TYPE_EXTERNAL, + NM_DEVICE_MANAGED_TYPE_ASSUME)) + nm_device_managed_type_set(self, NM_DEVICE_MANAGED_TYPE_MANAGED); break; } } @@ -13947,8 +13947,8 @@ reapply_cb(NMDevice *self, return; } - if (nm_device_sys_iface_state_is_external(self)) - nm_device_sys_iface_state_set(self, NM_DEVICE_SYS_IFACE_STATE_MANAGED); + if (nm_device_managed_type_is_external(self)) + nm_device_managed_type_set(self, NM_DEVICE_MANAGED_TYPE_MANAGED); if (!check_and_reapply_connection(self, connection @@ -14432,10 +14432,10 @@ nm_device_disconnect_active_connection(NMActiveConnection *active, if (NM_ACTIVE_CONNECTION(priv->act_request.obj) == active) { if (priv->state < NM_DEVICE_STATE_DEACTIVATING) { /* When the user actively deactivates a profile, we set - * the sys-iface-state to managed so that we deconfigure/cleanup the interface. + * the managed-type to managed so that we deconfigure/cleanup the interface. * But for external connections that go down otherwise, we don't want to touch the interface. */ - if (nm_device_sys_iface_state_is_external(self)) - nm_device_sys_iface_state_set(self, NM_DEVICE_SYS_IFACE_STATE_MANAGED); + if (nm_device_managed_type_is_external(self)) + nm_device_managed_type_set(self, NM_DEVICE_MANAGED_TYPE_MANAGED); nm_device_state_changed(self, NM_DEVICE_STATE_DEACTIVATING, device_reason); } else { @@ -15702,8 +15702,7 @@ nm_device_update_firewall_zone(NMDevice *self) priv = NM_DEVICE_GET_PRIVATE(self); - if (priv->fw_state >= FIREWALL_STATE_INITIALIZED - && !nm_device_sys_iface_state_is_external(self)) + if (priv->fw_state >= FIREWALL_STATE_INITIALIZED && !nm_device_managed_type_is_external(self)) fw_change_zone(self); } @@ -16350,7 +16349,7 @@ _cleanup_generic_pre(NMDevice *self, CleanupType cleanup_type) } if (cleanup_type == CLEANUP_TYPE_DECONFIGURE && priv->fw_state >= FIREWALL_STATE_INITIALIZED - && priv->fw_mgr && !nm_device_sys_iface_state_is_external(self)) { + && priv->fw_mgr && !nm_device_managed_type_is_external(self)) { nm_firewalld_manager_remove_from_zone(priv->fw_mgr, nm_device_get_ip_iface(self), NULL, @@ -16715,7 +16714,7 @@ _set_state_full(NMDevice *self, NMDeviceState state, NMDeviceStateReason reason, old_state = priv->state; - if (state == NM_DEVICE_STATE_FAILED && nm_device_sys_iface_state_is_external_or_assume(self)) { + if (state == NM_DEVICE_STATE_FAILED && nm_device_managed_type_is_external_or_assume(self)) { /* Avoid tearing down assumed connection, assume it's connected */ state = NM_DEVICE_STATE_ACTIVATED; reason = NM_DEVICE_STATE_REASON_CONNECTION_ASSUMED; @@ -16732,7 +16731,7 @@ _set_state_full(NMDevice *self, NMDeviceState state, NMDeviceStateReason reason, nm_device_state_to_string(old_state), nm_device_state_to_string(state), nm_device_state_reason_to_string_a(reason), - nm_device_sys_iface_state_to_string(priv->sys_iface_state), + nm_device_managed_type_to_string(priv->managed_type), priv->firmware_missing ? ", missing firmware" : ""); return; } @@ -16742,7 +16741,7 @@ _set_state_full(NMDevice *self, NMDeviceState state, NMDeviceStateReason reason, nm_device_state_to_string(old_state), nm_device_state_to_string(state), nm_device_state_reason_to_string_a(reason), - nm_device_sys_iface_state_to_string(priv->sys_iface_state)); + nm_device_managed_type_to_string(priv->managed_type)); /* in order to prevent triggering any callback caused * by the device not having any pending action anymore @@ -16764,11 +16763,11 @@ _set_state_full(NMDevice *self, NMDeviceState state, NMDeviceStateReason reason, if (state > NM_DEVICE_STATE_UNMANAGED && state <= NM_DEVICE_STATE_ACTIVATED && nm_device_state_reason_check(reason) == NM_DEVICE_STATE_REASON_NOW_MANAGED - && NM_IN_SET_TYPED(NMDeviceSysIfaceState, - priv->sys_iface_state, - NM_DEVICE_SYS_IFACE_STATE_EXTERNAL, - NM_DEVICE_SYS_IFACE_STATE_ASSUME)) - nm_device_sys_iface_state_set(self, NM_DEVICE_SYS_IFACE_STATE_MANAGED); + && NM_IN_SET_TYPED(NMDeviceManagedType, + priv->managed_type, + NM_DEVICE_MANAGED_TYPE_EXTERNAL, + NM_DEVICE_MANAGED_TYPE_ASSUME)) + nm_device_managed_type_set(self, NM_DEVICE_MANAGED_TYPE_MANAGED); if (state <= NM_DEVICE_STATE_DISCONNECTED || state >= NM_DEVICE_STATE_ACTIVATED) priv->auth_retries = NM_DEVICE_AUTH_RETRIES_UNSET; @@ -16810,10 +16809,10 @@ _set_state_full(NMDevice *self, NMDeviceState state, NMDeviceStateReason reason, case NM_DEVICE_STATE_UNMANAGED: nm_device_set_firmware_missing(self, FALSE); if (old_state > NM_DEVICE_STATE_UNMANAGED) { - if (priv->sys_iface_state != NM_DEVICE_SYS_IFACE_STATE_MANAGED) { + if (priv->managed_type != NM_DEVICE_MANAGED_TYPE_MANAGED) { nm_device_cleanup(self, reason, - priv->sys_iface_state == NM_DEVICE_SYS_IFACE_STATE_REMOVED + priv->managed_type == NM_DEVICE_MANAGED_TYPE_REMOVED ? CLEANUP_TYPE_REMOVED : CLEANUP_TYPE_KEEP); } else { @@ -16826,12 +16825,12 @@ _set_state_full(NMDevice *self, NMDeviceState state, NMDeviceStateReason reason, _dev_sysctl_restore_ip6_properties(self); } } - nm_device_sys_iface_state_set(self, NM_DEVICE_SYS_IFACE_STATE_EXTERNAL); + nm_device_managed_type_set(self, NM_DEVICE_MANAGED_TYPE_EXTERNAL); break; case NM_DEVICE_STATE_UNAVAILABLE: if (old_state == NM_DEVICE_STATE_UNMANAGED) { _dev_sysctl_save_ip6_properties(self); - if (priv->sys_iface_state == NM_DEVICE_SYS_IFACE_STATE_MANAGED) + if (priv->managed_type == NM_DEVICE_MANAGED_TYPE_MANAGED) ip6_managed_setup(self); device_init_static_sriov_num_vfs(self); @@ -16843,7 +16842,7 @@ _set_state_full(NMDevice *self, NMDeviceState state, NMDeviceStateReason reason, carrier_detect_wait(self); } - if (priv->sys_iface_state == NM_DEVICE_SYS_IFACE_STATE_MANAGED) { + if (priv->managed_type == NM_DEVICE_MANAGED_TYPE_MANAGED) { if (old_state == NM_DEVICE_STATE_UNMANAGED || priv->firmware_missing) { if (!nm_device_bring_up_full(self, TRUE, FALSE, &no_firmware) && no_firmware) _LOGW(LOGD_PLATFORM, "firmware may be missing."); @@ -16867,13 +16866,13 @@ _set_state_full(NMDevice *self, NMDeviceState state, NMDeviceStateReason reason, * userspace IPv6LL enabled. */ _dev_addrgenmode6_set(self, NM_IN6_ADDR_GEN_MODE_NONE); - if (priv->sys_iface_state == NM_DEVICE_SYS_IFACE_STATE_REMOVED) { + if (priv->managed_type == NM_DEVICE_MANAGED_TYPE_REMOVED) { nm_device_cleanup(self, reason, CLEANUP_TYPE_REMOVED); } else nm_device_cleanup(self, reason, CLEANUP_TYPE_DECONFIGURE); } else if (old_state < NM_DEVICE_STATE_DISCONNECTED) { - if (priv->sys_iface_state == NM_DEVICE_SYS_IFACE_STATE_MANAGED) { + if (priv->managed_type == NM_DEVICE_MANAGED_TYPE_MANAGED) { /* Ensure IPv6 is set up as it may not have been done when * entering the UNAVAILABLE state depending on the reason. */ @@ -17036,7 +17035,7 @@ _set_state_full(NMDevice *self, NMDeviceState state, NMDeviceStateReason reason, { gboolean change_zone = FALSE; - if (!nm_device_sys_iface_state_is_external(self)) { + if (!nm_device_managed_type_is_external(self)) { if (priv->ip_iface) { /* The device now has a @ip_iface different from the * @iface on which we previously set the zone. */ @@ -18628,14 +18627,14 @@ set_property(GObject *object, guint prop_id, const GValue *value, GParamSpec *ps managed = g_value_get_boolean(value); if (managed) { reason = NM_DEVICE_STATE_REASON_CONNECTION_ASSUMED; - if (NM_IN_SET_TYPED(NMDeviceSysIfaceState, - priv->sys_iface_state, - NM_DEVICE_SYS_IFACE_STATE_EXTERNAL, - NM_DEVICE_SYS_IFACE_STATE_REMOVED)) - nm_device_sys_iface_state_set(self, NM_DEVICE_SYS_IFACE_STATE_ASSUME); + if (NM_IN_SET_TYPED(NMDeviceManagedType, + priv->managed_type, + NM_DEVICE_MANAGED_TYPE_EXTERNAL, + NM_DEVICE_MANAGED_TYPE_REMOVED)) + nm_device_managed_type_set(self, NM_DEVICE_MANAGED_TYPE_ASSUME); } else { reason = NM_DEVICE_STATE_REASON_REMOVED; - nm_device_sys_iface_state_set(self, NM_DEVICE_SYS_IFACE_STATE_REMOVED); + nm_device_managed_type_set(self, NM_DEVICE_MANAGED_TYPE_REMOVED); } nm_device_set_unmanaged_by_flags(self, NM_UNMANAGED_USER_EXPLICIT, !managed, reason); } @@ -18723,10 +18722,10 @@ nm_device_init(NMDevice *self) priv->available_connections = g_hash_table_new_full(nm_direct_hash, NULL, g_object_unref, NULL); priv->ip6_saved_properties = g_hash_table_new_full(nm_str_hash, g_str_equal, NULL, g_free); - priv->sys_iface_state_ = NM_DEVICE_SYS_IFACE_STATE_EXTERNAL; + priv->managed_type_ = NM_DEVICE_MANAGED_TYPE_EXTERNAL; /* If networking is already disabled at boot, we want to manage all devices * after re-enabling networking; hence, the initial state is MANAGED. */ - priv->sys_iface_state_before_sleep = NM_DEVICE_SYS_IFACE_STATE_MANAGED; + priv->managed_type_before_sleep = NM_DEVICE_MANAGED_TYPE_MANAGED; priv->promisc_reset = NM_OPTION_BOOL_DEFAULT; } diff --git a/src/core/devices/nm-device.h b/src/core/devices/nm-device.h index 37eda5c0c..b84bbb65e 100644 --- a/src/core/devices/nm-device.h +++ b/src/core/devices/nm-device.h @@ -726,16 +726,16 @@ nm_device_autoconnect_blocked_unset(NMDevice *device, NMDeviceAutoconnectBlocked void nm_device_recheck_auto_activate_schedule(NMDevice *device); -NMDeviceSysIfaceState nm_device_sys_iface_state_get(NMDevice *device); +NMDeviceManagedType nm_device_managed_type_get(NMDevice *device); -gboolean nm_device_sys_iface_state_is_external(NMDevice *self); -gboolean nm_device_sys_iface_state_is_external_or_assume(NMDevice *self); +gboolean nm_device_managed_type_is_external(NMDevice *self); +gboolean nm_device_managed_type_is_external_or_assume(NMDevice *self); -void nm_device_sys_iface_state_set(NMDevice *device, NMDeviceSysIfaceState sys_iface_state); +void nm_device_managed_type_set(NMDevice *device, NMDeviceManagedType managed_type); void nm_device_notify_sleeping(NMDevice *self); -NMDeviceSysIfaceState nm_device_get_sys_iface_state_before_sleep(NMDevice *self); +NMDeviceManagedType nm_device_get_managed_type_before_sleep(NMDevice *self); void nm_device_state_changed(NMDevice *device, NMDeviceState state, NMDeviceStateReason reason); diff --git a/src/core/devices/ovs/nm-device-ovs-port.c b/src/core/devices/ovs/nm-device-ovs-port.c index 2acafba23..d78f02bac 100644 --- a/src/core/devices/ovs/nm-device-ovs-port.c +++ b/src/core/devices/ovs/nm-device-ovs-port.c @@ -218,9 +218,9 @@ detach_port(NMDevice *device, gpointer user_data) { NMDeviceOvsPort *self = NM_DEVICE_OVS_PORT(device); - bool port_not_managed = !NM_IN_SET(nm_device_sys_iface_state_get(port), - NM_DEVICE_SYS_IFACE_STATE_MANAGED, - NM_DEVICE_SYS_IFACE_STATE_ASSUME); + bool port_not_managed = !NM_IN_SET(nm_device_managed_type_get(port), + NM_DEVICE_MANAGED_TYPE_MANAGED, + NM_DEVICE_MANAGED_TYPE_ASSUME); NMTernary ret = TRUE; _LOGI(LOGD_DEVICE, "detaching ovs interface %s", nm_device_get_ip_iface(port)); diff --git a/src/core/devices/team/nm-device-team.c b/src/core/devices/team/nm-device-team.c index 0f420a7a2..a4c77f7f4 100644 --- a/src/core/devices/team/nm-device-team.c +++ b/src/core/devices/team/nm-device-team.c @@ -763,10 +763,10 @@ act_stage1_prepare(NMDevice *device, NMDeviceStateReason *out_failure_reason) NMSettingTeam *s_team; const char *cfg; - if (nm_device_sys_iface_state_is_external(device)) + if (nm_device_managed_type_is_external(device)) return NM_ACT_STAGE_RETURN_SUCCESS; - if (nm_device_sys_iface_state_is_external_or_assume(device)) { + if (nm_device_managed_type_is_external_or_assume(device)) { if (ensure_teamd_connection(device, &error)) return NM_ACT_STAGE_RETURN_SUCCESS; _LOGD(LOGD_TEAM, "could not connect to teamd: %s", error->message); @@ -832,7 +832,7 @@ deactivate(NMDevice *device) priv->stage1_state = NM_DEVICE_STAGE_STATE_INIT; - if (nm_device_sys_iface_state_is_external(device)) + if (nm_device_managed_type_is_external(device)) return; if (priv->teamd_pid || priv->tdc) diff --git a/src/core/nm-active-connection.c b/src/core/nm-active-connection.c index ca1993cf6..7a6f69515 100644 --- a/src/core/nm-active-connection.c +++ b/src/core/nm-active-connection.c @@ -989,10 +989,10 @@ _set_activation_type_managed(NMActiveConnection *self) _set_activation_type(self, NM_ACTIVATION_TYPE_MANAGED); if (priv->device && self == NM_ACTIVE_CONNECTION(nm_device_get_act_request(priv->device)) - && NM_IN_SET(nm_device_sys_iface_state_get(priv->device), - NM_DEVICE_SYS_IFACE_STATE_EXTERNAL, - NM_DEVICE_SYS_IFACE_STATE_ASSUME)) - nm_device_sys_iface_state_set(priv->device, NM_DEVICE_SYS_IFACE_STATE_MANAGED); + && NM_IN_SET(nm_device_managed_type_get(priv->device), + NM_DEVICE_MANAGED_TYPE_EXTERNAL, + NM_DEVICE_MANAGED_TYPE_ASSUME)) + nm_device_managed_type_set(priv->device, NM_DEVICE_MANAGED_TYPE_MANAGED); } NMActivationReason diff --git a/src/core/nm-l3cfg.h b/src/core/nm-l3cfg.h index 241fde024..f977b10f8 100644 --- a/src/core/nm-l3cfg.h +++ b/src/core/nm-l3cfg.h @@ -354,7 +354,7 @@ gboolean nm_l3cfg_remove_config_all_dirty(NML3Cfg *self, gconstpointer tag); * nm_l3cfg_commit_type_register(). nm_l3cfg_commit_on_idle_schedule() also * accepts a one-time commit-type argument. * - * This is related to NMDevice's sys_iface_state, which we use to control whether + * This is related to NMDevice's managed_type, which we use to control whether * to touch/assume/manage the interface. * * The numeric values of the enum matters: higher number mean more "important". diff --git a/src/core/nm-manager.c b/src/core/nm-manager.c index 0a7e7b2e4..55d800dc9 100644 --- a/src/core/nm-manager.c +++ b/src/core/nm-manager.c @@ -2309,7 +2309,7 @@ remove_device(NMManager *self, NMDevice *device, gboolean quitting) if (quitting) nm_device_set_unmanaged_by_quitting(device); else { - nm_device_sys_iface_state_set(device, NM_DEVICE_SYS_IFACE_STATE_REMOVED); + nm_device_managed_type_set(device, NM_DEVICE_MANAGED_TYPE_REMOVED); nm_device_set_unmanaged_by_flags(device, NM_UNMANAGED_PLATFORM_INIT, NM_UNMAN_FLAG_OP_SET_UNMANAGED, @@ -3694,9 +3694,9 @@ recheck_assume_connection(NMManager *self, NMDevice *device) } } - nm_device_sys_iface_state_set(device, - activation_type_assume ? NM_DEVICE_SYS_IFACE_STATE_ASSUME - : NM_DEVICE_SYS_IFACE_STATE_EXTERNAL); + nm_device_managed_type_set(device, + activation_type_assume ? NM_DEVICE_MANAGED_TYPE_ASSUME + : NM_DEVICE_MANAGED_TYPE_EXTERNAL); /* Move device to DISCONNECTED to activate the connection */ if (state == NM_DEVICE_STATE_UNMANAGED) { @@ -3765,8 +3765,8 @@ recheck_assume_connection(NMManager *self, NMDevice *device) "assume: deleting generated connection after assuming failed"); nm_settings_connection_delete(sett_conn, FALSE); } else { - if (nm_device_sys_iface_state_get(device) == NM_DEVICE_SYS_IFACE_STATE_ASSUME) - nm_device_sys_iface_state_set(device, NM_DEVICE_SYS_IFACE_STATE_EXTERNAL); + if (nm_device_managed_type_get(device) == NM_DEVICE_MANAGED_TYPE_ASSUME) + nm_device_managed_type_set(device, NM_DEVICE_MANAGED_TYPE_EXTERNAL); } return FALSE; } @@ -4374,7 +4374,7 @@ _platform_link_cb_idle(PlatformLinkCbData *data) device = nm_manager_get_device_by_ifindex(self, ifindex); if (device) { if (nm_device_is_software(device)) { - nm_device_sys_iface_state_set(device, NM_DEVICE_SYS_IFACE_STATE_REMOVED); + nm_device_managed_type_set(device, NM_DEVICE_MANAGED_TYPE_REMOVED); if (!nm_device_unrealize(device, FALSE, &error)) { _LOG2W(LOGD_DEVICE, device, "failed to unrealize: %s", error->message); g_clear_error(&error); @@ -5768,7 +5768,7 @@ _internal_activate_device(NMManager *self, NMActiveConnection *active, GError ** } if (nm_active_connection_get_activation_type(active) == NM_ACTIVATION_TYPE_MANAGED) - nm_device_sys_iface_state_set(device, NM_DEVICE_SYS_IFACE_STATE_MANAGED); + nm_device_managed_type_set(device, NM_DEVICE_MANAGED_TYPE_MANAGED); /* Try to find the controller connection/device if the connection has a dependency */ if (!find_controller(self, @@ -7404,13 +7404,13 @@ do_sleep_wake(NMManager *self, gboolean sleeping_changed) nm_device_set_enabled(device, enabled); } - /* The reason determines whether the device will be sys-iface-state=managed - * or sys-iface-state=external. Pass the correct reason to restore the state + /* The reason determines whether the device will be managed_type=managed + * or managed_type=external. Pass the correct reason to restore the state * that was set before sleeping. */ - reason = nm_device_get_sys_iface_state_before_sleep(device) - == NM_DEVICE_SYS_IFACE_STATE_EXTERNAL - ? NM_DEVICE_STATE_REASON_CONNECTION_ASSUMED - : NM_DEVICE_STATE_REASON_NOW_MANAGED; + reason = + nm_device_get_managed_type_before_sleep(device) == NM_DEVICE_MANAGED_TYPE_EXTERNAL + ? NM_DEVICE_STATE_REASON_CONNECTION_ASSUMED + : NM_DEVICE_STATE_REASON_NOW_MANAGED; nm_device_set_unmanaged_by_flags(device, NM_UNMANAGED_SLEEPING, NM_UNMAN_FLAG_OP_SET_MANAGED, diff --git a/src/core/nm-policy.c b/src/core/nm-policy.c index 93b52526a..05d4d0064 100644 --- a/src/core/nm-policy.c +++ b/src/core/nm-policy.c @@ -429,7 +429,7 @@ get_best_active_connection(NMPolicy *self, int addr_family, gboolean fully_activ if (state <= NM_DEVICE_STATE_DISCONNECTED || state >= NM_DEVICE_STATE_DEACTIVATING) continue; - if (nm_device_sys_iface_state_is_external(device)) + if (nm_device_managed_type_is_external(device)) continue; r = nm_device_get_best_default_route(device, addr_family); @@ -482,7 +482,7 @@ any_devices_active(NMPolicy *self) state = nm_device_get_state(device); if (state <= NM_DEVICE_STATE_DISCONNECTED || state >= NM_DEVICE_STATE_DEACTIVATING) continue; - if (nm_device_sys_iface_state_is_external(device)) + if (nm_device_managed_type_is_external(device)) continue; return TRUE; } @@ -809,7 +809,7 @@ build_device_hostname_infos(NMPolicy *self) if (!device) continue; - if (nm_device_sys_iface_state_is_external(device)) + if (nm_device_managed_type_is_external(device)) continue; only_from_default = @@ -1307,7 +1307,7 @@ update_ip_dns(NMPolicy *self, int addr_family, NMDevice *changed_device) /* Tell the DNS manager this config is preferred by re-adding it with * a different IP config type. */ - if (device && nm_device_sys_iface_state_is_external(device)) + if (device && nm_device_managed_type_is_external(device)) ip_config_type = NM_DNS_IP_CONFIG_TYPE_REMOVED; else if (vpn || (device && nm_device_is_vpn(device))) ip_config_type = NM_DNS_IP_CONFIG_TYPE_VPN; @@ -1447,7 +1447,7 @@ _auto_activate_device(NMPolicy *self, NMDevice *device) // deactivate the device and activate the new connection instead of just // bailing if the device is already active if (nm_device_get_act_request(device)) { - if (nm_device_sys_iface_state_is_external(device) + if (nm_device_managed_type_is_external(device) && nm_device_get_allow_autoconnect_on_external(device)) { /* this is an external activation, and we allow autoconnecting on * top of that. @@ -1781,7 +1781,7 @@ nm_policy_device_recheck_auto_activate_schedule(NMPolicy *self, NMDevice *device nm_manager_for_each_active_connection (priv->manager, ac, tmp_list) { if (nm_active_connection_get_device(ac) == device) { - if (nm_device_sys_iface_state_is_external(device) + if (nm_device_managed_type_is_external(device) && nm_device_get_allow_autoconnect_on_external(device)) { /* pass */ } else @@ -2300,7 +2300,7 @@ device_state_changed(NMDevice *device, * again when the device becomes ACTIVATED, we need also to update * routing and DNS here. */ nm_dns_manager_begin_updates(priv->dns_manager, __func__); - if (!nm_device_sys_iface_state_is_external(device)) { + if (!nm_device_managed_type_is_external(device)) { nm_dns_manager_set_ip_config(priv->dns_manager, AF_UNSPEC, device,