platform: rename NMPRulesManager API to NMPRouteManager

Routes of type blackhole, unreachable, prohibit don't have an
ifindex/device. They are thus in many ways similar to routing rules,
as they are global. We need a mediator to keep track which routes
to configure.

This will be very similar to what NMPRulesManager already does for
routing rules. Rename the API, so that it also can be used for routes.

Renaming the file will be done next, so that git's rename detection
doesn't get too confused.

6 files changed, 208 insertions, 207 deletions

diff --git a/src/core/devices/nm-device.c b/src/core/devices/nm-device.c
index a22bd82483..a0e69687bf 100644
--- a/src/core/devices/nm-device.c
+++ b/src/core/devices/nm-device.c
@@ -9283,7 +9283,7 @@ static void
 _routing_rules_sync(NMDevice *self, NMTernary set_mode)
 {
     NMDevicePrivate *priv               = NM_DEVICE_GET_PRIVATE(self);
-    NMPRulesManager *rules_manager      = nm_netns_get_rules_manager(nm_device_get_netns(self));
+    NMPRouteManager *route_manager      = nm_netns_get_route_manager(nm_device_get_netns(self));
     NMDeviceClass   *klass              = NM_DEVICE_GET_CLASS(self);
     gboolean         untrack_only_dirty = FALSE;
     gboolean         keep_deleted_rules;
@@ -9301,9 +9301,9 @@ _routing_rules_sync(NMDevice *self, NMTernary set_mode)
         int                is_ipv4;
 
         untrack_only_dirty = TRUE;
-        nmp_rules_manager_set_dirty(rules_manager, user_tag_1);
+        nmp_route_manager_set_dirty(route_manager, user_tag_1);
         if (klass->get_extra_rules)
-            nmp_rules_manager_set_dirty(rules_manager, user_tag_2);
+            nmp_route_manager_set_dirty(route_manager, user_tag_2);
 
         applied_connection = nm_device_get_applied_connection(self);
 
@@ -9323,13 +9323,13 @@ _routing_rules_sync(NMDevice *self, NMTernary set_mode)
                 nm_ip_routing_rule_to_platform(rule, &plrule);
 
                 /* We track this rule, but we also make it explicitly not weakly-tracked
-                 * (meaning to untrack NMP_RULES_MANAGER_EXTERN_WEAKLY_TRACKED_USER_TAG at
+                 * (meaning to untrack NMP_ROUTE_MANAGER_EXTERN_WEAKLY_TRACKED_USER_TAG at
                  * the same time). */
-                nmp_rules_manager_track(rules_manager,
-                                        &plrule,
-                                        10,
-                                        user_tag_1,
-                                        NMP_RULES_MANAGER_EXTERN_WEAKLY_TRACKED_USER_TAG);
+                nmp_route_manager_track_rule(route_manager,
+                                             &plrule,
+                                             10,
+                                             user_tag_1,
+                                             NMP_ROUTE_MANAGER_EXTERN_WEAKLY_TRACKED_USER_TAG);
             }
         }
 
@@ -9339,24 +9339,25 @@ _routing_rules_sync(NMDevice *self, NMTernary set_mode)
             extra_rules = klass->get_extra_rules(self);
             if (extra_rules) {
                 for (i = 0; i < extra_rules->len; i++) {
-                    nmp_rules_manager_track(rules_manager,
-                                            NMP_OBJECT_CAST_ROUTING_RULE(extra_rules->pdata[i]),
-                                            10,
-                                            user_tag_2,
-                                            NMP_RULES_MANAGER_EXTERN_WEAKLY_TRACKED_USER_TAG);
+                    nmp_route_manager_track_rule(
+                        route_manager,
+                        NMP_OBJECT_CAST_ROUTING_RULE(extra_rules->pdata[i]),
+                        10,
+                        user_tag_2,
+                        NMP_ROUTE_MANAGER_EXTERN_WEAKLY_TRACKED_USER_TAG);
                 }
             }
         }
     }
 
-    nmp_rules_manager_untrack_all(rules_manager, user_tag_1, !untrack_only_dirty);
+    nmp_route_manager_untrack_all(route_manager, user_tag_1, !untrack_only_dirty);
     if (klass->get_extra_rules)
-        nmp_rules_manager_untrack_all(rules_manager, user_tag_2, !untrack_only_dirty);
+        nmp_route_manager_untrack_all(route_manager, user_tag_2, !untrack_only_dirty);
 
     keep_deleted_rules = FALSE;
     if (set_mode == NM_TERNARY_DEFAULT) {
         /* when exiting NM, we leave the device up and the rules configured.
-         * We just all nmp_rules_manager_sync() to forget about the synced rules,
+         * We just all nmp_route_manager_sync_rules() to forget about the synced rules,
          * but we don't actually delete them.
          *
          * FIXME: that is a problem after restart of NetworkManager, because these
@@ -9370,7 +9371,7 @@ _routing_rules_sync(NMDevice *self, NMTernary set_mode)
          * file and track them after restart again. */
         keep_deleted_rules = TRUE;
     }
