// SPDX-License-Identifier: GPL-2.0+ /* NetworkManager -- Network link manager * * Copyright 2004 - 2016 Red Hat, Inc. * Copyright 2005 - 2008 Novell, Inc. */ #include "nm-default.h" #include "NetworkManagerUtils.h" #include #include "nm-glib-aux/nm-c-list.h" #include "nm-libnm-core-intern/nm-common-macros.h" #include "nm-utils.h" #include "nm-setting-connection.h" #include "nm-setting-ip4-config.h" #include "nm-setting-ip6-config.h" #include "nm-core-internal.h" #include "platform/nm-platform.h" #include "nm-auth-utils.h" #include "systemd/nm-sd-utils-shared.h" /*****************************************************************************/ /** * nm_utils_get_shared_wifi_permission: * @connection: the NMConnection to lookup the permission. * * Returns: a static string of the wifi-permission (if any) or %NULL. */ const char * nm_utils_get_shared_wifi_permission (NMConnection *connection) { NMSettingWireless *s_wifi; NMSettingWirelessSecurity *s_wsec; const char *method; method = nm_utils_get_ip_config_method (connection, AF_INET); if (!nm_streq (method, NM_SETTING_IP4_CONFIG_METHOD_SHARED)) return NULL; s_wifi = nm_connection_get_setting_wireless (connection); if (s_wifi) { s_wsec = nm_connection_get_setting_wireless_security (connection); if (s_wsec) return NM_AUTH_PERMISSION_WIFI_SHARE_PROTECTED; else return NM_AUTH_PERMISSION_WIFI_SHARE_OPEN; } return NULL; } /*****************************************************************************/ static char * get_new_connection_name (NMConnection *const*existing_connections, const char *preferred, const char *fallback_prefix) { gs_free const char **existing_names = NULL; guint i, existing_len = 0; g_assert (fallback_prefix); if (existing_connections) { existing_len = NM_PTRARRAY_LEN (existing_connections); existing_names = g_new (const char *, existing_len); for (i = 0; i < existing_len; i++) { NMConnection *candidate; const char *id; candidate = existing_connections[i]; nm_assert (NM_IS_CONNECTION (candidate)); id = nm_connection_get_id (candidate); nm_assert (id); existing_names[i] = id; if ( preferred && nm_streq (preferred, id)) { /* the preferred name is already taken. Forget about it. */ preferred = NULL; } } nm_assert (!existing_connections[i]); } /* Return the preferred name if it was unique */ if (preferred) return g_strdup (preferred); /* Otherwise find the next available unique connection name using the given * connection name template. */ for (i = 1; TRUE; i++) { char *temp; /* TRANSLATORS: the first %s is a prefix for the connection id, such * as "Wired Connection" or "VPN Connection". The %d is a number * that is combined with the first argument to create a unique * connection id. */ temp = g_strdup_printf (C_("connection id fallback", "%s %u"), fallback_prefix, i); if (nm_utils_strv_find_first ((char **) existing_names, existing_len, temp) < 0) return temp; g_free (temp); } } static char * get_new_connection_ifname (NMPlatform *platform, NMConnection *const*existing_connections, const char *prefix) { guint i, j; for (i = 0; TRUE; i++) { char *name; name = g_strdup_printf ("%s%d", prefix, i); if (nm_platform_link_get_by_ifname (platform, name)) goto next; if (existing_connections) { for (j = 0; existing_connections[j]; j++) { if (nm_streq0 (nm_connection_get_interface_name (existing_connections[j]), name)) goto next; } } return name; next: g_free (name); } } const char * nm_utils_get_ip_config_method (NMConnection *connection, int addr_family) { NMSettingConnection *s_con; NMSettingIPConfig *s_ip; const char *method; s_con = nm_connection_get_setting_connection (connection); if (addr_family == AF_INET) { g_return_val_if_fail (s_con != NULL, NM_SETTING_IP4_CONFIG_METHOD_AUTO); s_ip = nm_connection_get_setting_ip4_config (connection); if (!s_ip) return NM_SETTING_IP4_CONFIG_METHOD_DISABLED; method = nm_setting_ip_config_get_method (s_ip); g_return_val_if_fail (method != NULL, NM_SETTING_IP4_CONFIG_METHOD_AUTO); return method; } if (addr_family == AF_INET6) { g_return_val_if_fail (s_con != NULL, NM_SETTING_IP6_CONFIG_METHOD_AUTO); s_ip = nm_connection_get_setting_ip6_config (connection); if (!s_ip) return NM_SETTING_IP6_CONFIG_METHOD_IGNORE; method = nm_setting_ip_config_get_method (s_ip); g_return_val_if_fail (method != NULL, NM_SETTING_IP6_CONFIG_METHOD_AUTO); return method; } g_return_val_if_reached ("" /* bogus */); } gboolean nm_utils_connection_has_default_route (NMConnection *connection, int addr_family, gboolean *out_is_never_default) { const char *method; NMSettingIPConfig *s_ip; gboolean is_never_default = FALSE; gboolean has_default_route = FALSE; g_return_val_if_fail (NM_IS_CONNECTION (connection), FALSE); g_return_val_if_fail (NM_IN_SET (addr_family, AF_INET, AF_INET6), FALSE); if (!connection) goto out; s_ip = nm_connection_get_setting_ip_config (connection, addr_family); if (!s_ip) goto out; if (nm_setting_ip_config_get_never_default (s_ip)) { is_never_default = TRUE; goto out; } method = nm_utils_get_ip_config_method (connection, addr_family); if (addr_family == AF_INET) { if (NM_IN_STRSET (method, NM_SETTING_IP4_CONFIG_METHOD_DISABLED, NM_SETTING_IP4_CONFIG_METHOD_LINK_LOCAL)) goto out; } else { if (NM_IN_STRSET (method, NM_SETTING_IP6_CONFIG_METHOD_IGNORE, NM_SETTING_IP6_CONFIG_METHOD_DISABLED, NM_SETTING_IP6_CONFIG_METHOD_LINK_LOCAL)) goto out; } has_default_route = TRUE; out: NM_SET_OUT (out_is_never_default, is_never_default); return has_default_route; } /*****************************************************************************/ void nm_utils_complete_generic (NMPlatform *platform, NMConnection *connection, const char *ctype, NMConnection *const*existing_connections, const char *preferred_id, const char *fallback_id_prefix, const char *ifname_prefix, const char *ifname, gboolean default_enable_ipv6) { NMSettingConnection *s_con; char *id, *generated_ifname; GHashTable *parameters; g_assert (fallback_id_prefix); g_return_if_fail (ifname_prefix == NULL || ifname == NULL); s_con = nm_connection_get_setting_connection (connection); if (!s_con) { s_con = (NMSettingConnection *) nm_setting_connection_new (); nm_connection_add_setting (connection, NM_SETTING (s_con)); } g_object_set (G_OBJECT (s_con), NM_SETTING_CONNECTION_TYPE, ctype, NULL); if (!nm_setting_connection_get_uuid (s_con)) { char uuid[37]; g_object_set (G_OBJECT (s_con), NM_SETTING_CONNECTION_UUID, nm_utils_uuid_generate_buf (uuid), NULL); } /* Add a connection ID if absent */ if (!nm_setting_connection_get_id (s_con)) { id = get_new_connection_name (existing_connections, preferred_id, fallback_id_prefix); g_object_set (G_OBJECT (s_con), NM_SETTING_CONNECTION_ID, id, NULL); g_free (id); } /* Add an interface name, if requested */ if (ifname) { g_object_set (G_OBJECT (s_con), NM_SETTING_CONNECTION_INTERFACE_NAME, ifname, NULL); } else if (ifname_prefix && !nm_setting_connection_get_interface_name (s_con)) { generated_ifname = get_new_connection_ifname (platform, existing_connections, ifname_prefix); g_object_set (G_OBJECT (s_con), NM_SETTING_CONNECTION_INTERFACE_NAME, generated_ifname, NULL); g_free (generated_ifname); } /* Normalize */ parameters = g_hash_table_new (nm_str_hash, g_str_equal); g_hash_table_insert (parameters, NM_CONNECTION_NORMALIZE_PARAM_IP6_CONFIG_METHOD, default_enable_ipv6 ? NM_SETTING_IP6_CONFIG_METHOD_AUTO : NM_SETTING_IP6_CONFIG_METHOD_IGNORE); nm_connection_normalize (connection, parameters, NULL, NULL); g_hash_table_destroy (parameters); } /*****************************************************************************/ static GHashTable * check_property_in_hash (GHashTable *hash, const char *s_name, const char *p_name) { GHashTable *props; props = g_hash_table_lookup (hash, s_name); if ( !props || !g_hash_table_lookup (props, p_name)) { return NULL; } return props; } static void remove_from_hash (GHashTable *s_hash, GHashTable *p_hash, const char *s_name, const char *p_name) { if (!p_hash) return; g_hash_table_remove (p_hash, p_name); if (g_hash_table_size (p_hash) == 0) g_hash_table_remove (s_hash, s_name); } static gboolean check_ip6_method (NMConnection *orig, NMConnection *candidate, GHashTable *settings) { GHashTable *props; const char *orig_ip6_method, *candidate_ip6_method; NMSettingIPConfig *candidate_ip6; gboolean allow = FALSE; props = check_property_in_hash (settings, NM_SETTING_IP6_CONFIG_SETTING_NAME, NM_SETTING_IP_CONFIG_METHOD); if (!props) return TRUE; orig_ip6_method = nm_utils_get_ip_config_method (orig, AF_INET6); candidate_ip6_method = nm_utils_get_ip_config_method (candidate, AF_INET6); candidate_ip6 = nm_connection_get_setting_ip6_config (candidate); if ( nm_streq (orig_ip6_method, NM_SETTING_IP6_CONFIG_METHOD_LINK_LOCAL) && nm_streq (candidate_ip6_method, NM_SETTING_IP6_CONFIG_METHOD_AUTO) && ( !candidate_ip6 || nm_setting_ip_config_get_may_fail (candidate_ip6))) { /* If the generated connection is 'link-local' and the candidate is both 'auto' * and may-fail=TRUE, then the candidate is OK to use. may-fail is included * in the decision because if the candidate is 'auto' but may-fail=FALSE, then * the connection could not possibly have been previously activated on the * device if the device has no non-link-local IPv6 address. */ allow = TRUE; } else if ( NM_IN_STRSET (orig_ip6_method, NM_SETTING_IP6_CONFIG_METHOD_LINK_LOCAL, NM_SETTING_IP6_CONFIG_METHOD_AUTO) && nm_streq0 (candidate_ip6_method, NM_SETTING_IP6_CONFIG_METHOD_IGNORE)) { /* If the generated connection method is 'link-local' or 'auto' and the candidate * method is 'ignore' we can take the connection, because NM didn't simply take care * of IPv6. */ allow = TRUE; } if (allow) { remove_from_hash (settings, props, NM_SETTING_IP6_CONFIG_SETTING_NAME, NM_SETTING_IP_CONFIG_METHOD); } return allow; } static int route_compare (NMIPRoute *route1, NMIPRoute *route2, gint64 default_metric) { NMIPAddr a1; NMIPAddr a2; guint64 m1; guint64 m2; int family; guint plen; family = nm_ip_route_get_family (route1); NM_CMP_DIRECT (family, nm_ip_route_get_family (route2)); nm_assert_addr_family (family); plen = nm_ip_route_get_prefix (route1); NM_CMP_DIRECT (plen, nm_ip_route_get_prefix (route2)); m1 = nm_ip_route_get_metric (route1); m2 = nm_ip_route_get_metric (route2); NM_CMP_DIRECT (m1 == -1 ? default_metric : m1, m2 == -1 ? default_metric : m2); NM_CMP_DIRECT_STRCMP0 (nm_ip_route_get_next_hop (route1), nm_ip_route_get_next_hop (route2)); if (!inet_pton (family, nm_ip_route_get_dest (route1), &a1)) nm_assert_not_reached (); if (!inet_pton (family, nm_ip_route_get_dest (route2), &a2)) nm_assert_not_reached (); nm_utils_ipx_address_clear_host_address (family, &a1, NULL, plen); nm_utils_ipx_address_clear_host_address (family, &a2, NULL, plen); NM_CMP_DIRECT_MEMCMP (&a1, &a2, nm_utils_addr_family_to_size (family)); return 0; } static int route_ptr_compare (const void *a, const void *b, gpointer metric) { return route_compare (*(NMIPRoute **) a, *(NMIPRoute **) b, *((gint64 *) metric)); } static gboolean check_ip_routes (NMConnection *orig, NMConnection *candidate, GHashTable *settings, gint64 default_metric, gboolean v4) { gs_free NMIPRoute **routes1 = NULL; NMIPRoute **routes2; NMSettingIPConfig *s_ip1, *s_ip2; gint64 m; const char *s_name; GHashTable *props; guint i, i1, i2, num1, num2; const guint8 PLEN = v4 ? 32 : 128; s_name = v4 ? NM_SETTING_IP4_CONFIG_SETTING_NAME : NM_SETTING_IP6_CONFIG_SETTING_NAME; props = check_property_in_hash (settings, s_name, NM_SETTING_IP_CONFIG_ROUTES); if (!props) return TRUE; s_ip1 = (NMSettingIPConfig *) nm_connection_get_setting_by_name (orig, s_name); s_ip2 = (NMSettingIPConfig *) nm_connection_get_setting_by_name (candidate, s_name); if (!s_ip1 || !s_ip2) return FALSE; num1 = nm_setting_ip_config_get_num_routes (s_ip1); num2 = nm_setting_ip_config_get_num_routes (s_ip2); routes1 = g_new (NMIPRoute *, (gsize) num1 + num2); routes2 = &routes1[num1]; for (i = 0; i < num1; i++) routes1[i] = nm_setting_ip_config_get_route (s_ip1, i); for (i = 0; i < num2; i++) routes2[i] = nm_setting_ip_config_get_route (s_ip2, i); m = nm_setting_ip_config_get_route_metric (s_ip2); if (m != -1) default_metric = m; g_qsort_with_data (routes1, num1, sizeof (NMIPRoute *), route_ptr_compare, &default_metric); g_qsort_with_data (routes2, num2, sizeof (NMIPRoute *), route_ptr_compare, &default_metric); for (i1 = 0, i2 = 0; i2 < num2; i1++) { if (i1 >= num1) return FALSE; if (route_compare (routes1[i1], routes2[i2], default_metric) == 0) { i2++; continue; } /* if @orig (@routes1) contains /32 routes that are missing in @candidate, * we accept that. * * A /32 may have been added automatically, as a direct-route to the gateway. * The generated connection (@orig) would contain that route, so we shall ignore * it. * * Likeweise for /128 for IPv6. */ if (nm_ip_route_get_prefix (routes1[i1]) == PLEN) continue; return FALSE; } /* check that @orig has no left-over (except host routes that we ignore). */ for (; i1 < num1; i1++) { if (nm_ip_route_get_prefix (routes1[i1]) != PLEN) return FALSE; } remove_from_hash (settings, props, s_name, NM_SETTING_IP_CONFIG_ROUTES); return TRUE; } static gboolean check_ip4_method (NMConnection *orig, NMConnection *candidate, GHashTable *settings, gboolean device_has_carrier) { GHashTable *props; const char *orig_ip4_method, *candidate_ip4_method; NMSettingIPConfig *candidate_ip4; props = check_property_in_hash (settings, NM_SETTING_IP4_CONFIG_SETTING_NAME, NM_SETTING_IP_CONFIG_METHOD); if (!props) return TRUE; orig_ip4_method = nm_utils_get_ip_config_method (orig, AF_INET); candidate_ip4_method = nm_utils_get_ip_config_method (candidate, AF_INET); candidate_ip4 = nm_connection_get_setting_ip4_config (candidate); if ( nm_streq (orig_ip4_method, NM_SETTING_IP4_CONFIG_METHOD_DISABLED) && nm_streq (candidate_ip4_method, NM_SETTING_IP4_CONFIG_METHOD_AUTO) && ( !candidate_ip4 || nm_setting_ip_config_get_may_fail (candidate_ip4)) && !device_has_carrier) { /* If the generated connection is 'disabled' (device had no IP addresses) * but it has no carrier, that most likely means that IP addressing could * not complete and thus no IP addresses were assigned. In that case, allow * matching to the "auto" method. */ remove_from_hash (settings, props, NM_SETTING_IP4_CONFIG_SETTING_NAME, NM_SETTING_IP_CONFIG_METHOD); return TRUE; } return FALSE; } static gboolean check_connection_interface_name (NMConnection *orig, NMConnection *candidate, GHashTable *settings) { GHashTable *props; const char *orig_ifname, *cand_ifname; NMSettingConnection *s_con_orig, *s_con_cand; props = check_property_in_hash (settings, NM_SETTING_CONNECTION_SETTING_NAME, NM_SETTING_CONNECTION_INTERFACE_NAME); if (!props) return TRUE; /* If one of the interface names is NULL, we accept that connection */ s_con_orig = nm_connection_get_setting_connection (orig); s_con_cand = nm_connection_get_setting_connection (candidate); orig_ifname = nm_setting_connection_get_interface_name (s_con_orig); cand_ifname = nm_setting_connection_get_interface_name (s_con_cand); if (!orig_ifname || !cand_ifname) { remove_from_hash (settings, props, NM_SETTING_CONNECTION_SETTING_NAME, NM_SETTING_CONNECTION_INTERFACE_NAME); return TRUE; } return FALSE; } static gboolean check_connection_mac_address (NMConnection *orig, NMConnection *candidate, GHashTable *settings) { GHashTable *props; const char *orig_mac = NULL, *cand_mac = NULL; NMSettingWired *s_wired_orig, *s_wired_cand; props = check_property_in_hash (settings, NM_SETTING_WIRED_SETTING_NAME, NM_SETTING_WIRED_MAC_ADDRESS); if (!props) return TRUE; /* If one of the MAC addresses is NULL, we accept that connection */ s_wired_orig = nm_connection_get_setting_wired (orig); if (s_wired_orig) orig_mac = nm_setting_wired_get_mac_address (s_wired_orig); s_wired_cand = nm_connection_get_setting_wired (candidate); if (s_wired_cand) cand_mac = nm_setting_wired_get_mac_address (s_wired_cand); if (!orig_mac || !cand_mac) { remove_from_hash (settings, props, NM_SETTING_WIRED_SETTING_NAME, NM_SETTING_WIRED_MAC_ADDRESS); return TRUE; } return FALSE; } static gboolean check_connection_infiniband_mac_address (NMConnection *orig, NMConnection *candidate, GHashTable *settings) { GHashTable *props; const char *orig_mac = NULL, *cand_mac = NULL; NMSettingInfiniband *s_infiniband_orig, *s_infiniband_cand; props = check_property_in_hash (settings, NM_SETTING_INFINIBAND_SETTING_NAME, NM_SETTING_INFINIBAND_MAC_ADDRESS); if (!props) return TRUE; /* If one of the MAC addresses is NULL, we accept that connection */ s_infiniband_orig = nm_connection_get_setting_infiniband (orig); if (s_infiniband_orig) orig_mac = nm_setting_infiniband_get_mac_address (s_infiniband_orig); s_infiniband_cand = nm_connection_get_setting_infiniband (candidate); if (s_infiniband_cand) cand_mac = nm_setting_infiniband_get_mac_address (s_infiniband_cand); if (!orig_mac || !cand_mac) { remove_from_hash (settings, props, NM_SETTING_INFINIBAND_SETTING_NAME, NM_SETTING_INFINIBAND_MAC_ADDRESS); return TRUE; } return FALSE; } static gboolean check_connection_cloned_mac_address (NMConnection *orig, NMConnection *candidate, GHashTable *settings) { GHashTable *props; const char *orig_mac = NULL, *cand_mac = NULL; NMSettingWired *s_wired_orig, *s_wired_cand; props = check_property_in_hash (settings, NM_SETTING_WIRED_SETTING_NAME, NM_SETTING_WIRED_CLONED_MAC_ADDRESS); if (!props) return TRUE; /* If one of the MAC addresses is NULL, we accept that connection */ s_wired_orig = nm_connection_get_setting_wired (orig); if (s_wired_orig) orig_mac = nm_setting_wired_get_cloned_mac_address (s_wired_orig); s_wired_cand = nm_connection_get_setting_wired (candidate); if (s_wired_cand) cand_mac = nm_setting_wired_get_cloned_mac_address (s_wired_cand); /* special cloned mac address entries are accepted. */ if (NM_CLONED_MAC_IS_SPECIAL (orig_mac)) orig_mac = NULL; if (NM_CLONED_MAC_IS_SPECIAL (cand_mac)) cand_mac = NULL; if (!orig_mac || !cand_mac) { remove_from_hash (settings, props, NM_SETTING_WIRED_SETTING_NAME, NM_SETTING_WIRED_CLONED_MAC_ADDRESS); return TRUE; } return FALSE; } static gboolean check_connection_s390_props (NMConnection *orig, NMConnection *candidate, GHashTable *settings) { GHashTable *props1, *props2, *props3; NMSettingWired *s_wired_orig, *s_wired_cand; props1 = check_property_in_hash (settings, NM_SETTING_WIRED_SETTING_NAME, NM_SETTING_WIRED_S390_SUBCHANNELS); props2 = check_property_in_hash (settings, NM_SETTING_WIRED_SETTING_NAME, NM_SETTING_WIRED_S390_NETTYPE); props3 = check_property_in_hash (settings, NM_SETTING_WIRED_SETTING_NAME, NM_SETTING_WIRED_S390_OPTIONS); if (!props1 && !props2 && !props3) return TRUE; /* If the generated connection did not contain wired setting, * allow it to match to a connection with a wired setting, * but default (empty) s390-* properties */ s_wired_orig = nm_connection_get_setting_wired (orig); s_wired_cand = nm_connection_get_setting_wired (candidate); if (!s_wired_orig && s_wired_cand) { const char * const *subchans = nm_setting_wired_get_s390_subchannels (s_wired_cand); const char *nettype = nm_setting_wired_get_s390_nettype (s_wired_cand); guint32 num_options = nm_setting_wired_get_num_s390_options (s_wired_cand); if ((!subchans || !*subchans) && !nettype && num_options == 0) { remove_from_hash (settings, props1, NM_SETTING_WIRED_SETTING_NAME, NM_SETTING_WIRED_S390_SUBCHANNELS); remove_from_hash (settings, props2, NM_SETTING_WIRED_SETTING_NAME, NM_SETTING_WIRED_S390_NETTYPE); remove_from_hash (settings, props3, NM_SETTING_WIRED_SETTING_NAME, NM_SETTING_WIRED_S390_OPTIONS); return TRUE; } } return FALSE; } static NMConnection * check_possible_match (NMConnection *orig, NMConnection *candidate, GHashTable *settings, gboolean device_has_carrier, gint64 default_v4_metric, gint64 default_v6_metric) { g_return_val_if_fail (settings != NULL, NULL); if (!check_ip6_method (orig, candidate, settings)) return NULL; if (!check_ip4_method (orig, candidate, settings, device_has_carrier)) return NULL; if (!check_ip_routes (orig, candidate, settings, default_v4_metric, TRUE)) return NULL; if (!check_ip_routes (orig, candidate, settings, default_v6_metric, FALSE)) return NULL; if (!check_connection_interface_name (orig, candidate, settings)) return NULL; if (!check_connection_mac_address (orig, candidate, settings)) return NULL; if (!check_connection_infiniband_mac_address (orig, candidate, settings)) return NULL; if (!check_connection_cloned_mac_address (orig, candidate, settings)) return NULL; if (!check_connection_s390_props (orig, candidate, settings)) return NULL; if (g_hash_table_size (settings) == 0) return candidate; else return NULL; } /** * nm_utils_match_connection: * @connections: a (optionally pre-sorted) list of connections from which to * find a matching connection to @original based on "inferrable" properties * @original: the #NMConnection to find a match for from @connections * @indicated: whether the match is already hinted/indicated. That is the * case when we found the connection in the state file from a previous run. * In this case, we perform a relexed check, as we have a good hint * that the connection actually matches. * @device_has_carrier: pass %TRUE if the device that generated @original has * a carrier, %FALSE if not * @match_filter_func: a function to check whether each connection from @connections * should be considered for matching. This function should return %TRUE if the * connection should be considered, %FALSE if the connection should be ignored * @match_compat_data: data pointer passed to @match_filter_func * * Checks each connection from @connections until a matching connection is found * considering only setting properties marked with %NM_SETTING_PARAM_INFERRABLE * and checking a few other characteristics like IPv6 method. If the caller * desires some priority order of the connections, @connections should be * sorted before calling this function. * * Returns: the best #NMConnection matching @original, or %NULL if no connection * matches well enough. */ NMConnection * nm_utils_match_connection (NMConnection *const*connections, NMConnection *original, gboolean indicated, gboolean device_has_carrier, gint64 default_v4_metric, gint64 default_v6_metric, NMUtilsMatchFilterFunc match_filter_func, gpointer match_filter_data) { NMConnection *best_match = NULL; if (!connections) return NULL; for (; *connections; connections++) { NMConnection *candidate = *connections; GHashTable *diffs = NULL; nm_assert (NM_IS_CONNECTION (candidate)); if (match_filter_func) { if (!match_filter_func (candidate, match_filter_data)) continue; } if (indicated) { NMSettingConnection *s_orig, *s_cand; s_orig = nm_connection_get_setting_connection (original); s_cand = nm_connection_get_setting_connection (candidate); /* It is indicated that this connection matches. Assume we have * a match, but check for particular differences that let us * reject the candidate. */ if (!nm_streq0 (nm_setting_connection_get_connection_type (s_orig), nm_setting_connection_get_connection_type (s_cand))) continue; if (!nm_streq0 (nm_setting_connection_get_slave_type (s_orig), nm_setting_connection_get_slave_type (s_cand))) continue; /* this is good enough for a match */ } else if (!nm_connection_diff (original, candidate, NM_SETTING_COMPARE_FLAG_INFERRABLE, &diffs)) { if (!best_match) { best_match = check_possible_match (original, candidate, diffs, device_has_carrier, default_v4_metric, default_v6_metric); } if (!best_match && nm_logging_enabled (LOGL_DEBUG, LOGD_CORE)) { GString *diff_string; GHashTableIter s_iter, p_iter; gpointer setting_name, setting; gpointer property_name, value; diff_string = g_string_new (NULL); g_hash_table_iter_init (&s_iter, diffs); while (g_hash_table_iter_next (&s_iter, &setting_name, &setting)) { g_hash_table_iter_init (&p_iter, setting); while (g_hash_table_iter_next (&p_iter, &property_name, &value)) { if (diff_string->len) g_string_append (diff_string, ", "); g_string_append_printf (diff_string, "%s.%s", (char *) setting_name, (char *) property_name); } } nm_log_dbg (LOGD_CORE, "Connection '%s' differs from candidate '%s' in %s", nm_connection_get_id (original), nm_connection_get_id (candidate), diff_string->str); g_string_free (diff_string, TRUE); } g_hash_table_unref (diffs); continue; } /* Exact match */ return candidate; } /* Best match (if any) */ return best_match; } /*****************************************************************************/ int nm_match_spec_device_by_pllink (const NMPlatformLink *pllink, const char *match_device_type, const char *match_dhcp_plugin, const GSList *specs, int no_match_value) { NMMatchSpecMatchType m; /* we can only match by certain properties that are available on the * platform link (and even @pllink might be missing. * * It's still useful because of specs like "*" and "except:interface-name:eth0", * which match even in that case. */ m = nm_match_spec_device (specs, pllink ? pllink->name : NULL, match_device_type, pllink ? pllink->driver : NULL, NULL, NULL, NULL, match_dhcp_plugin); switch (m) { case NM_MATCH_SPEC_MATCH: return TRUE; case NM_MATCH_SPEC_NEG_MATCH: return FALSE; case NM_MATCH_SPEC_NO_MATCH: return no_match_value; } nm_assert_not_reached (); return no_match_value; } /*****************************************************************************/ NMPlatformRoutingRule * nm_ip_routing_rule_to_platform (const NMIPRoutingRule *rule, NMPlatformRoutingRule *out_pl) { nm_assert (rule); nm_assert (nm_ip_routing_rule_validate (rule, NULL)); nm_assert (out_pl); *out_pl = (NMPlatformRoutingRule) { .addr_family = nm_ip_routing_rule_get_addr_family (rule), .flags = ( nm_ip_routing_rule_get_invert (rule) ? FIB_RULE_INVERT : 0), .priority = nm_ip_routing_rule_get_priority (rule), .tos = nm_ip_routing_rule_get_tos (rule), .ip_proto = nm_ip_routing_rule_get_ipproto (rule), .fwmark = nm_ip_routing_rule_get_fwmark (rule), .fwmask = nm_ip_routing_rule_get_fwmask (rule), .sport_range = { .start = nm_ip_routing_rule_get_source_port_start (rule), .end = nm_ip_routing_rule_get_source_port_end (rule), }, .dport_range = { .start = nm_ip_routing_rule_get_destination_port_start (rule), .end = nm_ip_routing_rule_get_destination_port_end (rule), }, .src = *(nm_ip_routing_rule_get_from_bin (rule) ?: &nm_ip_addr_zero), .dst = *(nm_ip_routing_rule_get_to_bin (rule) ?: &nm_ip_addr_zero), .src_len = nm_ip_routing_rule_get_from_len (rule), .dst_len = nm_ip_routing_rule_get_to_len (rule), .action = nm_ip_routing_rule_get_action (rule), .table = nm_ip_routing_rule_get_table (rule), .suppress_prefixlen_inverse = ~((guint32) nm_ip_routing_rule_get_suppress_prefixlength (rule)), }; nm_ip_routing_rule_get_xifname_bin (rule, TRUE, out_pl->iifname); nm_ip_routing_rule_get_xifname_bin (rule, FALSE, out_pl->oifname); return out_pl; } /*****************************************************************************/ struct _NMShutdownWaitObjHandle { CList lst; gpointer watched_obj; char *msg_reason; bool free_msg_reason:1; bool is_cancellable:1; }; static CList _shutdown_waitobj_lst_head; static void _shutdown_waitobj_unregister (NMShutdownWaitObjHandle *handle) { c_list_unlink_stale (&handle->lst); if (handle->free_msg_reason) g_free (handle->msg_reason); g_slice_free (NMShutdownWaitObjHandle, handle); /* FIXME(shutdown): check whether the object list is empty, and * signal shutdown-complete */ } static void _shutdown_waitobj_cb (gpointer user_data, GObject *where_the_object_was) { NMShutdownWaitObjHandle *handle = user_data; nm_assert (handle); nm_assert (handle->watched_obj == where_the_object_was); _shutdown_waitobj_unregister (handle); } /** * nm_shutdown_wait_obj_register_full: * @watched_obj: the object to watch. Takes a weak reference on the object * to be notified when it gets destroyed. * @wait_type: whether @watched_obj is just a plain GObject or a GCancellable * that should be cancelled. * @msg_reason: a reason message, for debugging and logging purposes. * @free_msg_reason: if %TRUE, then ownership of @msg_reason will be taken * and the string will be freed with g_free() afterwards. If %FALSE, * the caller must ensure that @msg_reason string outlives the watched * objects (e.g. being a static strings). * * Keep track of @watched_obj until it gets destroyed. During shutdown, * we wait until all watched objects are destroyed. This is useful, if * this object still conducts some asynchronous action, which needs to * complete before NetworkManager is allowed to terminate. We re-use * the reference-counter of @watched_obj as signal, that the object * is still used. * * If @wait_type is %NM_SHUTDOWN_WAIT_TYPE_CANCELLABLE, then during shutdown * (after %NM_SHUTDOWN_TIMEOUT_MS), the cancellable will be cancelled to notify * the source of the shutdown. Note that otherwise, in this mode also @watched_obj * is only tracked with a weak-pointer. Especially, it does not register to the * "cancelled" signal to automatically unregister (otherwise, you would never * know whether the returned NMShutdownWaitObjHandle is still valid. * * FIXME(shutdown): proper shutdown is not yet implemented, and registering * an object (currently) has no effect. * * FIXME(shutdown): during shutdown, after %NM_SHUTDOWN_TIMEOUT_MS timeout, cancel * all remaining %NM_SHUTDOWN_WAIT_TYPE_CANCELLABLE instances. Also, when somebody * enqueues a cancellable after that point, cancel it right away on an idle handler. * * Returns: a handle to unregister the object. The caller may choose to ignore * the handle, in which case, the object will be automatically unregistered, * once it gets destroyed. * Note that the handle is only valid as long as @watched_obj exists. If * you plan to use it, ensure that you take care of not using it after * destroying @watched_obj. */ NMShutdownWaitObjHandle * nm_shutdown_wait_obj_register_full (gpointer watched_obj, NMShutdownWaitType wait_type, char *msg_reason, gboolean free_msg_reason) { NMShutdownWaitObjHandle *handle; if (wait_type == NM_SHUTDOWN_WAIT_TYPE_OBJECT) g_return_val_if_fail (G_IS_OBJECT (watched_obj), NULL); else if (wait_type == NM_SHUTDOWN_WAIT_TYPE_CANCELLABLE) g_return_val_if_fail (G_IS_CANCELLABLE (watched_obj), NULL); else g_return_val_if_reached (NULL); if (G_UNLIKELY (!_shutdown_waitobj_lst_head.next)) c_list_init (&_shutdown_waitobj_lst_head); handle = g_slice_new (NMShutdownWaitObjHandle); *handle = (NMShutdownWaitObjHandle) { /* depending on @free_msg_reason, we take ownership of @msg_reason. * In either case, we just reference the string without cloning * it. */ .watched_obj = watched_obj, .msg_reason = msg_reason, .free_msg_reason = free_msg_reason, .is_cancellable = (wait_type == NM_SHUTDOWN_WAIT_TYPE_CANCELLABLE), }; c_list_link_tail (&_shutdown_waitobj_lst_head, &handle->lst); g_object_weak_ref (watched_obj, _shutdown_waitobj_cb, handle); return handle; } void nm_shutdown_wait_obj_unregister (NMShutdownWaitObjHandle *handle) { g_return_if_fail (handle); nm_assert (G_IS_OBJECT (handle->watched_obj)); nm_assert (nm_c_list_contains_entry (&_shutdown_waitobj_lst_head, handle, lst)); g_object_weak_unref (handle->watched_obj, _shutdown_waitobj_cb, handle); _shutdown_waitobj_unregister (handle); } /*****************************************************************************/ /** * nm_utils_file_is_in_path: * @abs_filename: the absolute filename to test * @abs_path: the absolute path, to check whether filename is in. * * This tests, whether @abs_filename is a file which lies inside @abs_path. * Basically, this checks whether @abs_filename is the same as @abs_path + * basename(@abs_filename). It allows simple normalizations, like coalescing * multiple "//". * * However, beware that this function is purely filename based. That means, * it will reject files that reference the same file (i.e. inode) via * symlinks or bind mounts. Maybe one would like to check for file (inode) * identity, but that is not really possible based on the file name alone. * * This means, that nm_utils_file_is_in_path("/var/run/some-file", "/var/run") * will succeed, but nm_utils_file_is_in_path("/run/some-file", "/var/run") * will not (although, it's well known that they reference the same path). * * Also, note that @abs_filename must not have trailing slashes itself. * So, this will reject nm_utils_file_is_in_path("/usr/lib/", "/usr") as * invalid, because the function searches for file names (and "lib/" is * clearly a directory). * * Returns: if @abs_filename is a file inside @abs_path, returns the * trailing part of @abs_filename which is the filename. Otherwise * %NULL. */ const char * nm_utils_file_is_in_path (const char *abs_filename, const char *abs_path) { const char *path; g_return_val_if_fail (abs_filename && abs_filename[0] == '/', NULL); g_return_val_if_fail (abs_path && abs_path[0] == '/', NULL); path = nm_sd_utils_path_startswith (abs_filename, abs_path); if (!path) return NULL; nm_assert (path[0] != '/'); nm_assert (path > abs_filename); nm_assert (path <= &abs_filename[strlen (abs_filename)]); /* we require a non-empty remainder with no slashes. That is, only a filename. * * Note this will reject "/var/run/" as not being in "/var", * while "/var/run" would pass. The function searches for files * only, so a trailing slash (indicating a directory) is not allowed). * This is despite that the function cannot determine whether "/var/run" * is itself a file or a directory. "*/ return path[0] && !strchr (path, '/') ? path : NULL; }