all: rename nm_utils_strsplit_set*() to nm_strsplit_set*()

25 files changed, 260 insertions, 298 deletions

diff --git a/src/core/devices/nm-device-bond.c b/src/core/devices/nm-device-bond.c
index 34839960cc..4cd29e1478 100644
--- a/src/core/devices/nm-device-bond.c
+++ b/src/core/devices/nm-device-bond.c
@@ -250,9 +250,8 @@ set_arp_targets(NMDevice *device, const char *cur_arp_ip_target, const char *new
     gsize                        i;
     gsize                        j;
 
-    cur_strv = nm_utils_strsplit_set_full(cur_arp_ip_target,
-                                          NM_ASCII_SPACES,
-                                          NM_UTILS_STRSPLIT_SET_FLAGS_STRSTRIP);
+    cur_strv =
+        nm_strsplit_set_full(cur_arp_ip_target, NM_ASCII_SPACES, NM_STRSPLIT_SET_FLAGS_STRSTRIP);
     new_strv = nm_utils_bond_option_arp_ip_targets_split(new_arp_ip_target);
 
     cur_len = NM_PTRARRAY_LEN(cur_strv);
diff --git a/src/core/dhcp/nm-dhcp-dhclient-utils.c b/src/core/dhcp/nm-dhcp-dhclient-utils.c
index 4284a852a5..3ea481c385 100644
--- a/src/core/dhcp/nm-dhcp-dhclient-utils.c
+++ b/src/core/dhcp/nm-dhcp-dhclient-utils.c
@@ -59,7 +59,7 @@ grab_request_options(GPtrArray *store, const char *line)
     gsize                i;
 
     /* Grab each 'request' or 'also request'  option and save for later */
-    line_v = nm_utils_strsplit_set(line, "\t ,");
+    line_v = nm_strsplit_set(line, "\t ,");
     for (i = 0; line_v && line_v[i]; i++) {
         const char *ss = nm_str_skip_leading_spaces(line_v[i]);
         gsize       l;
@@ -330,7 +330,7 @@ nm_dhcp_dhclient_create_config(const char *        interface,
         g_string_append_printf(new_contents, _("# Merged from %s\n\n"), orig_path);
         intf[0] = '\0';
 
-        lines = nm_utils_strsplit_set(orig_contents, "\n\r");
+        lines = nm_strsplit_set(orig_contents, "\n\r");
         for (line_i = 0; lines && lines[line_i]; line_i++) {
             const char *line = nm_str_skip_leading_spaces(lines[line_i]);
             const char *p;
@@ -620,7 +620,7 @@ nm_dhcp_dhclient_read_duid(const char *leasefile, GError **error)
     if (!g_file_get_contents(leasefile, &contents, NULL, error))
         return NULL;
 
-    contents_v = nm_utils_strsplit_set(contents, "\n\r");
+    contents_v = nm_strsplit_set(contents, "\n\r");
     for (i = 0; contents_v && contents_v[i]; i++) {
         const char *p = nm_str_skip_leading_spaces(contents_v[i]);
         GBytes *    duid;
@@ -671,7 +671,7 @@ nm_dhcp_dhclient_save_duid(const char *leasefile, GBytes *duid, GError **error)
             return FALSE;
         }
 
-        lines = nm_utils_strsplit_set_with_empty(contents, "\n\r");
+        lines = nm_strsplit_set_with_empty(contents, "\n\r");
     }
 
     s = g_string_sized_new(len + 50);
diff --git a/src/core/dhcp/nm-dhcp-nettools.c b/src/core/dhcp/nm-dhcp-nettools.c
index 72f677ed55..6e8c69c71f 100644
--- a/src/core/dhcp/nm-dhcp-nettools.c
+++ b/src/core/dhcp/nm-dhcp-nettools.c
@@ -601,7 +601,7 @@ lease_to_ip4_config(NMDedupMultiIndex *multi_idx,
         nm_str_buf_append_len0(&sbuf, (const char *) l_data, l_data_len);
 
         /* Multiple domains sometimes stuffed into option 15 "Domain Name". */
-        domains = nm_utils_strsplit_set(nm_str_buf_get_str(&sbuf), " ");
+        domains = nm_strsplit_set(nm_str_buf_get_str(&sbuf), " ");
 
         nm_str_buf_reset(&sbuf);
         if (domains) {
diff --git a/src/core/dhcp/nm-dhcp-utils.c b/src/core/dhcp/nm-dhcp-utils.c
index 7fd18b0a72..3cc6987ada 100644
--- a/src/core/dhcp/nm-dhcp-utils.c
+++ b/src/core/dhcp/nm-dhcp-utils.c
@@ -35,7 +35,7 @@ ip4_process_dhcpcd_rfc3442_routes(const char * iface,
     const char **        r;
     gboolean             have_routes = FALSE;
 
-    routes = nm_utils_strsplit_set(str, " ");
+    routes = nm_strsplit_set(str, " ");
     if (!routes)
         return FALSE;
 
@@ -164,7 +164,7 @@ ip4_process_dhclient_rfc3442_routes(const char * iface,
     const char *const *  o;
     gboolean             have_routes = FALSE;
 
-    octets = nm_utils_strsplit_set_with_empty(str, " .");
+    octets = nm_strsplit_set_with_empty(str, " .");
     if (NM_PTRARRAY_LEN(octets) < 5) {
         _LOG2W(LOGD_DHCP4, iface, "ignoring invalid classless static routes '%s'", str);
         return FALSE;
@@ -296,7 +296,7 @@ process_classful_routes(const char * iface,
     if (!str)
         return;
 
-    searches = nm_utils_strsplit_set(str, " ");
+    searches = nm_strsplit_set(str, " ");
     if (!searches)
         return;
 
@@ -376,7 +376,7 @@ process_domain_search(const char *iface, const char *str, GFunc add_func, gpoint
         return;
     }
 
-    searches = nm_utils_strsplit_set(unescaped, " ");
+    searches = nm_strsplit_set(unescaped, " ");
     for (s = searches; searches && *s; s++) {
         _LOG2I(LOGD_DHCP, iface, "  domain search '%s'", *s);
         add_func((gpointer) *s, user_data);
@@ -450,7 +450,7 @@ nm_dhcp_utils_ip4_config_from_options(NMDedupMultiIndex *multi_idx,
          */
         str = g_hash_table_lookup(options, "routers");
         if (str) {
-            gs_free const char **routers = nm_utils_strsplit_set(str, " ");
+            gs_free const char **routers = nm_strsplit_set(str, " ");
             const char **        s;
 
             for (s = routers; routers && *s; s++) {
@@ -491,7 +491,7 @@ nm_dhcp_utils_ip4_config_from_options(NMDedupMultiIndex *multi_idx,
 
     str = g_hash_table_lookup(options, "domain_name_servers");
     if (str) {
-        gs_free const char **dns = nm_utils_strsplit_set(str, " ");
+        gs_free const char **dns = nm_strsplit_set(str, " ");
         const char **        s;
 
         for (s = dns; dns && *s; s++) {
@@ -507,7 +507,7 @@ nm_dhcp_utils_ip4_config_from_options(NMDedupMultiIndex *multi_idx,
 
     str = g_hash_table_lookup(options, "domain_name");
     if (str) {
-        gs_free const char **domains = nm_utils_strsplit_set(str, " ");
+        gs_free const char **domains = nm_strsplit_set(str, " ");
         const char **        s;
 
         for (s = domains; domains && *s; s++) {
@@ -522,7 +522,7 @@ nm_dhcp_utils_ip4_config_from_options(NMDedupMultiIndex *multi_idx,
 
     str = g_hash_table_lookup(options, "netbios_name_servers");
     if (str) {
-        gs_free const char **nbns = nm_utils_strsplit_set(str, " ");
+        gs_free const char **nbns = nm_strsplit_set(str, " ");
         const char **        s;
 
         for (s = nbns; nbns && *s; s++) {
@@ -557,7 +557,7 @@ nm_dhcp_utils_ip4_config_from_options(NMDedupMultiIndex *multi_idx,
 
     str = g_hash_table_lookup(options, "nis_servers");
     if (str) {
-        gs_free const char **nis = nm_utils_strsplit_set(str, " ");
+        gs_free const char **nis = nm_strsplit_set(str, " ");
         const char **        s;
 
         for (s = nis; nis && *s; s++) {
@@ -689,7 +689,7 @@ nm_dhcp_utils_ip6_config_from_options(NMDedupMultiIndex *multi_idx,
 
     str = g_hash_table_lookup(options, "dhcp6_name_servers");
     if (str) {
-        gs_free const char **dns = nm_utils_strsplit_set(str, " ");
+        gs_free const char **dns = nm_strsplit_set(str, " ");
         const char **        s;
 
         for (s = dns; dns && *s; s++) {
diff --git a/src/core/nm-config.c b/src/core/nm-config.c
index cde5bd7438..c41f582329 100644
--- a/src/core/nm-config.c
+++ b/src/core/nm-config.c
@@ -336,7 +336,7 @@ no_auto_default_from_file(const char *no_auto_default_file)
     gsize         i;
 
     if (no_auto_default_file && g_file_get_contents(no_auto_default_file, &data, NULL, NULL))
-        list = nm_utils_strsplit_set(data, "\n");
+        list = nm_strsplit_set(data, "\n");
 
     if (list) {
         for (i = 0; list[i]; i++)
diff --git a/src/core/nm-dcb.c b/src/core/nm-dcb.c
index 930a10238f..0b995ebf78 100644
--- a/src/core/nm-dcb.c
+++ b/src/core/nm-dcb.c
@@ -35,7 +35,7 @@ do_helper(const char *iface,
     cmdline = g_strdup_vprintf(fmt, args);
     va_end(args);
 
-    split = nm_utils_strsplit_set_with_empty(cmdline, " ");
+    split = nm_strsplit_set_with_empty(cmdline, " ");
     if (!split) {
         g_set_error(error,
                     NM_MANAGER_ERROR,
diff --git a/src/core/settings/plugins/ifcfg-rh/nms-ifcfg-rh-reader.c b/src/core/settings/plugins/ifcfg-rh/nms-ifcfg-rh-reader.c
index a98fa0f9a8..233b778397 100644
--- a/src/core/settings/plugins/ifcfg-rh/nms-ifcfg-rh-reader.c
+++ b/src/core/settings/plugins/ifcfg-rh/nms-ifcfg-rh-reader.c
@@ -474,7 +474,7 @@ make_connection_setting(const char *file,
     if (v) {
         gs_free const char **items = NULL;
 
-        items = nm_utils_strsplit_set(v, " ");
+        items = nm_strsplit_set(v, " ");
         for (iter = items; iter && *iter; iter++) {
             if (!nm_setting_connection_add_permission(s_con, "user", *iter, NULL))
                 PARSE_WARNING("invalid USERS item '%s'", *iter);
@@ -490,7 +490,7 @@ make_connection_setting(const char *file,
     if (v) {
         gs_free const char **items = NULL;
 
-        items = nm_utils_strsplit_set(v, " \t");
+        items = nm_strsplit_set(v, " \t");
         for (iter = items; iter && *iter; iter++) {
             if (!nm_setting_connection_add_secondary(s_con, *iter))
                 PARSE_WARNING("secondary connection UUID '%s' already added", *iter);
@@ -1036,7 +1036,7 @@ parse_route_line(const char *line,
      * Maybe later we want to support some form of quotation here.
      * Which of course, would be incompatible with initscripts.
      */
-    words_free = nm_utils_strsplit_set(line, " \t\n");
+    words_free = nm_strsplit_set(line, " \t\n");
 
     words = words_free ?: NM_PTRARRAY_EMPTY(const char *);
 
@@ -1582,7 +1582,7 @@ parse_dns_options(NMSettingIPConfig *ip_config, const char *value)
     if (!nm_setting_ip_config_has_dns_options(ip_config))
         nm_setting_ip_config_clear_dns_options(ip_config, TRUE);
 
-    options = nm_utils_strsplit_set(value, " ");
+    options = nm_strsplit_set(value, " ");
     if (options) {
         for (item = options; *item; item++) {
             if (!nm_setting_ip_config_add_dns_option(ip_config, *item))
@@ -1999,7 +1999,7 @@ make_ip4_setting(shvarFile *ifcfg,
         if (v) {
             gs_free const char **searches = NULL;
 
-            searches = nm_utils_strsplit_set(v, " ");
+            searches = nm_strsplit_set(v, " ");
             if (searches) {
                 for (item = searches; *item; item++) {
                     if (!nm_setting_ip_config_add_dns_search(s_ip4, *item))
@@ -2059,7 +2059,7 @@ make_ip4_setting(shvarFile *ifcfg,
         if (v) {
             gs_free const char **searches = NULL;
 
-            searches = nm_utils_strsplit_set(v, " ");
+            searches = nm_strsplit_set(v, " ");
             if (searches) {
                 for (item = searches; *item; item++) {
                     if (!nm_setting_ip_config_add_dns_search(s_ip4, *item))
@@ -2433,7 +2433,7 @@ make_ip6_setting(shvarFile *ifcfg, shvarFile *network_ifcfg, gboolean routes_rea
                       ipv6addr_secondaries ?: "",
                       NULL);
 
-    list = nm_utils_strsplit_set(value, " ");
+    list = nm_strsplit_set(value, " ");
     for (iter = list, i = 0; iter && *iter; iter++, i++) {
         NMIPAddress *addr = NULL;
 
@@ -2532,7 +2532,7 @@ make_ip6_setting(shvarFile *ifcfg, shvarFile *network_ifcfg, gboolean routes_rea
     if (v) {
         gs_free const char **searches = NULL;
 
-        searches = nm_utils_strsplit_set(v, " ");
+        searches = nm_strsplit_set(v, " ");
         if (searches) {
             for (iter = searches; *iter; iter++) {
                 if (!nm_setting_ip_config_add_dns_search(s_ip6, *iter))
@@ -2949,7 +2949,7 @@ read_dcb_percent_array(shvarFile *       ifcfg,
         return TRUE;
     }
 
-    split = nm_utils_strsplit_set(val, ",");
+    split = nm_strsplit_set(val, ",");
     if (NM_PTRARRAY_LEN(split) != 8) {
         PARSE_WARNING("invalid %s percentage list value '%s'", prop, val);
         g_set_error_literal(error,
@@ -3368,7 +3368,7 @@ fill_wpa_ciphers(shvarFile *ifcfg, NMSettingWirelessSecurity *wsec, gboolean gro
     if (!p)
         return TRUE;
 
-    list = nm_utils_strsplit_set(p, " ");
+    list = nm_strsplit_set(p, " ");
     for (iter = list; iter && *iter; iter++, i++) {
         if (!strcmp(*iter, "CCMP")) {
             if (group)
@@ -3604,7 +3604,7 @@ parse_8021x_phase2_auth(shvarFile *     ifcfg,
     }
 
     inner_auth = g_ascii_strdown(v, -1);
-    list       = nm_utils_strsplit_set(inner_auth, " ");
+    list       = nm_strsplit_set(inner_auth, " ");
     for (iter = list; iter && *iter; iter++) {
         if (NM_IN_STRSET(*iter, "pap", "chap", "mschap", "mschapv2", "gtc", "otp", "md5")) {
             if (num_auth == 0) {
@@ -3779,7 +3779,7 @@ eap_fast_reader(const char *    eap_method,
     if (fast_provisioning) {
         gs_free const char **list = NULL;
 
-        list = nm_utils_strsplit_set(fast_provisioning, " \t");
+        list = nm_strsplit_set(fast_provisioning, " \t");
         for (iter = list; iter && *iter; iter++) {
             if (strcmp(*iter, "allow-unauth") == 0)
                 allow_unauth = TRUE;
@@ -3857,7 +3857,7 @@ read_8021x_list_value(shvarFile *     ifcfg,
     if (!v)
         return;
 
-    strv = nm_utils_strsplit_set(v, " \t");
+    strv = nm_strsplit_set(v, " \t");
     if (strv)
         g_object_set(setting, prop_name, strv, NULL);
 }
@@ -3884,7 +3884,7 @@ fill_8021x(shvarFile *ifcfg, const char *file, const char *key_mgmt, gboolean wi
         return NULL;
     }
 
-    list = nm_utils_strsplit_set(v, " ");
+    list = nm_strsplit_set(v, " ");
 
     s_8021x = (NMSetting8021x *) nm_setting_802_1x_new();
 
@@ -4237,7 +4237,7 @@ transform_hwaddr_blacklist(const char *blacklist)
     const char **strv;
     gsize        i, j;
 
-    strv = nm_utils_strsplit_set(blacklist, " \t");
+    strv = nm_strsplit_set(blacklist, " \t");
     if (!strv)
         return NULL;
     for (i = 0, j = 0; strv[j]; j++) {
@@ -4706,7 +4706,7 @@ parse_ethtool_option(const char *             value,
     gs_free const char **words        = NULL;
     NMEthtoolType        ethtool_type = NM_ETHTOOL_TYPE_UNKNOWN;
 
-    words = nm_utils_strsplit_set(value, " \t\n");
+    words = nm_strsplit_set(value, " \t\n");
     if (!words)
         return;
 
@@ -4968,7 +4968,7 @@ parse_ethtool_options(shvarFile *ifcfg, NMConnection *connection)
             gs_free const char **opts = NULL;
             const char *const *  iter;
 
-            opts = nm_utils_strsplit_set(ethtool_opts, ";");
+            opts = nm_strsplit_set(ethtool_opts, ";");
             for (iter = opts; iter && iter[0]; iter++) {
                 /* in case of repeated wol_passwords, parse_ethtool_option()
                  * will do the right thing and clear wol_password before resetting. */
@@ -5076,7 +5076,7 @@ make_wired_setting(shvarFile *ifcfg, const char *file, NMSetting8021x **s_8021x,
                 gs_free const char **chans = NULL;
                 guint32              num_chans;
 
-                chans     = nm_utils_strsplit_set(cvalue, ",");
+                chans     = nm_strsplit_set(cvalue, ",");
                 num_chans = NM_PTRARRAY_LEN(chans);
                 if (num_chans < 2 || num_chans > 3) {
                     PARSE_WARNING("invalid SUBCHANNELS '%s' (%u channels, 2 or 3 expected)",
@@ -5448,7 +5448,7 @@ make_bond_setting(shvarFile *ifcfg, const char *file, GError **error)
         gs_free const char **items = NULL;
         const char *const *  iter;
 
-        items = nm_utils_strsplit_set(v, " ");
+        items = nm_strsplit_set(v, " ");
         for (iter = items; iter && *iter; iter++) {
             gs_free char *key = NULL;
             const char *  val;
@@ -5758,7 +5758,7 @@ handle_bridging_opts(NMSetting *   setting,
     gs_free const char **items = NULL;
     const char *const *  iter;
 
-    items = nm_utils_strsplit_set(value, " ");
+    items = nm_strsplit_set(value, " ");
     for (iter = items; iter && *iter; iter++) {
         gs_free char *key = NULL;
         const char *  val;
@@ -6019,7 +6019,7 @@ parse_prio_map_list(NMSettingVlan *s_vlan, shvarFile *ifcfg, const char *key, NM
     v = svGetValueStr(ifcfg, key, &value);
     if (!v)
         return;
-    list = nm_utils_strsplit_set(v, ",");
+    list = nm_strsplit_set(v, ",");
 
     for (iter = list; iter && *iter; iter++) {
         if (!strchr(*iter, ':'))
@@ -6130,7 +6130,7 @@ make_vlan_setting(shvarFile *ifcfg, const char *file, GError **error)
         gs_free const char **strv = NULL;
         const char *const *  ptr;
 
-        strv = nm_utils_strsplit_set(v, ", ");
+        strv = nm_strsplit_set(v, ", ");
         for (ptr = strv; ptr && *ptr; ptr++) {
             if (nm_streq(*ptr, "GVRP") && gvrp == -1)
                 vlan_flags |= NM_VLAN_FLAG_GVRP;
@@ -6276,7 +6276,7 @@ check_dns_search_domains(shvarFile *ifcfg, NMSetting *s_ip4, NMSetting *s_ip6)
             gs_free const char **searches = NULL;
             const char *const *  item;
 
-            searches = nm_utils_strsplit_set(v, " ");
+            searches = nm_strsplit_set(v, " ");
             if (searches) {
                 for (item = searches; *item; item++) {
                     if (!nm_setting_ip_config_add_dns_search(NM_SETTING_IP_CONFIG(s_ip6), *item))
diff --git a/src/core/settings/plugins/ifupdown/nms-ifupdown-parser.c b/src/core/settings/plugins/ifupdown/nms-ifupdown-parser.c
index db6b1aefb7..5bad2362fa 100644
--- a/src/core/settings/plugins/ifupdown/nms-ifupdown-parser.c
+++ b/src/core/settings/plugins/ifupdown/nms-ifupdown-parser.c
@@ -397,7 +397,7 @@ ifupdown_ip4_add_dns(NMSettingIPConfig *s_ip4, const char *dns)
     if (dns == NULL)
         return;
 
-    list = nm_utils_strsplit_set(dns, " \t");
+    list = nm_strsplit_set(dns, " \t");
     for (iter = list; iter && *iter; iter++) {
         if (!inet_pton(AF_INET, *iter, &addr)) {
             _LOGW("    ignoring invalid nameserver '%s'", *iter);
@@ -497,7 +497,7 @@ update_ip4_setting_from_if_block(NMConnection *connection, if_block *block, GErr
             gs_free const char **list = NULL;
             const char **        iter;
 
-            list = nm_utils_strsplit_set(search_v, " \t");
+            list = nm_strsplit_set(search_v, " \t");
             for (iter = list; iter && *iter; iter++) {
                 if (!nm_setting_ip_config_add_dns_search(s_ip4, *iter))
                     _LOGW("    duplicate DNS domain '%s'", *iter);
@@ -521,7 +521,7 @@ ifupdown_ip6_add_dns(NMSettingIPConfig *s_ip6, const char *dns)
     if (dns == NULL)
         return;
 
-    list = nm_utils_strsplit_set(dns, " \t");
+    list = nm_strsplit_set(dns, " \t");
     for (iter = list; iter && *iter; iter++) {
         if (!inet_pton(AF_INET6, *iter, &addr)) {
             _LOGW("    ignoring invalid nameserver '%s'", *iter);
@@ -605,7 +605,7 @@ update_ip6_setting_from_if_block(NMConnection *connection, if_block *block, GErr
             gs_free const char **list = NULL;
             const char **        iter;
 
-            list = nm_utils_strsplit_set(search_v, " \t");
+            list = nm_strsplit_set(search_v, " \t");
             for (iter = list; iter && *iter; iter++) {
                 if (!nm_setting_ip_config_add_dns_search(s_ip6, *iter))
                     _LOGW("    duplicate DNS domain '%s'", *iter);
diff --git a/src/core/settings/plugins/ifupdown/nms-ifupdown-plugin.c b/src/core/settings/plugins/ifupdown/nms-ifupdown-plugin.c
index 80a5638a13..bac78d4738 100644
--- a/src/core/settings/plugins/ifupdown/nms-ifupdown-plugin.c
+++ b/src/core/settings/plugins/ifupdown/nms-ifupdown-plugin.c
@@ -264,7 +264,7 @@ load_eni_ifaces(NMSIfupdownPlugin *self)
 
                     _LOGD("parse: found bridge ports %s for %s", ports, block->name);
 
-                    port_ifaces = nm_utils_strsplit_set(ports, " \t");
+                    port_ifaces = nm_strsplit_set(ports, " \t");
                     for (i = 0; port_ifaces && port_ifaces[i]; i++) {
                         const char *token = port_ifaces[i];
 
diff --git a/src/libnm-core-aux-intern/nm-libnm-core-utils.c b/src/libnm-core-aux-intern/nm-libnm-core-utils.c
index e53f840a28..849037ca07 100644
--- a/src/libnm-core-aux-intern/nm-libnm-core-utils.c
+++ b/src/libnm-core-aux-intern/nm-libnm-core-utils.c
@@ -14,7 +14,7 @@
 const char **
 nm_utils_bond_option_arp_ip_targets_split(const char *arp_ip_target)
 {
-    return nm_utils_strsplit_set_full(arp_ip_target, ",", NM_UTILS_STRSPLIT_SET_FLAGS_STRSTRIP);
+    return nm_strsplit_set_full(arp_ip_target, ",", NM_STRSPLIT_SET_FLAGS_STRSTRIP);
 }
 
 void
diff --git a/src/libnm-core-impl/nm-utils.c b/src/libnm-core-impl/nm-utils.c
index 7eefe3e456..6101db1919 100644
--- a/src/libnm-core-impl/nm-utils.c
+++ b/src/libnm-core-impl/nm-utils.c
@@ -2882,7 +2882,7 @@ _nm_sriov_vf_parse_vlans(NMSriovVF *vf, const char *str, GError **error)
     gs_free const char **vlans = NULL;
     guint                i;
 
-    vlans = nm_utils_strsplit_set(str, ";");
+    vlans = nm_strsplit_set(str, ";");
     if (!vlans) {
         g_set_error_literal(error,
                             NM_CONNECTION_ERROR,
diff --git a/src/libnm-core-impl/tests/test-general.c b/src/libnm-core-impl/tests/test-general.c
index 7cd00efe27..ebc7243be7 100644
--- a/src/libnm-core-impl/tests/test-general.c
+++ b/src/libnm-core-impl/tests/test-general.c
@@ -542,27 +542,25 @@ test_nm_g_slice_free_fcn(void)
 /*****************************************************************************/
 
 static void
-_do_test_nm_utils_strsplit_set_f_one(NMUtilsStrsplitSetFlags flags,
-                                     const char *            str,
-                                     gsize                   words_len,
-                                     const char *const *     exp_words)
+_do_test_nm_strsplit_set_f_one(NMUtilsStrsplitSetFlags flags,
+                               const char *            str,
+                               gsize                   words_len,
+                               const char *const *     exp_words)
 {
 #define DELIMITERS   " \n"
 #define DELIMITERS_C ' ', '\n'
 
     gs_free const char **words = NULL;
     gsize                i, j, k;
-    const gboolean       f_allow_escaping =
-        NM_FLAGS_HAS(flags, NM_UTILS_STRSPLIT_SET_FLAGS_ALLOW_ESCAPING);
-    const gboolean f_preserve_empty =
-        NM_FLAGS_HAS(flags, NM_UTILS_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY);
+    const gboolean     f_allow_escaping = NM_FLAGS_HAS(flags, NM_STRSPLIT_SET_FLAGS_ALLOW_ESCAPING);
+    const gboolean     f_preserve_empty = NM_FLAGS_HAS(flags, NM_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY);
     const char *       s1;
     gsize              initial_offset;
     gs_strfreev char **words_g = NULL;
 
-    g_assert(!NM_FLAGS_ANY(flags,
-                           ~(NM_UTILS_STRSPLIT_SET_FLAGS_ALLOW_ESCAPING
-                             | NM_UTILS_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY)));
+    g_assert(!NM_FLAGS_ANY(
+        flags,
+        ~(NM_STRSPLIT_SET_FLAGS_ALLOW_ESCAPING | NM_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY)));
 
     /* assert that the expected words are valid (and don't contain unescaped delimiters). */
     for (i = 0; i < words_len; i++) {
@@ -623,12 +621,12 @@ _do_test_nm_utils_strsplit_set_f_one(NMUtilsStrsplitSetFlags flags,
         }
     }
 
-    if (flags == NM_UTILS_STRSPLIT_SET_FLAGS_NONE && nmtst_get_rand_bool())
-        words = nm_utils_strsplit_set(str, DELIMITERS);
-    else if (flags == NM_UTILS_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY && nmtst_get_rand_bool())
-        words = nm_utils_strsplit_set_with_empty(str, DELIMITERS);
+    if (flags == NM_STRSPLIT_SET_FLAGS_NONE && nmtst_get_rand_bool())
+        words = nm_strsplit_set(str, DELIMITERS);
+    else if (flags == NM_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY && nmtst_get_rand_bool())
+        words = nm_strsplit_set_with_empty(str, DELIMITERS);
     else
-        words = nm_utils_strsplit_set_full(str, DELIMITERS, flags);
+        words = nm_strsplit_set_full(str, DELIMITERS, flags);
 
     g_assert_cmpint(NM_PTRARRAY_LEN(words), ==, words_len);
 
@@ -751,14 +749,14 @@ _do_test_nm_utils_strsplit_set_f_one(NMUtilsStrsplitSetFlags flags,
 }
 
 static void
-_do_test_nm_utils_strsplit_set_f(NMUtilsStrsplitSetFlags flags,
-                                 const char *            str,
-                                 gsize                   words_len,
-                                 const char *const *     exp_words)
+_do_test_nm_strsplit_set_f(NMUtilsStrsplitSetFlags flags,
+                           const char *            str,
+                           gsize                   words_len,
+                           const char *const *     exp_words)
 {
-    _do_test_nm_utils_strsplit_set_f_one(flags, str, words_len, exp_words);
+    _do_test_nm_strsplit_set_f_one(flags, str, words_len, exp_words);
 
-    if (NM_FLAGS_HAS(flags, NM_UTILS_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY)) {
+    if (NM_FLAGS_HAS(flags, NM_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY)) {
         gs_unref_ptrarray GPtrArray *exp_words2 = NULL;
         gsize                        k;
 
@@ -768,32 +766,32 @@ _do_test_nm_utils_strsplit_set_f(NMUtilsStrsplitSetFlags flags,
                 g_ptr_array_add(exp_words2, (gpointer) exp_words[k]);
         }
 
-        _do_test_nm_utils_strsplit_set_f_one(flags & (~NM_UTILS_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY),
-                                             str,
-                                             exp_words2->len,
-                                             (const char *const *) exp_words2->pdata);
+        _do_test_nm_strsplit_set_f_one(flags & (~NM_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY),
+                                       str,
+                                       exp_words2->len,
+                                       (const char *const *) exp_words2->pdata);
     }
 }
 
-#define do_test_nm_utils_strsplit_set_f(flags, str, ...) \
-    _do_test_nm_utils_strsplit_set_f(flags, str, NM_NARG(__VA_ARGS__), NM_MAKE_STRV(__VA_ARGS__))
+#define do_test_nm_strsplit_set_f(flags, str, ...) \
+    _do_test_nm_strsplit_set_f(flags, str, NM_NARG(__VA_ARGS__), NM_MAKE_STRV(__VA_ARGS__))
 
-#define do_test_nm_utils_strsplit_set(allow_escaping, str, ...)                                   \
-    do_test_nm_utils_strsplit_set_f((allow_escaping) ? NM_UTILS_STRSPLIT_SET_FLAGS_ALLOW_ESCAPING \
-                                                     : NM_UTILS_STRSPLIT_SET_FLAGS_NONE,          \
-                                    str,                                                          \
-                                    ##__VA_ARGS__)
+#define do_test_nm_strsplit_set(allow_escaping, str, ...)                             \
+    do_test_nm_strsplit_set_f((allow_escaping) ? NM_STRSPLIT_SET_FLAGS_ALLOW_ESCAPING \
+                                               : NM_STRSPLIT_SET_FLAGS_NONE,          \
+                              str,                                                    \
+                              ##__VA_ARGS__)
 
 static void
-_do_test_nm_utils_strsplit_set_simple(NMUtilsStrsplitSetFlags flags,
-                                      const char *            str,
-                                      gsize                   words_len,
-                                      const char *const *     exp_words)
+_do_test_nm_strsplit_set_simple(NMUtilsStrsplitSetFlags flags,
+                                const char *            str,
+                                gsize                   words_len,
+                                const char *const *     exp_words)
 {
     gs_free const char **tokens = NULL;
     gsize                n_tokens;
 
-    tokens = nm_utils_strsplit_set_full(str, DELIMITERS, flags);
+    tokens = nm_strsplit_set_full(str, DELIMITERS, flags);
 
     if (!tokens) {
         g_assert_cmpint(words_len, ==, 0);
@@ -826,107 +824,87 @@ _do_test_nm_utils_strsplit_set_simple(NMUtilsStrsplitSetFlags flags,
     }
     g_assert_cmpint(words_len, ==, NM_PTRARRAY_LEN(tokens));
 }
-#define do_test_nm_utils_strsplit_set_simple(flags, str, ...)   \
-    _do_test_nm_utils_strsplit_set_simple((flags),              \
-                                          (str),                \
-                                          NM_NARG(__VA_ARGS__), \
-                                          NM_MAKE_STRV(__VA_ARGS__))
+#define do_test_nm_strsplit_set_simple(flags, str, ...) \
+    _do_test_nm_strsplit_set_simple((flags), (str), NM_NARG(__VA_ARGS__), NM_MAKE_STRV(__VA_ARGS__))
 
 static void
-test_nm_utils_strsplit_set(void)
+test_nm_strsplit_set(void)
 {
     gs_unref_ptrarray GPtrArray *words_exp = NULL;
     guint                        test_run;
 
-    do_test_nm_utils_strsplit_set_f(NM_UTILS_STRSPLIT_SET_FLAGS_NONE, NULL);
-    do_test_nm_utils_strsplit_set_f(NM_UTILS_STRSPLIT_SET_FLAGS_NONE, "");
-    do_test_nm_utils_strsplit_set_f(NM_UTILS_STRSPLIT_SET_FLAGS_NONE, " ");
-    do_test_nm_utils_strsplit_set_f(NM_UTILS_STRSPLIT_SET_FLAGS_NONE, "a  b", "a", "b");
-
-    do_test_nm_utils_strsplit_set_f(NM_UTILS_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY, NULL);
-    do_test_nm_utils_strsplit_set_f(NM_UTILS_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY, "");
-    do_test_nm_utils_strsplit_set_f(NM_UTILS_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY, " ", "", "");
-    do_test_nm_utils_strsplit_set_f(NM_UTILS_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY, "  ", "", "", "");
-    do_test_nm_utils_strsplit_set_f(NM_UTILS_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY, "a  ", "a", "", "");
-    do_test_nm_utils_strsplit_set_f(NM_UTILS_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY,
-                                    "a  b",
-                                    "a",
-                                    "",
-                                    "b");
-    do_test_nm_utils_strsplit_set_f(NM_UTILS_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY,
-                                    " ab  b",
-                                    "",
-                                    "ab",
-                                    "",
-                                    "b");
-    do_test_nm_utils_strsplit_set_f(NM_UTILS_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY,
-                                    "ab  b",
-                                    "ab",
-                                    "",
-                                    "b");
-    do_test_nm_utils_strsplit_set_f(NM_UTILS_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY, "abb", "abb");
-    do_test_nm_utils_strsplit_set_f(NM_UTILS_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY,
-                                    "abb  bb ",
-                                    "abb",
-                                    "",
-                                    "bb",
-                                    "");
-    do_test_nm_utils_strsplit_set_f(NM_UTILS_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY,
-                                    "abb bcb ",
-                                    "abb",
-                                    "bcb",
-                                    "");
-
-    do_test_nm_utils_strsplit_set(FALSE, NULL);
-    do_test_nm_utils_strsplit_set(FALSE, "");
-    do_test_nm_utils_strsplit_set(FALSE, "\n");
-    do_test_nm_utils_strsplit_set(TRUE, " \t\n", "\t");
-    do_test_nm_utils_strsplit_set(FALSE, "a", "a");
-    do_test_nm_utils_strsplit_set(FALSE, "a b", "a", "b");
-    do_test_nm_utils_strsplit_set(FALSE, "a\rb", "a\rb");
-    do_test_nm_utils_strsplit_set(FALSE, "  a\rb  ", "a\rb");
-    do_test_nm_utils_strsplit_set(FALSE, "  a bbbd afds ere", "a", "bbbd", "afds", "ere");
-    do_test_nm_utils_strsplit_set(FALSE,
-                                  "1 2 3 4 5 6 7 8 9 0 "
-                                  "1 2 3 4 5 6 7 8 9 0 "
-                                  "1 2 3 4 5 6 7 8 9 0",
-                                  "1",
-                                  "2",
-                                  "3",
-                                  "4",
-                                  "5",
-                                  "6",
-                                  "7",
-                                  "8",
-                                  "9",
-                                  "0",
-                                  "1",
-                                  "2",
-                                  "3",
-                                  "4",
-                                  "5",
-                                  "6",
-                                  "7",
-                                  "8",
-                                  "9",
-                                  "0",
-                                  "1",
-                                  "2",
-                                  "3",
-                                  "4",
-                                  "5",
-                                  "6",
-                                  "7",
-                                  "8",
-                                  "9",
-                                  "0");
-    do_test_nm_utils_strsplit_set(TRUE, "\\", "\\");
-    do_test_nm_utils_strsplit_set(TRUE, "\\ ", "\\ ");
-    do_test_nm_utils_strsplit_set(TRUE, "\\\\", "\\\\");
-    do_test_nm_utils_strsplit_set(TRUE, "\\\t", "\\\t");
-    do_test_nm_utils_strsplit_set(TRUE, "foo\\", "foo\\");
-    do_test_nm_utils_strsplit_set(TRUE, "bar foo\\", "bar", "foo\\");
-    do_test_nm_utils_strsplit_set(TRUE, "\\ a b\\ \\  c", "\\ a", "b\\ \\ ", "c");
+    do_test_nm_strsplit_set_f(NM_STRSPLIT_SET_FLAGS_NONE, NULL);
+    do_test_nm_strsplit_set_f(NM_STRSPLIT_SET_FLAGS_NONE, "");
+    do_test_nm_strsplit_set_f(NM_STRSPLIT_SET_FLAGS_NONE, " ");
+    do_test_nm_strsplit_set_f(NM_STRSPLIT_SET_FLAGS_NONE, "a  b", "a", "b");
+
+    do_test_nm_strsplit_set_f(NM_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY, NULL);
+    do_test_nm_strsplit_set_f(NM_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY, "");
+    do_test_nm_strsplit_set_f(NM_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY, " ", "", "");
+    do_test_nm_strsplit_set_f(NM_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY, "  ", "", "", "");
+    do_test_nm_strsplit_set_f(NM_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY, "a  ", "a", "", "");
+    do_test_nm_strsplit_set_f(NM_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY, "a  b", "a", "", "b");
+    do_test_nm_strsplit_set_f(NM_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY, " ab  b", "", "ab", "", "b");
+    do_test_nm_strsplit_set_f(NM_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY, "ab  b", "ab", "", "b");
+    do_test_nm_strsplit_set_f(NM_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY, "abb", "abb");
+    do_test_nm_strsplit_set_f(NM_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY,
+                              "abb  bb ",
+                              "abb",
+                              "",
+                              "bb",
+                              "");
+    do_test_nm_strsplit_set_f(NM_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY, "abb bcb ", "abb", "bcb", "");
+
+    do_test_nm_strsplit_set(FALSE, NULL);
+    do_test_nm_strsplit_set(FALSE, "");
+    do_test_nm_strsplit_set(FALSE, "\n");
+    do_test_nm_strsplit_set(TRUE, " \t\n", "\t");
+    do_test_nm_strsplit_set(FALSE, "a", "a");
+    do_test_nm_strsplit_set(FALSE, "a b", "a", "b");
+    do_test_nm_strsplit_set(FALSE, "a\rb", "a\rb");
+    do_test_nm_strsplit_set(FALSE, "  a\rb  ", "a\rb");
+    do_test_nm_strsplit_set(FALSE, "  a bbbd afds ere", "a", "bbbd", "afds", "ere");
+    do_test_nm_strsplit_set(FALSE,
+                            "1 2 3 4 5 6 7 8 9 0 "
+                            "1 2 3 4 5 6 7 8 9 0 "
+                            "1 2 3 4 5 6 7 8 9 0",
+                            "1",
+                            "2",
+                            "3",
+                            "4",
+                            "5",
+                            "6",
+                            "7",
+                            "8",
+                            "9",
+                            "0",
+                            "1",
+                            "2",
+                            "3",
+                            "4",
+                            "5",
+                            "6",
+                            "7",
+                            "8",
+                            "9",
+                            "0",
+                            "1",
+                            "2",
+                            "3",
+                            "4",
+                            "5",
+                            "6",
+                            "7",
+                            "8",
+                            "9",
+                            "0");
+    do_test_nm_strsplit_set(TRUE, "\\", "\\");
+    do_test_nm_strsplit_set(TRUE, "\\ ", "\\ ");
+    do_test_nm_strsplit_set(TRUE, "\\\\", "\\\\");
+    do_test_nm_strsplit_set(TRUE, "\\\t", "\\\t");
+    do_test_nm_strsplit_set(TRUE, "foo\\", "foo\\");
+    do_test_nm_strsplit_set(TRUE, "bar foo\\", "bar", "foo\\");
+    do_test_nm_strsplit_set(TRUE, "\\ a b\\ \\  c", "\\ a", "b\\ \\ ", "c");
 
     words_exp = g_ptr_array_new_with_free_func(g_free);
     for (test_run = 0; test_run < 100; test_run++) {
@@ -974,52 +952,40 @@ test_nm_utils_strsplit_set(void)
             words_len = 0;
         }
 
-        _do_test_nm_utils_strsplit_set_f((f_allow_escaping
-                                              ? NM_UTILS_STRSPLIT_SET_FLAGS_ALLOW_ESCAPING
-                                              : NM_UTILS_STRSPLIT_SET_FLAGS_NONE)
-                                             | NM_UTILS_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY,
-                                         str,
-                                         words_len,
-                                         (const char *const *) words_exp->pdata);
+        _do_test_nm_strsplit_set_f(
+            (f_allow_escaping ? NM_STRSPLIT_SET_FLAGS_ALLOW_ESCAPING : NM_STRSPLIT_SET_FLAGS_NONE)
+                | NM_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY,
+            str,
+            words_len,
+            (const char *const *) words_exp->pdata);
     }
 
-    do_test_nm_utils_strsplit_set_simple(NM_UTILS_STRSPLIT_SET_FLAGS_ESCAPED, "\t", "\t");
-    do_test_nm_utils_strsplit_set_simple(NM_UTILS_STRSPLIT_SET_FLAGS_ESCAPED
-                                             | NM_UTILS_STRSPLIT_SET_FLAGS_STRSTRIP,
-                                         "\t");
-    do_test_nm_utils_strsplit_set_simple(NM_UTILS_STRSPLIT_SET_FLAGS_ESCAPED
-                                             | NM_UTILS_STRSPLIT_SET_FLAGS_STRSTRIP
-                                             | NM_UTILS_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY,
-                                         "\t",
-                                         "");
-    do_test_nm_utils_strsplit_set_simple(NM_UTILS_STRSPLIT_SET_FLAGS_ESCAPED
-                                             | NM_UTILS_STRSPLIT_SET_FLAGS_STRSTRIP
-                                             | NM_UTILS_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY,
-                                         "\t\\\t\t\t\\\t",
-                                         "\t\t\t\t");
-
-    do_test_nm_utils_strsplit_set_simple(NM_UTILS_STRSPLIT_SET_FLAGS_ESCAPED, "\ta", "\ta");
-    do_test_nm_utils_strsplit_set_simple(NM_UTILS_STRSPLIT_SET_FLAGS_ESCAPED
-                                             | NM_UTILS_STRSPLIT_SET_FLAGS_STRSTRIP,
-                                         "\ta",
-                                         "a");
-    do_test_nm_utils_strsplit_set_simple(NM_UTILS_STRSPLIT_SET_FLAGS_ESCAPED,
-                                         "\ta\\ b\t\\ ",
-                                         "\ta b\t ");
-    do_test_nm_utils_strsplit_set_simple(NM_UTILS_STRSPLIT_SET_FLAGS_ESCAPED
-                                             | NM_UTILS_STRSPLIT_SET_FLAGS_STRSTRIP,
-                                         "\ta\\ b\t\\ \t",
-                                         "a b\t ");
-    do_test_nm_utils_strsplit_set_simple(NM_UTILS_STRSPLIT_SET_FLAGS_ESCAPED, "a\\  b", "a ", "b");
-    do_test_nm_utils_strsplit_set_simple(NM_UTILS_STRSPLIT_SET_FLAGS_ESCAPED,
-                                         "\ta\\  b",
-                                         "\ta ",
-                                         "b");
-    do_test_nm_utils_strsplit_set_simple(NM_UTILS_STRSPLIT_SET_FLAGS_ESCAPED
-                                             | NM_UTILS_STRSPLIT_SET_FLAGS_STRSTRIP,
-                                         "\ta\\  b",
-                                         "a ",
-                                         "b");
+    do_test_nm_strsplit_set_simple(NM_STRSPLIT_SET_FLAGS_ESCAPED, "\t", "\t");
+    do_test_nm_strsplit_set_simple(NM_STRSPLIT_SET_FLAGS_ESCAPED | NM_STRSPLIT_SET_FLAGS_STRSTRIP,
+                                   "\t");
+    do_test_nm_strsplit_set_simple(NM_STRSPLIT_SET_FLAGS_ESCAPED | NM_STRSPLIT_SET_FLAGS_STRSTRIP
+                                       | NM_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY,
+                                   "\t",
+                                   "");
+    do_test_nm_strsplit_set_simple(NM_STRSPLIT_SET_FLAGS_ESCAPED | NM_STRSPLIT_SET_FLAGS_STRSTRIP
+                                       | NM_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY,
+                                   "\t\\\t\t\t\\\t",
+                                   "\t\t\t\t");
+
+    do_test_nm_strsplit_set_simple(NM_STRSPLIT_SET_FLAGS_ESCAPED, "\ta", "\ta");
+    do_test_nm_strsplit_set_simple(NM_STRSPLIT_SET_FLAGS_ESCAPED | NM_STRSPLIT_SET_FLAGS_STRSTRIP,
+                                   "\ta",
+                                   "a");
+    do_test_nm_strsplit_set_simple(NM_STRSPLIT_SET_FLAGS_ESCAPED, "\ta\\ b\t\\ ", "\ta b\t ");
+    do_test_nm_strsplit_set_simple(NM_STRSPLIT_SET_FLAGS_ESCAPED | NM_STRSPLIT_SET_FLAGS_STRSTRIP,
+                                   "\ta\\ b\t\\ \t",
+                                   "a b\t ");
+    do_test_nm_strsplit_set_simple(NM_STRSPLIT_SET_FLAGS_ESCAPED, "a\\  b", "a ", "b");
+    do_test_nm_strsplit_set_simple(NM_STRSPLIT_SET_FLAGS_ESCAPED, "\ta\\  b", "\ta ", "b");
+    do_test_nm_strsplit_set_simple(NM_STRSPLIT_SET_FLAGS_ESCAPED | NM_STRSPLIT_SET_FLAGS_STRSTRIP,
+                                   "\ta\\  b",
+                                   "a ",
+                                   "b");
 }
 
 /*****************************************************************************/
@@ -10718,7 +10684,7 @@ main(int argc, char **argv)
     g_test_add_func("/core/general/test_c_list_sort", test_c_list_sort);
     g_test_add_func("/core/general/test_dedup_multi", test_dedup_multi);
     g_test_add_func("/core/general/test_utils_str_utf8safe", test_utils_str_utf8safe);
-    g_test_add_func("/core/general/test_nm_utils_strsplit_set", test_nm_utils_strsplit_set);
+    g_test_add_func("/core/general/test_nm_strsplit_set", test_nm_strsplit_set);
     g_test_add_func("/core/general/test_nm_utils_escaped_tokens", test_nm_utils_escaped_tokens);
     g_test_add_func("/core/general/test_nm_in_set", test_nm_in_set);
     g_test_add_func("/core/general/test_nm_in_strset", test_nm_in_strset);
diff --git a/src/libnm-glib-aux/nm-shared-utils.c b/src/libnm-glib-aux/nm-shared-utils.c
index cd600dab95..de93a68be0 100644
--- a/src/libnm-glib-aux/nm-shared-utils.c
+++ b/src/libnm-glib-aux/nm-shared-utils.c
@@ -1732,7 +1732,7 @@ _char_lookup_has_all(const CharLookupTable *lookup, const char *candidates)
 }
 
 /**
- * nm_utils_strsplit_set_full:
+ * nm_strsplit_set_full:
  * @str: the string to split.
  * @delimiters: the set of delimiters.
  * @flags: additional flags for controlling the operation.
@@ -1746,7 +1746,7 @@ _char_lookup_has_all(const CharLookupTable *lookup, const char *candidates)
  * This never returns an empty array.
  *
  * Returns: %NULL if @str is %NULL or "".
- *   If @str only contains delimiters and %NM_UTILS_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY
+ *   If @str only contains delimiters and %NM_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY
  *   is not set, it also returns %NULL.
  *   Otherwise, a %NULL terminated strv array containing the split words.
  *   (delimiter characters are removed).
@@ -1757,7 +1757,7 @@ _char_lookup_has_all(const CharLookupTable *lookup, const char *candidates)
  *   like "g_strstrip((char *) iter[0])".
  */
 const char **
-nm_utils_strsplit_set_full(const char *str, const char *delimiters, NMUtilsStrsplitSetFlags flags)
+nm_strsplit_set_full(const char *str, const char *delimiters, NMUtilsStrsplitSetFlags flags)
 {
     const char **   ptr;
     gsize           num_tokens;
@@ -1766,12 +1766,11 @@ nm_utils_strsplit_set_full(const char *str, const char *delimiters, NMUtilsStrsp
     const char *    c_str;
     char *          s;
     CharLookupTable ch_lookup;
-    const gboolean  f_escaped = NM_FLAGS_HAS(flags, NM_UTILS_STRSPLIT_SET_FLAGS_ESCAPED);
+    const gboolean  f_escaped = NM_FLAGS_HAS(flags, NM_STRSPLIT_SET_FLAGS_ESCAPED);
     const gboolean  f_allow_escaping =
-        f_escaped || NM_FLAGS_HAS(flags, NM_UTILS_STRSPLIT_SET_FLAGS_ALLOW_ESCAPING);
-    const gboolean f_preserve_empty =
-        NM_FLAGS_HAS(flags, NM_UTILS_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY);
-    const gboolean f_strstrip = NM_FLAGS_HAS(flags, NM_UTILS_STRSPLIT_SET_FLAGS_STRSTRIP);
+        f_escaped || NM_FLAGS_HAS(flags, NM_STRSPLIT_SET_FLAGS_ALLOW_ESCAPING);
+    const gboolean f_preserve_empty = NM_FLAGS_HAS(flags, NM_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY);
+    const gboolean f_strstrip       = NM_FLAGS_HAS(flags, NM_STRSPLIT_SET_FLAGS_STRSTRIP);
 
     if (!str)
         return NULL;
@@ -1790,8 +1789,8 @@ nm_utils_strsplit_set_full(const char *str, const char *delimiters, NMUtilsStrsp
     }
 
     if (!str[0]) {
-        /* We return %NULL here, also with NM_UTILS_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY.
-         * That makes nm_utils_strsplit_set_full() with NM_UTILS_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY
+        /* We return %NULL here, also with NM_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY.
+         * That makes nm_strsplit_set_full() with NM_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY
          * different from g_strsplit_set(), which would in this case return an empty array.
          * If you need to handle %NULL, and "" specially, then check the input string first. */
         return NULL;
@@ -2174,7 +2173,7 @@ nm_utils_escaped_tokens_options_split(char *str, const char **out_key, const cha
  * with the flags "EXTRACT_UNQUOTE | EXTRACT_RELAX". This is what
  * systemd uses to parse /proc/cmdline, and we do too.
  *
- * Splits the string. We have nm_utils_strsplit_set() which
+ * Splits the string. We have nm_strsplit_set() which
  * supports a variety of flags. However, extending that already
  * complex code to also support quotation and escaping is hard.
  * Instead, add a naive implementation.
@@ -4285,7 +4284,7 @@ nm_utils_get_start_time_for_pid(pid_t pid, char *out_state, pid_t *out_ppid)
 
     state = p[0];
 
-    tokens = nm_utils_strsplit_set(p, " ");
+    tokens = nm_strsplit_set(p, " ");
 
     if (NM_PTRARRAY_LEN(tokens) < 20)
         goto fail;
diff --git a/src/libnm-glib-aux/nm-shared-utils.h b/src/libnm-glib-aux/nm-shared-utils.h
index 8342e0a98f..82772b030e 100644
--- a/src/libnm-glib-aux/nm-shared-utils.h
+++ b/src/libnm-glib-aux/nm-shared-utils.h
@@ -656,85 +656,85 @@ int nm_utils_dbus_path_cmp(const char *dbus_path_a, const char *dbus_path_b);
 /*****************************************************************************/
 
 typedef enum {
-    NM_UTILS_STRSPLIT_SET_FLAGS_NONE = 0,
+    NM_STRSPLIT_SET_FLAGS_NONE = 0,
 
     /* by default, strsplit will coalesce consecutive delimiters and remove
      * them from the result. If this flag is present, empty values are preserved
      * and returned.
      *
-     * When combined with %NM_UTILS_STRSPLIT_SET_FLAGS_STRSTRIP, if a value gets
+     * When combined with %NM_STRSPLIT_SET_FLAGS_STRSTRIP, if a value gets
      * empty after strstrip(), it also gets removed. */
-    NM_UTILS_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY = (1u << 0),
+    NM_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY = (1u << 0),
 
-    /* %NM_UTILS_STRSPLIT_SET_FLAGS_ALLOW_ESCAPING means that delimiters prefixed
+    /* %NM_STRSPLIT_SET_FLAGS_ALLOW_ESCAPING means that delimiters prefixed
      * by a backslash are not treated as a separator. Such delimiters and their escape
      * character are copied to the current word without unescaping them. In general,
-     * nm_utils_strsplit_set_full() does not remove any backslash escape characters
+     * nm_strsplit_set_full() does not remove any backslash escape characters
      * and does no unescaping. It only considers them for skipping to split at
      * an escaped delimiter.
      *
-     * If this is combined with (or implied by %NM_UTILS_STRSPLIT_SET_FLAGS_ESCAPED), then
+     * If this is combined with (or implied by %NM_STRSPLIT_SET_FLAGS_ESCAPED), then
      * the backslash escapes are removed from the result.
      */
-    NM_UTILS_STRSPLIT_SET_FLAGS_ALLOW_ESCAPING = (1u << 1),
+    NM_STRSPLIT_SET_FLAGS_ALLOW_ESCAPING = (1u << 1),
 
     /* If flag is set, does the same as g_strstrip() on the returned tokens.
      * This will remove leading and trailing ascii whitespaces (g_ascii_isspace()
      * and NM_ASCII_SPACES).
      *
-     * - when combined with !%NM_UTILS_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY,
+     * - when combined with !%NM_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY,
      *   empty tokens will be removed (and %NULL will be returned if that
      *   results in an empty string array).
-     * - when combined with %NM_UTILS_STRSPLIT_SET_FLAGS_ALLOW_ESCAPING,
+     * - when combined with %NM_STRSPLIT_SET_FLAGS_ALLOW_ESCAPING,
      *   trailing whitespace escaped by backslash are not stripped. */
-    NM_UTILS_STRSPLIT_SET_FLAGS_STRSTRIP = (1u << 2),
+    NM_STRSPLIT_SET_FLAGS_STRSTRIP = (1u << 2),
 
-    /* This implies %NM_UTILS_STRSPLIT_SET_FLAGS_ALLOW_ESCAPING.
+    /* This implies %NM_STRSPLIT_SET_FLAGS_ALLOW_ESCAPING.
      *
      * This will do a final run over all tokens and remove all backslash
      * escape characters that
      *   - precede a delimiter.
      *   - precede a backslash.
-     *   - precede a whitespace (only with %NM_UTILS_STRSPLIT_SET_FLAGS_STRSTRIP).
+     *   - precede a whitespace (only with %NM_STRSPLIT_SET_FLAGS_STRSTRIP).
      *
-     *  Note that with %NM_UTILS_STRSPLIT_SET_FLAGS_STRSTRIP, it is only
+     *  Note that with %NM_STRSPLIT_SET_FLAGS_STRSTRIP, it is only
      *  necessary to escape the very last whitespace (if the delimiters
      *  are not whitespace themself). So, technically, it would be sufficient
      *  to only unescape a backslash before the last whitespace and the user
      *  still could express everything. However, such a rule would be complicated
-     *  to understand, so when using backslash escaping with nm_utils_strsplit_set_full(),
+     *  to understand, so when using backslash escaping with nm_strsplit_set_full(),
      *  then all characters (including backslash) are treated verbatim, except:
      *
      *    - "\\$DELIMITER" (escaped delimiter)
      *    - "\\\\" (escaped backslash)
-     *    - "\\$SPACE" (escaped space) (only with %NM_UTILS_STRSPLIT_SET_FLAGS_STRSTRIP).
+     *    - "\\$SPACE" (escaped space) (only with %NM_STRSPLIT_SET_FLAGS_STRSTRIP).
      *
      * Note that all other escapes like "\\n" or "\\001" are left alone.
      * That makes the escaping/unescaping rules simple. Also, for the most part
      * a text is just taken as-is, with little additional rules. Only backslashes
      * need extra care, and then only if they proceed one of the relevant characters.
      */
-    NM_UTILS_STRSPLIT_SET_FLAGS_ESCAPED = (1u << 3),
+    NM_STRSPLIT_SET_FLAGS_ESCAPED = (1u << 3),
 
 } NMUtilsStrsplitSetFlags;
 
 const char **
-nm_utils_strsplit_set_full(const char *str, const char *delimiter, NMUtilsStrsplitSetFlags flags);
+nm_strsplit_set_full(const char *str, const char *delimiter, NMUtilsStrsplitSetFlags flags);
 
 static inline const char **
-nm_utils_strsplit_set_with_empty(const char *str, const char *delimiters)
+nm_strsplit_set_with_empty(const char *str, const char *delimiters)
 {
     /* this returns the same result as g_strsplit_set(str, delimiters, -1), except
      * it does not deep-clone the strv array.
      * Also, for @str == "", this returns %NULL while g_strsplit_set() would return
      * an empty strv array. */
-    return nm_utils_strsplit_set_full(str, delimiters, NM_UTILS_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY);
+    return nm_strsplit_set_full(str, delimiters, NM_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY);
 }
 
 static inline const char **
-nm_utils_strsplit_set(const char *str, const char *delimiters)
+nm_strsplit_set(const char *str, const char *delimiters)
 {
-    return nm_utils_strsplit_set_full(str, delimiters, NM_UTILS_STRSPLIT_SET_FLAGS_NONE);
+    return nm_strsplit_set_full(str, delimiters, NM_STRSPLIT_SET_FLAGS_NONE);
 }
 
 gssize _nm_strv_find_first(const char *const *list, gssize len, const char *needle);
@@ -769,10 +769,9 @@ nm_copy_func_g_strdup(gconstpointer arg, gpointer user_data)
 static inline const char **
 nm_utils_escaped_tokens_split(const char *str, const char *delimiters)
 {
-    return nm_utils_strsplit_set_full(str,
-                                      delimiters,
-                                      NM_UTILS_STRSPLIT_SET_FLAGS_ESCAPED
-                                          | NM_UTILS_STRSPLIT_SET_FLAGS_STRSTRIP);
+    return nm_strsplit_set_full(str,
+                                delimiters,
+                                NM_STRSPLIT_SET_FLAGS_ESCAPED | NM_STRSPLIT_SET_FLAGS_STRSTRIP);
 }
 
 typedef enum {
@@ -895,10 +894,10 @@ char **nm_utils_strsplit_quoted(const char *str);
 static inline const char **
 nm_utils_escaped_tokens_options_split_list(const char *str)
 {
-    return nm_utils_strsplit_set_full(str,
-                                      ",",
-                                      NM_UTILS_STRSPLIT_SET_FLAGS_STRSTRIP
-                                          | NM_UTILS_STRSPLIT_SET_FLAGS_ALLOW_ESCAPING);
+    return nm_strsplit_set_full(str,
+                                ",",
+                                NM_STRSPLIT_SET_FLAGS_STRSTRIP
+                                    | NM_STRSPLIT_SET_FLAGS_ALLOW_ESCAPING);
 }
 
 void nm_utils_escaped_tokens_options_split(char *str, const char **out_key, const char **out_val);
diff --git a/src/libnm-log-core/nm-logging.c b/src/libnm-log-core/nm-logging.c
index 43d8285cf2..6d2c085eee 100644
--- a/src/libnm-log-core/nm-logging.c
+++ b/src/libnm-log-core/nm-logging.c
@@ -296,7 +296,7 @@ nm_logging_setup(const char *level, const char *domains, char **bad_domains, GEr
         }
     }
 
-    domains_v = nm_utils_strsplit_set(domains, ", ");
+    domains_v = nm_strsplit_set(domains, ", ");
     for (i_d = 0; domains_v && domains_v[i_d]; i_d++) {
         const char *   s = domains_v[i_d];
         const char *   p;
diff --git a/src/libnmc-base/nm-vpn-helpers.c b/src/libnmc-base/nm-vpn-helpers.c
index 4895014ece..60b5ecc471 100644
--- a/src/libnmc-base/nm-vpn-helpers.c
+++ b/src/libnmc-base/nm-vpn-helpers.c
@@ -236,7 +236,7 @@ nm_vpn_openconnect_authenticate_helper(const char *host,
      * HOST='1.2.3.4'
      * FINGERPRINT='sha1:32bac90cf09a722e10ecc1942c67fe2ac8c21e2e'
      */
-    output_v = nm_utils_strsplit_set_with_empty(output, "\r\n");
+    output_v = nm_strsplit_set_with_empty(output, "\r\n");
     for (iter = output_v; iter && *iter; iter++) {
         char *s_mutable = (char *) *iter;
 
diff --git a/src/libnmc-setting/nm-meta-setting-desc.c b/src/libnmc-setting/nm-meta-setting-desc.c
index eba9f2a105..0f2bf0e52f 100644
--- a/src/libnmc-setting/nm-meta-setting-desc.c
+++ b/src/libnmc-setting/nm-meta-setting-desc.c
@@ -191,14 +191,13 @@ _value_strsplit(const char *value, ValueStrsplitMode split_mode, gsize *out_len)
     /* note that all modes remove empty tokens (",", "a,,b", ",,"). */
     switch (split_mode) {
     case VALUE_STRSPLIT_MODE_OBJLIST:
-        strv = nm_utils_strsplit_set_full(value,
-                                          ESCAPED_TOKENS_DELIMITERS,
-                                          NM_UTILS_STRSPLIT_SET_FLAGS_STRSTRIP);
+        strv =
+            nm_strsplit_set_full(value, ESCAPED_TOKENS_DELIMITERS, NM_STRSPLIT_SET_FLAGS_STRSTRIP);
         break;
     case VALUE_STRSPLIT_MODE_MULTILIST:
-        strv = nm_utils_strsplit_set_full(value,
-                                          ESCAPED_TOKENS_WITH_SPACES_DELIMTERS,
-                                          NM_UTILS_STRSPLIT_SET_FLAGS_STRSTRIP);
+        strv = nm_strsplit_set_full(value,
+                                    ESCAPED_TOKENS_WITH_SPACES_DELIMTERS,
+                                    NM_STRSPLIT_SET_FLAGS_STRSTRIP);
         break;
     case VALUE_STRSPLIT_MODE_ESCAPED_TOKENS:
         strv = nm_utils_escaped_tokens_split(value, ESCAPED_TOKENS_DELIMITERS);
@@ -309,7 +308,7 @@ _parse_ip_route(int family, const char *str, GError **error)
     nm_assert(!error || !*error);
 
     str_clean = nm_strstrip_avoid_copy_a(300, str, &str_clean_free);
-    routev    = nm_utils_strsplit_set(str_clean, " \t");
+    routev    = nm_strsplit_set(str_clean, " \t");
     if (!routev) {
         g_set_error(error, 1, 0, "'%s' is not valid. %s", str, ROUTE_SYNTAX);
         return NULL;
@@ -2271,7 +2270,7 @@ static gboolean _set_fcn_gobject_bytes(ARGS_SET_FCN)
     }
 
     /* Otherwise, consider the following format: AA b 0xCc D */
-    strv  = nm_utils_strsplit_set(value, " \t");
+    strv  = nm_strsplit_set(value, " \t");
     array = g_byte_array_sized_new(NM_PTRARRAY_LEN(strv));
     for (iter = strv; iter && *iter; iter++) {
         int    v;
@@ -2916,7 +2915,7 @@ static gboolean _set_fcn_dcb_flags(ARGS_SET_FCN)
         const char *const *  iter;
 
         /* Check for individual flag numbers */
-        strv = nm_utils_strsplit_set(value, " \t,");
+        strv = nm_strsplit_set(value, " \t,");
         for (iter = strv; iter && *iter; iter++) {
             t = _nm_utils_ascii_str_to_int64(*iter, 0, 0, DCB_ALL_FLAGS, -1);
 
@@ -2957,7 +2956,7 @@ dcb_parse_uint_array(const char *val,
     const char *const *  iter;
     gsize                i;
 
-    items = nm_utils_strsplit_set_with_empty(val, ",");
+    items = nm_strsplit_set_with_empty(val, ",");
     if (NM_PTRARRAY_LEN(items) != 8) {
         g_set_error_literal(error, 1, 0, _("must contain 8 comma-separated numbers"));
         return FALSE;
@@ -4033,7 +4032,7 @@ static gboolean _set_fcn_wired_s390_subchannels(ARGS_SET_FCN)
     if (_SET_FCN_DO_RESET_DEFAULT(property_info, modifier, value))
         return _gobject_property_reset_default(setting, property_info->property_name);
 
-    strv = nm_utils_strsplit_set(value, " ,\t");
+    strv = nm_strsplit_set(value, " ,\t");
     len  = NM_PTRARRAY_LEN(strv);
     if (len != 2 && len != 3) {
         g_set_error(error, 1, 0, _("'%s' is not valid; 2 or 3 strings should be provided"), value);
diff --git a/src/libnmt-newt/nmt-newt-utils.c b/src/libnmt-newt/nmt-newt-utils.c
index 480c819421..99bde74795 100644
--- a/src/libnmt-newt/nmt-newt-utils.c
+++ b/src/libnmt-newt/nmt-newt-utils.c
@@ -124,7 +124,7 @@ nmt_newt_parse_colors(const char *s, bool is_newt)
     gs_free const char **lines = NULL;
     size_t               i;
 
-    lines = nm_utils_strsplit_set(s, ";:\n\r\t ");
+    lines = nm_strsplit_set(s, ";:\n\r\t ");
 
     if (!lines)
         return;
diff --git a/src/nm-cloud-setup/nmcs-provider-aliyun.c b/src/nm-cloud-setup/nmcs-provider-aliyun.c
index b430b452d0..e6c7624f92 100644
--- a/src/nm-cloud-setup/nmcs-provider-aliyun.c
+++ b/src/nm-cloud-setup/nmcs-provider-aliyun.c
@@ -159,9 +159,9 @@ _get_config_fetch_done_cb(NMHttpClient *         http_client,
     switch (fetch_type) {
     case GET_CONFIG_FETCH_DONE_TYPE_PRIVATE_IPV4S:
 
-        s_addrs = nm_utils_strsplit_set_full(g_bytes_get_data(response, NULL),
-                                             ",",
-                                             NM_UTILS_STRSPLIT_SET_FLAGS_STRSTRIP);
+        s_addrs = nm_strsplit_set_full(g_bytes_get_data(response, NULL),
+                                       ",",
+                                       NM_STRSPLIT_SET_FLAGS_STRSTRIP);
         len     = NM_PTRARRAY_LEN(s_addrs);
         nm_assert(!config_iface_data->has_ipv4s);
         nm_assert(!config_iface_data->ipv4s_arr);
diff --git a/src/nm-cloud-setup/nmcs-provider-ec2.c b/src/nm-cloud-setup/nmcs-provider-ec2.c
index 6f83238d68..970aa6dc61 100644
--- a/src/nm-cloud-setup/nmcs-provider-ec2.c
+++ b/src/nm-cloud-setup/nmcs-provider-ec2.c
@@ -145,9 +145,9 @@ _get_config_fetch_done_cb(NMHttpClient *http_client,
         gs_free const char **s_addrs = NULL;
         gsize                i, len;
 
-        s_addrs = nm_utils_strsplit_set_full(g_bytes_get_data(response, NULL),
-                                             "\n",
-                                             NM_UTILS_STRSPLIT_SET_FLAGS_STRSTRIP);
+        s_addrs = nm_strsplit_set_full(g_bytes_get_data(response, NULL),
+                                       "\n",
+                                       NM_STRSPLIT_SET_FLAGS_STRSTRIP);
         len     = NM_PTRARRAY_LEN(s_addrs);
 
         nm_assert(!config_iface_data->has_ipv4s);
diff --git a/src/nm-dispatcher/tests/test-dispatcher-envp.c b/src/nm-dispatcher/tests/test-dispatcher-envp.c
index 297cfbbdc9..8a24c426db 100644
--- a/src/nm-dispatcher/tests/test-dispatcher-envp.c
+++ b/src/nm-dispatcher/tests/test-dispatcher-envp.c
@@ -159,7 +159,7 @@ add_uint_array(GKeyFile *       kf,
     if (tmp == NULL)
         return TRUE;
 
-    split = nm_utils_strsplit_set_with_empty(tmp, " ");
+    split = nm_strsplit_set_with_empty(tmp, " ");
     if (split) {
         gs_unref_array GArray *items = NULL;
 
@@ -229,7 +229,7 @@ parse_ip4(GKeyFile *kf, GVariant **out_props, const char *section, GError **erro
     tmp = g_key_file_get_string(kf, section, "domains", error);
     if (tmp == NULL)
         return FALSE;
-    split = nm_utils_strsplit_set_with_empty(tmp, " ");
+    split = nm_strsplit_set_with_empty(tmp, " ");
     if (split) {
         for (iter = split; *iter; iter++)
             g_strstrip((char *) *iter);
@@ -247,7 +247,7 @@ parse_ip4(GKeyFile *kf, GVariant **out_props, const char *section, GError **erro
     tmp = g_key_file_get_string(kf, section, "addresses", error);
     if (tmp == NULL)
         return FALSE;
-    split = nm_utils_strsplit_set_with_empty(tmp, ",");
+    split = nm_strsplit_set_with_empty(tmp, ",");
     if (split) {
         gs_unref_ptrarray GPtrArray *addresses = NULL;
         const char *                 gateway   = NULL;
@@ -291,7 +291,7 @@ parse_ip4(GKeyFile *kf, GVariant **out_props, const char *section, GError **erro
 
     nm_clear_g_free(&tmp);
     tmp   = g_key_file_get_string(kf, section, "routes", NULL);
-    split = nm_utils_strsplit_set_with_empty(tmp, ",");
+    split = nm_strsplit_set_with_empty(tmp, ",");
     if (split) {
         gs_unref_ptrarray GPtrArray *routes = NULL;
 
diff --git a/src/nm-initrd-generator/nmi-cmdline-reader.c b/src/nm-initrd-generator/nmi-cmdline-reader.c
index cb6e189a9e..8f163f1c7a 100644
--- a/src/nm-initrd-generator/nmi-cmdline-reader.c
+++ b/src/nm-initrd-generator/nmi-cmdline-reader.c
@@ -461,7 +461,7 @@ _parse_ip_method(const char *kind)
 
     /* dracut also supports combinations, separated by comma. We don't
      * support arbitrary combinations, but accept specific subsets. */
-    strv = nm_utils_strsplit_set_full(kind, ",", NM_UTILS_STRSPLIT_SET_FLAGS_STRSTRIP);
+    strv = nm_strsplit_set_full(kind, ",", NM_STRSPLIT_SET_FLAGS_STRSTRIP);
     if (!strv)
         return NULL;
 
diff --git a/src/nmcli/connections.c b/src/nmcli/connections.c
index 44e1657518..10bc224c19 100644
--- a/src/nmcli/connections.c
+++ b/src/nmcli/connections.c
@@ -1666,7 +1666,7 @@ split_required_fields_for_con_show(const char *input,
     str1 = g_string_new(NULL);
     str2 = g_string_new(NULL);
 
-    fields = nm_utils_strsplit_set_with_empty(input, ",");
+    fields = nm_strsplit_set_with_empty(input, ",");
     for (iter = fields; iter && *iter; iter++) {
         char *   s_mutable = (char *) (*iter);
         char *   dot;
@@ -2007,7 +2007,7 @@ parse_preferred_connection_order(const char *order, GError **error)
     gboolean             inverse, unique;
     guint                i;
 
-    strv = nm_utils_strsplit_set(order, ":");
+    strv = nm_strsplit_set(order, ":");
     if (!strv) {
         g_set_error(error, NMCLI_ERROR, 0, _("incorrect string '%s' of '--order' option"), order);
         return NULL;
diff --git a/src/nmcli/settings.c b/src/nmcli/settings.c
index 6c93c021f1..f496640087 100644
--- a/src/nmcli/settings.c
+++ b/src/nmcli/settings.c
@@ -362,7 +362,7 @@ _set_fcn_precheck_connection_secondaries(NMClient *  client,
     char **              iter;
     gboolean             modified = FALSE;
 
-    strv0 = nm_utils_strsplit_set(value, " \t,");
+    strv0 = nm_strsplit_set(value, " \t,");
     if (!strv0)
         return TRUE;
 
diff --git a/src/nmcli/utils.c b/src/nmcli/utils.c
index 6dd93f7b22..85768c1908 100644
--- a/src/nmcli/utils.c
+++ b/src/nmcli/utils.c
@@ -495,7 +495,7 @@ nmc_string_to_arg_array(const char *line,
     gs_free const char **arr0 = NULL;
     char **              arr;
 
-    arr0 = nm_utils_strsplit_set(line ?: "", delim ?: " \t");
+    arr0 = nm_strsplit_set(line ?: "", delim ?: " \t");
     if (!arr0)
         arr = g_new0(char *, 1);
     else