-    nmp_rules_manager_sync(rules_manager, keep_deleted_rules);
+    nmp_route_manager_sync_rules(route_manager, keep_deleted_rules);
 }
 
 static gboolean
diff --git a/src/core/nm-netns.c b/src/core/nm-netns.c
index 4d3c3172ae..1253c8b4a2 100644
--- a/src/core/nm-netns.c
+++ b/src/core/nm-netns.c
@@ -25,7 +25,7 @@ typedef struct {
     NMNetns         *_self_signal_user_data;
     NMPlatform      *platform;
     NMPNetns        *platform_netns;
-    NMPRulesManager *rules_manager;
+    NMPRouteManager *route_manager;
     GHashTable      *l3cfgs;
     GHashTable      *shared_ips;
     CList            l3cfg_signal_pending_lst_head;
@@ -79,10 +79,10 @@ nm_netns_get_platform(NMNetns *self)
     return NM_NETNS_GET_PRIVATE(self)->platform;
 }
 
-NMPRulesManager *
-nm_netns_get_rules_manager(NMNetns *self)
+NMPRouteManager *
+nm_netns_get_route_manager(NMNetns *self)
 {
-    return NM_NETNS_GET_PRIVATE(self)->rules_manager;
+    return NM_NETNS_GET_PRIVATE(self)->route_manager;
 }
 
 NMDedupMultiIndex *
@@ -397,14 +397,14 @@ constructed(GObject *object)
 
     priv->platform_netns = nm_platform_netns_get(priv->platform);
 
-    priv->rules_manager = nmp_rules_manager_new(priv->platform);
+    priv->route_manager = nmp_route_manager_new(priv->platform);
 
     /* Weakly track the default rules with a dummy user-tag. These
      * rules are always weekly tracked... */
-    nmp_rules_manager_track_default(priv->rules_manager,
-                                    AF_UNSPEC,
-                                    0,
-                                    nm_netns_parent_class /* static dummy user-tag */);
+    nmp_route_manager_track_rule_default(priv->route_manager,
+                                         AF_UNSPEC,
+                                         0,
+                                         nm_netns_parent_class /* static dummy user-tag */);
 
     /* Also weakly track all existing rules. These were added before NetworkManager
      * starts, so they are probably none of NetworkManager's business.
@@ -414,12 +414,12 @@ constructed(GObject *object)
      * of NetworkManager, we just don't know.
      *
      * For that reason, whenever we will touch such rules later one, we make them
-     * fully owned and no longer weekly tracked. See %NMP_RULES_MANAGER_EXTERN_WEAKLY_TRACKED_USER_TAG. */
-    nmp_rules_manager_track_from_platform(priv->rules_manager,
-                                          NULL,
-                                          AF_UNSPEC,
-                                          0,
-                                          NMP_RULES_MANAGER_EXTERN_WEAKLY_TRACKED_USER_TAG);
+     * fully owned and no longer weekly tracked. See %NMP_ROUTE_MANAGER_EXTERN_WEAKLY_TRACKED_USER_TAG. */
+    nmp_route_manager_track_rule_from_platform(priv->route_manager,
+                                               NULL,
+                                               AF_UNSPEC,
+                                               0,
+                                               NMP_ROUTE_MANAGER_EXTERN_WEAKLY_TRACKED_USER_TAG);
 
     G_OBJECT_CLASS(nm_netns_parent_class)->constructed(object);
 
@@ -469,7 +469,7 @@ dispose(GObject *object)
     g_clear_object(&priv->platform);
     nm_clear_pointer(&priv->l3cfgs, g_hash_table_unref);
 
-    nm_clear_pointer(&priv->rules_manager, nmp_rules_manager_unref);
+    nm_clear_pointer(&priv->route_manager, nmp_route_manager_unref);
 
     G_OBJECT_CLASS(nm_netns_parent_class)->dispose(object);
 }
diff --git a/src/core/nm-netns.h b/src/core/nm-netns.h
index 0cb5637544..deb1d1f006 100644
--- a/src/core/nm-netns.h
+++ b/src/core/nm-netns.h
@@ -29,7 +29,7 @@ NMNetns *nm_netns_new(struct _NMPlatform *platform);
 struct _NMPlatform *nm_netns_get_platform(NMNetns *self);
 NMPNetns           *nm_netns_get_platform_netns(NMNetns *self);
 
-struct _NMPRulesManager *nm_netns_get_rules_manager(NMNetns *self);
+struct _NMPRouteManager *nm_netns_get_route_manager(NMNetns *self);
 
 struct _NMDedupMultiIndex *nm_netns_get_multi_idx(NMNetns *self);
 
diff --git a/src/core/platform/tests/test-route.c b/src/core/platform/tests/test-route.c
index 4974a409cb..969ed7f2f5 100644
--- a/src/core/platform/tests/test-route.c
+++ b/src/core/platform/tests/test-route.c
@@ -1637,8 +1637,8 @@ again:
 
     if (TEST_SYNC) {
         gs_unref_hashtable GHashTable *unique_priorities = g_hash_table_new(NULL, NULL);
-        nm_auto_unref_rules_manager NMPRulesManager *rules_manager =
-            nmp_rules_manager_new(platform);
+        nm_auto_unref_route_manager NMPRouteManager *route_manager =
+            nmp_route_manager_new(platform);
         gs_unref_ptrarray GPtrArray *objs_sync  = NULL;
         gconstpointer                USER_TAG_1 = &platform;
         gconstpointer                USER_TAG_2 = &unique_priorities;
@@ -1660,29 +1660,29 @@ again:
         }
 
         for (i = 0; i < objs_sync->len; i++) {
-            nmp_rules_manager_track(rules_manager,
-                                    NMP_OBJECT_CAST_ROUTING_RULE(objs_sync->pdata[i]),
-                                    1,
-                                    USER_TAG_1,
-                                    NULL);
+            nmp_route_manager_track_rule(route_manager,
+                                         NMP_OBJECT_CAST_ROUTING_RULE(objs_sync->pdata[i]),
+                                         1,
+                                         USER_TAG_1,
+                                         NULL);
             if (nmtst_get_rand_bool()) {
                 /* this has no effect, because a negative priority (of same absolute value)
                  * has lower priority than the positive priority above. */
-                nmp_rules_manager_track(rules_manager,
-                                        NMP_OBJECT_CAST_ROUTING_RULE(objs_sync->pdata[i]),
-                                        -1,
-                                        USER_TAG_2,
-                                        NULL);
+                nmp_route_manager_track_rule(route_manager,
+                                             NMP_OBJECT_CAST_ROUTING_RULE(objs_sync->pdata[i]),
+                                             -1,
+                                             USER_TAG_2,
+                                             NULL);
             }
             if (nmtst_get_rand_uint32() % objs_sync->len == 0) {
-                nmp_rules_manager_sync(rules_manager, FALSE);
+                nmp_route_manager_sync_rules(route_manager, FALSE);
                 g_assert_cmpint(nmtstp_platform_routing_rules_get_count(platform, AF_UNSPEC),
                                 ==,
                                 i + 1);
             }
         }
 
-        nmp_rules_manager_sync(rules_manager, FALSE);
+        nmp_route_manager_sync_rules(route_manager, FALSE);
         g_assert_cmpint(nmtstp_platform_routing_rules_get_count(platform, AF_UNSPEC),
                         ==,
                         objs_sync->len);
@@ -1690,37 +1690,37 @@ again:
         for (i = 0; i < objs_sync->len; i++) {
             switch (nmtst_get_rand_uint32() % 3) {
             case 0:
-                nmp_rules_manager_untrack(rules_manager,
-                                          NMP_OBJECT_CAST_ROUTING_RULE(objs_sync->pdata[i]),
-                                          USER_TAG_1);
-                nmp_rules_manager_untrack(rules_manager,
-                                          NMP_OBJECT_CAST_ROUTING_RULE(objs_sync->pdata[i]),
-                                          USER_TAG_1);
+                nmp_route_manager_untrack_rule(route_manager,
+                                               NMP_OBJECT_CAST_ROUTING_RULE(objs_sync->pdata[i]),
+                                               USER_TAG_1);
+                nmp_route_manager_untrack_rule(route_manager,
+                                               NMP_OBJECT_CAST_ROUTING_RULE(objs_sync->pdata[i]),
+                                               USER_TAG_1);
                 break;
             case 1:
-                nmp_rules_manager_track(rules_manager,
-                                        NMP_OBJECT_CAST_ROUTING_RULE(objs_sync->pdata[i]),
-                                        -1,
-                                        USER_TAG_1,
-                                        NULL);
+                nmp_route_manager_track_rule(route_manager,
+                                             NMP_OBJECT_CAST_ROUTING_RULE(objs_sync->pdata[i]),
+                                             -1,
+                                             USER_TAG_1,
+                                             NULL);
                 break;
             case 2:
-                nmp_rules_manager_track(rules_manager,
-                                        NMP_OBJECT_CAST_ROUTING_RULE(objs_sync->pdata[i]),
-                                        -2,
-                                        USER_TAG_2,
-                                        NULL);
+                nmp_route_manager_track_rule(route_manager,
+                                             NMP_OBJECT_CAST_ROUTING_RULE(objs_sync->pdata[i]),
+                                             -2,
+                                             USER_TAG_2,
+                                             NULL);
                 break;
             }
             if (nmtst_get_rand_uint32() % objs_sync->len == 0) {
-                nmp_rules_manager_sync(rules_manager, FALSE);
+                nmp_route_manager_sync_rules(route_manager, FALSE);
                 g_assert_cmpint(nmtstp_platform_routing_rules_get_count(platform, AF_UNSPEC),
                                 ==,
                                 objs_sync->len - i - 1);
             }
         }
 
-        nmp_rules_manager_sync(rules_manager, FALSE);
+        nmp_route_manager_sync_rules(route_manager, FALSE);
 
     } else {
         for (i = 0; i < objs->len;) {
diff --git a/src/libnm-platform/nmp-rules-manager.c b/src/libnm-platform/nmp-rules-manager.c
index 746d1eaa74..bd63d462d8 100644
--- a/src/libnm-platform/nmp-rules-manager.c
+++ b/src/libnm-platform/nmp-rules-manager.c
@@ -13,7 +13,7 @@
 
 /*****************************************************************************/
 
-struct _NMPRulesManager {
+struct _NMPRouteManager {
     NMPlatform *platform;
     GHashTable *by_obj;
     GHashTable *by_user_tag;
@@ -23,12 +23,12 @@ struct _NMPRulesManager {
 
 /*****************************************************************************/
 
-static void _rules_init(NMPRulesManager *self);
+static void _rules_init(NMPRouteManager *self);
 
 /*****************************************************************************/
 
 #define _NMLOG_DOMAIN      LOGD_PLATFORM
-#define _NMLOG_PREFIX_NAME "rules-manager"
+#define _NMLOG_PREFIX_NAME "route-manager"
 
 #define _NMLOG(level, ...)                                                 \
     G_STMT_START                                                           \
@@ -50,10 +50,10 @@ static void _rules_init(NMPRulesManager *self);
 /*****************************************************************************/
 
 static gboolean
-NMP_IS_RULES_MANAGER(gpointer self)
+NMP_IS_ROUTE_MANAGER(gpointer self)
 {
-    return self && ((NMPRulesManager *) self)->ref_count > 0
-           && NM_IS_PLATFORM(((NMPRulesManager *) self)->platform);
+    return self && ((NMPRouteManager *) self)->ref_count > 0
+           && NM_IS_PLATFORM(((NMPRouteManager *) self)->platform);
 }
 
 #define _USER_TAG_LOG(user_tag) nm_hash_obfuscate_ptr(1240261787u, (user_tag))
@@ -109,13 +109,13 @@ typedef struct {
     /* indicates whether we configured/removed the rule (during sync()). We need that, so
      * if the rule gets untracked, that we know to remove/restore it.
      *
-     * This makes NMPRulesManager stateful (beyond the configuration that indicates
+     * This makes NMPRouteManager stateful (beyond the configuration that indicates
      * which rules are tracked).
      * After a restart, NetworkManager would no longer remember which rules were added
      * by us.
      *
      * That is partially fixed by NetworkManager taking over the rules that it
-     * actively configures (see %NMP_RULES_MANAGER_EXTERN_WEAKLY_TRACKED_USER_TAG). */
+     * actively configures (see %NMP_ROUTE_MANAGER_EXTERN_WEAKLY_TRACKED_USER_TAG). */
     ConfigState config_state;
 } RulesObjData;
 
@@ -126,7 +126,7 @@ typedef struct {
 
 /*****************************************************************************/
 
-static void _rules_data_untrack(NMPRulesManager *self,
+static void _rules_data_untrack(NMPRouteManager *self,
                                 RulesData       *rules_data,
                                 gboolean         remove_user_tag_data,
                                 gboolean         make_owned_by_us);
@@ -289,8 +289,8 @@ _rules_data_lookup(GHashTable *by_data, const NMPObject *obj, gconstpointer user
 }
 
 /**
- * nmp_rules_manager_track:
- * @self: the #NMPRulesManager instance
+ * nmp_route_manager_track_rule:
+ * @self: the #NMPRouteManager instance
  * @routing_rule: the #NMPlatformRoutingRule to track or untrack
  * @track_priority: the priority for tracking the rule. Note that
  *   negative values indicate a forced absence of the rule. Priorities
@@ -302,17 +302,17 @@ _rules_data_lookup(GHashTable *by_data, const NMPObject *obj, gconstpointer user
  * @user_tag: the tag associated with tracking this rule. The same tag
  *   must be used to untrack the rule later.
  * @user_tag_untrack: if not %NULL, at the same time untrack this user-tag
- *   for the same rule. Note that this is different from a plain nmp_rules_manager_untrack(),
+ *   for the same rule. Note that this is different from a plain nmp_route_manager_untrack_rule(),
  *   because it enforces ownership of the now tracked rule. On the other hand,
- *   a plain nmp_rules_manager_untrack() merely forgets about the tracking.
- *   The purpose here is to set this to %NMP_RULES_MANAGER_EXTERN_WEAKLY_TRACKED_USER_TAG.
+ *   a plain nmp_route_manager_untrack_rule() merely forgets about the tracking.
+ *   The purpose here is to set this to %NMP_ROUTE_MANAGER_EXTERN_WEAKLY_TRACKED_USER_TAG.
  */
 void
-nmp_rules_manager_track(NMPRulesManager             *self,
-                        const NMPlatformRoutingRule *routing_rule,
-                        gint32                       track_priority,
-                        gconstpointer                user_tag,
-                        gconstpointer                user_tag_untrack)
+nmp_route_manager_track_rule(NMPRouteManager             *self,
+                             const NMPlatformRoutingRule *routing_rule,
+                             gint32                       track_priority,
+                             gconstpointer                user_tag,
+                             gconstpointer                user_tag_untrack)
 {
     NMPObject         obj_stack;
     const NMPObject  *p_obj_stack;
@@ -323,7 +323,7 @@ nmp_rules_manager_track(NMPRulesManager             *self,
     guint32           track_priority_val;
     gboolean          track_priority_present;
 
-    g_return_if_fail(NMP_IS_RULES_MANAGER(self));
+    g_return_if_fail(NMP_IS_ROUTE_MANAGER(self));
     g_return_if_fail(routing_rule);
     g_return_if_fail(user_tag);
     nm_assert(track_priority != G_MININT32);
@@ -414,14 +414,14 @@ nmp_rules_manager_track(NMPRulesManager             *self,
 }
 
 static void
-_rules_data_untrack(NMPRulesManager *self,
+_rules_data_untrack(NMPRouteManager *self,
                     RulesData       *rules_data,
                     gboolean         remove_user_tag_data,
                     gboolean         make_owned_by_us)
 {
     RulesObjData *obj_data;
 
-    nm_assert(NMP_IS_RULES_MANAGER(self));
+    nm_assert(NMP_IS_ROUTE_MANAGER(self));
     _rules_data_assert(rules_data, TRUE);
     nm_assert(self->by_data);
     nm_assert(g_hash_table_lookup(self->by_data, rules_data) == rules_data);
@@ -465,15 +465,15 @@ _rules_data_untrack(NMPRulesManager *self,
 }
 
 void
-nmp_rules_manager_untrack(NMPRulesManager             *self,
-                          const NMPlatformRoutingRule *routing_rule,
-                          gconstpointer                user_tag)
+nmp_route_manager_untrack_rule(NMPRouteManager             *self,
+                               const NMPlatformRoutingRule *routing_rule,
+                               gconstpointer                user_tag)
 {
     NMPObject        obj_stack;
     const NMPObject *p_obj_stack;
     RulesData       *rules_data;
 
-    g_return_if_fail(NMP_IS_RULES_MANAGER(self));
+    g_return_if_fail(NMP_IS_ROUTE_MANAGER(self));
     g_return_if_fail(routing_rule);
     g_return_if_fail(user_tag);
 
@@ -489,12 +489,12 @@ nmp_rules_manager_untrack(NMPRulesManager             *self,
 }
 
 void
-nmp_rules_manager_set_dirty(NMPRulesManager *self, gconstpointer user_tag)
+nmp_route_manager_set_dirty(NMPRouteManager *self, gconstpointer user_tag)
 {
     RulesData        *rules_data;
     RulesUserTagData *user_tag_data;
 
-    g_return_if_fail(NMP_IS_RULES_MANAGER(self));
+    g_return_if_fail(NMP_IS_ROUTE_MANAGER(self));
     g_return_if_fail(user_tag);
 
     if (!self->by_data)
@@ -509,7 +509,7 @@ nmp_rules_manager_set_dirty(NMPRulesManager *self, gconstpointer user_tag)
 }
 
 void
-nmp_rules_manager_untrack_all(NMPRulesManager *self,
+nmp_route_manager_untrack_all(NMPRouteManager *self,
                               gconstpointer    user_tag,
                               gboolean         all /* or only dirty */)
 {
@@ -517,7 +517,7 @@ nmp_rules_manager_untrack_all(NMPRulesManager *self,
     RulesData        *rules_data_safe;
     RulesUserTagData *user_tag_data;
 
-    g_return_if_fail(NMP_IS_RULES_MANAGER(self));
+    g_return_if_fail(NMP_IS_ROUTE_MANAGER(self));
     g_return_if_fail(user_tag);
 
     if (!self->by_data)
@@ -539,7 +539,7 @@ nmp_rules_manager_untrack_all(NMPRulesManager *self,
 }
 
 void
-nmp_rules_manager_sync(NMPRulesManager *self, gboolean keep_deleted_rules)
+nmp_route_manager_sync_rules(NMPRouteManager *self, gboolean keep_deleted_rules)
 {
     const NMDedupMultiHeadEntry *pl_head_entry;
     NMDedupMultiIter             pl_iter;
@@ -550,7 +550,7 @@ nmp_rules_manager_sync(NMPRulesManager *self, gboolean keep_deleted_rules)
     guint                        i;
     const RulesData             *rd_best;
 
-    g_return_if_fail(NMP_IS_RULES_MANAGER(self));
+    g_return_if_fail(NMP_IS_ROUTE_MANAGER(self));
 
     if (!self->by_data)
         return;
@@ -643,18 +643,18 @@ nmp_rules_manager_sync(NMPRulesManager *self, gboolean keep_deleted_rules)
 }
 
 void
-nmp_rules_manager_track_from_platform(NMPRulesManager *self,
-                                      NMPlatform      *platform,
-                                      int              addr_family,
-                                      gint32           tracking_priority,
-                                      gconstpointer    user_tag)
+nmp_route_manager_track_rule_from_platform(NMPRouteManager *self,
+                                           NMPlatform      *platform,
+                                           int              addr_family,
+                                           gint32           tracking_priority,
+                                           gconstpointer    user_tag)
 {
     NMPLookup                    lookup;
     const NMDedupMultiHeadEntry *head_entry;
     NMDedupMultiIter             iter;
     const NMPObject             *o;
 
-    g_return_if_fail(NMP_IS_RULES_MANAGER(self));
+    g_return_if_fail(NMP_IS_ROUTE_MANAGER(self));
 
     if (!platform)
         platform = self->platform;
@@ -671,87 +671,87 @@ nmp_rules_manager_track_from_platform(NMPRulesManager *self,
         if (addr_family != AF_UNSPEC && rr->addr_family != addr_family)
             continue;
 
-        nmp_rules_manager_track(self, rr, tracking_priority, user_tag, NULL);
+        nmp_route_manager_track_rule(self, rr, tracking_priority, user_tag, NULL);
     }
 }
 
 /*****************************************************************************/
 
 void
-nmp_rules_manager_track_default(NMPRulesManager *self,
-                                int              addr_family,
-                                gint32           track_priority,
-                                gconstpointer    user_tag)
+nmp_route_manager_track_rule_default(NMPRouteManager *self,
+                                     int              addr_family,
+                                     gint32           track_priority,
+                                     gconstpointer    user_tag)
 {
-    g_return_if_fail(NMP_IS_RULES_MANAGER(self));
+    g_return_if_fail(NMP_IS_ROUTE_MANAGER(self));
 
     nm_assert(NM_IN_SET(addr_family, AF_UNSPEC, AF_INET, AF_INET6));
 
     /* track the default rules. See also `man ip-rule`. */
 
     if (NM_IN_SET(addr_family, AF_UNSPEC, AF_INET)) {
-        nmp_rules_manager_track(self,
-                                &((NMPlatformRoutingRule){
-                                    .addr_family = AF_INET,
-                                    .priority    = 0,
-                                    .table       = RT_TABLE_LOCAL,
-                                    .action      = FR_ACT_TO_TBL,
-                                    .protocol    = RTPROT_KERNEL,
-                                }),
-                                track_priority,
-                                user_tag,
-                                NULL);
-        nmp_rules_manager_track(self,
-                                &((NMPlatformRoutingRule){
-                                    .addr_family = AF_INET,
-                                    .priority    = 32766,
-                                    .table       = RT_TABLE_MAIN,
-                                    .action      = FR_ACT_TO_TBL,
-                                    .protocol    = RTPROT_KERNEL,
-                                }),
-                                track_priority,
-                                user_tag,
-                                NULL);
-        nmp_rules_manager_track(self,
-                                &((NMPlatformRoutingRule){
-                                    .addr_family = AF_INET,
-                                    .priority    = 32767,
-                                    .table       = RT_TABLE_DEFAULT,
-                                    .action      = FR_ACT_TO_TBL,
-                                    .protocol    = RTPROT_KERNEL,
-                                }),
-                                track_priority,
-                                user_tag,
-                                NULL);
+        nmp_route_manager_track_rule(self,
+                                     &((NMPlatformRoutingRule){
+                                         .addr_family = AF_INET,
+                                         .priority    = 0,
+                                         .table       = RT_TABLE_LOCAL,
+                                         .action      = FR_ACT_TO_TBL,
+                                         .protocol    = RTPROT_KERNEL,
+                                     }),
+                                     track_priority,
+                                     user_tag,
+                                     NULL);
+        nmp_route_manager_track_rule(self,
+                                     &((NMPlatformRoutingRule){
+                                         .addr_family = AF_INET,
+                                         .priority    = 32766,
+                                         .table       = RT_TABLE_MAIN,
+                                         .action      = FR_ACT_TO_TBL,
+                                         .protocol    = RTPROT_KERNEL,
+                                     }),
+                                     track_priority,
+                                     user_tag,
+                                     NULL);
+        nmp_route_manager_track_rule(self,
+                                     &((NMPlatformRoutingRule){
+                                         .addr_family = AF_INET,
+                                         .priority    = 32767,
+                                         .table       = RT_TABLE_DEFAULT,
+                                         .action      = FR_ACT_TO_TBL,
+                                         .protocol    = RTPROT_KERNEL,
+                                     }),
+                                     track_priority,
+                                     user_tag,
+                                     NULL);
     }
     if (NM_IN_SET(addr_family, AF_UNSPEC, AF_INET6)) {
-        nmp_rules_manager_track(self,
-                                &((NMPlatformRoutingRule){
-                                    .addr_family = AF_INET6,
-                                    .priority    = 0,
-                                    .table       = RT_TABLE_LOCAL,
-                                    .action      = FR_ACT_TO_TBL,
-                                    .protocol    = RTPROT_KERNEL,
-                                }),
-                                track_priority,
-                                user_tag,
-                                NULL);
-        nmp_rules_manager_track(self,
-                                &((NMPlatformRoutingRule){
-                                    .addr_family = AF_INET6,
-                                    .priority    = 32766,
-                                    .table       = RT_TABLE_MAIN,
-                                    .action      = FR_ACT_TO_TBL,
-                                    .protocol    = RTPROT_KERNEL,
-                                }),
-                                track_priority,
-                                user_tag,
-                                NULL);
+        nmp_route_manager_track_rule(self,
+                                     &((NMPlatformRoutingRule){
+                                         .addr_family = AF_INET6,
+                                         .priority    = 0,
+                                         .table       = RT_TABLE_LOCAL,
+                                         .action      = FR_ACT_TO_TBL,
+                                         .protocol    = RTPROT_KERNEL,
+                                     }),
+                                     track_priority,
+                                     user_tag,
+                                     NULL);
+        nmp_route_manager_track_rule(self,
+                                     &((NMPlatformRoutingRule){
+                                         .addr_family = AF_INET6,
+                                         .priority    = 32766,
+                                         .table       = RT_TABLE_MAIN,
+                                         .action      = FR_ACT_TO_TBL,
+                                         .protocol    = RTPROT_KERNEL,
+                                     }),
+                                     track_priority,
+                                     user_tag,
+                                     NULL);
     }
 }
 
 static void
-_rules_init(NMPRulesManager *self)
+_rules_init(NMPRouteManager *self)
 {
     if (self->by_data)
         return;
@@ -768,15 +768,15 @@ _rules_init(NMPRulesManager *self)
 
 /*****************************************************************************/
 
-NMPRulesManager *
-nmp_rules_manager_new(NMPlatform *platform)
+NMPRouteManager *
+nmp_route_manager_new(NMPlatform *platform)
 {
-    NMPRulesManager *self;
+    NMPRouteManager *self;
 
     g_return_val_if_fail(NM_IS_PLATFORM(platform), NULL);
 
-    self  = g_slice_new(NMPRulesManager);
-    *self = (NMPRulesManager){
+    self  = g_slice_new(NMPRouteManager);
+    *self = (NMPRouteManager){
         .ref_count = 1,
         .platform  = g_object_ref(platform),
     };
@@ -784,17 +784,17 @@ nmp_rules_manager_new(NMPlatform *platform)
 }
 
 void
-nmp_rules_manager_ref(NMPRulesManager *self)
+nmp_route_manager_ref(NMPRouteManager *self)
 {
-    g_return_if_fail(NMP_IS_RULES_MANAGER(self));
+    g_return_if_fail(NMP_IS_ROUTE_MANAGER(self));
 
     self->ref_count++;
 }
 
 void
-nmp_rules_manager_unref(NMPRulesManager *self)
+nmp_route_manager_unref(NMPRouteManager *self)
 {
-    g_return_if_fail(NMP_IS_RULES_MANAGER(self));
+    g_return_if_fail(NMP_IS_ROUTE_MANAGER(self));
 
     if (--self->ref_count > 0)
         return;
@@ -805,5 +805,5 @@ nmp_rules_manager_unref(NMPRulesManager *self)
         g_hash_table_destroy(self->by_data);
     }
     g_object_unref(self->platform);
-    g_slice_free(NMPRulesManager, self);
+    g_slice_free(NMPRouteManager, self);
 }
diff --git a/src/libnm-platform/nmp-rules-manager.h b/src/libnm-platform/nmp-rules-manager.h
index 65e8ddb236..3bc4a49301 100644
--- a/src/libnm-platform/nmp-rules-manager.h
+++ b/src/libnm-platform/nmp-rules-manager.h
@@ -1,53 +1,53 @@
 /* SPDX-License-Identifier: LGPL-2.1-or-later */
 
-#ifndef __NMP_RULES_MANAGER_H__
-#define __NMP_RULES_MANAGER_H__
+#ifndef __NMP_ROUTE_MANAGER_H__
+#define __NMP_ROUTE_MANAGER_H__
 
 #include "nm-platform.h"
 
 /*****************************************************************************/
 
-#define NMP_RULES_MANAGER_EXTERN_WEAKLY_TRACKED_USER_TAG ((const void *) nmp_rules_manager_new)
+#define NMP_ROUTE_MANAGER_EXTERN_WEAKLY_TRACKED_USER_TAG ((const void *) nmp_route_manager_new)
 
-typedef struct _NMPRulesManager NMPRulesManager;
+typedef struct _NMPRouteManager NMPRouteManager;
 
-NMPRulesManager *nmp_rules_manager_new(NMPlatform *platform);
+NMPRouteManager *nmp_route_manager_new(NMPlatform *platform);
 
-void nmp_rules_manager_ref(NMPRulesManager *self);
-void nmp_rules_manager_unref(NMPRulesManager *self);
+void nmp_route_manager_ref(NMPRouteManager *self);
+void nmp_route_manager_unref(NMPRouteManager *self);
 
-#define nm_auto_unref_rules_manager nm_auto(_nmp_rules_manager_unref)
-NM_AUTO_DEFINE_FCN0(NMPRulesManager *, _nmp_rules_manager_unref, nmp_rules_manager_unref);
+#define nm_auto_unref_route_manager nm_auto(_nmp_route_manager_unref)
+NM_AUTO_DEFINE_FCN0(NMPRouteManager *, _nmp_route_manager_unref, nmp_route_manager_unref);
 
-void nmp_rules_manager_track(NMPRulesManager             *self,
-                             const NMPlatformRoutingRule *routing_rule,
-                             gint32                       track_priority,
-                             gconstpointer                user_tag,
-                             gconstpointer                user_tag_untrack);
+void nmp_route_manager_track_rule(NMPRouteManager             *self,
+                                  const NMPlatformRoutingRule *routing_rule,
+                                  gint32                       track_priority,
+                                  gconstpointer                user_tag,
+                                  gconstpointer                user_tag_untrack);
 
-void nmp_rules_manager_track_default(NMPRulesManager *self,
-                                     int              addr_family,
-                                     gint32           track_priority,
-                                     gconstpointer    user_tag);
+void nmp_route_manager_track_rule_default(NMPRouteManager *self,
+                                          int              addr_family,
+                                          gint32           track_priority,
+                                          gconstpointer    user_tag);
 
-void nmp_rules_manager_track_from_platform(NMPRulesManager *self,
-                                           NMPlatform      *platform,
-                                           int              addr_family,
-                                           gint32           tracking_priority,
-                                           gconstpointer    user_tag);
+void nmp_route_manager_track_rule_from_platform(NMPRouteManager *self,
+                                                NMPlatform      *platform,
+                                                int              addr_family,
+                                                gint32           tracking_priority,
+                                                gconstpointer    user_tag);
 
-void nmp_rules_manager_untrack(NMPRulesManager             *self,
-                               const NMPlatformRoutingRule *routing_rule,
-                               gconstpointer                user_tag);
+void nmp_route_manager_untrack_rule(NMPRouteManager             *self,
+                                    const NMPlatformRoutingRule *routing_rule,
+                                    gconstpointer                user_tag);
 
-void nmp_rules_manager_set_dirty(NMPRulesManager *self, gconstpointer user_tag);
+void nmp_route_manager_set_dirty(NMPRouteManager *self, gconstpointer user_tag);
 
-void nmp_rules_manager_untrack_all(NMPRulesManager *self,
+void nmp_route_manager_untrack_all(NMPRouteManager *self,
                                    gconstpointer    user_tag,
                                    gboolean         all /* or only dirty */);
 
-void nmp_rules_manager_sync(NMPRulesManager *self, gboolean keep_deleted_rules);
+void nmp_route_manager_sync_rules(NMPRouteManager *self, gboolean keep_deleted_rules);
 
 /*****************************************************************************/
 
-#endif /* __NMP_RULES_MANAGER_H__ */
+#endif /* __NMP_ROUTE_MANAGER_H__ */