mirror of
https://gitlab.freedesktop.org/NetworkManager/NetworkManager
synced 2024-07-21 02:04:17 +00:00
cb73d0b1e2
Deal with compiling warning about variable not initialized before use. [thaller@redhat.com: reworded original commit message] https://gitlab.freedesktop.org/NetworkManager/NetworkManager/-/merge_requests/587
3398 lines
106 KiB
C
3398 lines
106 KiB
C
// SPDX-License-Identifier: LGPL-2.1+
|
|
/*
|
|
* Copyright (C) 2007 - 2018 Red Hat, Inc.
|
|
* Copyright (C) 2007 - 2008 Novell, Inc.
|
|
*/
|
|
|
|
#include "nm-default.h"
|
|
|
|
#include "nm-connection.h"
|
|
|
|
#include <arpa/inet.h>
|
|
|
|
#include "nm-connection-private.h"
|
|
#include "nm-utils.h"
|
|
#include "nm-setting-private.h"
|
|
#include "nm-core-internal.h"
|
|
|
|
/**
|
|
* SECTION:nm-connection
|
|
* @short_description: Describes a connection to specific network or provider
|
|
*
|
|
* An #NMConnection describes all the settings and configuration values that
|
|
* are necessary to configure network devices for operation on a specific
|
|
* network. Connections are the fundamental operating object for
|
|
* NetworkManager; no device is connected without a #NMConnection, or
|
|
* disconnected without having been connected with a #NMConnection.
|
|
*
|
|
* Each #NMConnection contains a list of #NMSetting objects usually referenced
|
|
* by name (using nm_connection_get_setting_by_name()) or by type (with
|
|
* nm_connection_get_setting()). The settings describe the actual parameters
|
|
* with which the network devices are configured, including device-specific
|
|
* parameters (MTU, SSID, APN, channel, rate, etc) and IP-level parameters
|
|
* (addresses, routes, addressing methods, etc).
|
|
*
|
|
*/
|
|
|
|
/*****************************************************************************/
|
|
|
|
enum {
|
|
SECRETS_UPDATED,
|
|
SECRETS_CLEARED,
|
|
CHANGED,
|
|
LAST_SIGNAL
|
|
};
|
|
|
|
static guint signals[LAST_SIGNAL] = { 0 };
|
|
|
|
typedef struct {
|
|
NMConnection *self;
|
|
|
|
GHashTable *settings;
|
|
|
|
/* D-Bus path of the connection, if any */
|
|
char *path;
|
|
} NMConnectionPrivate;
|
|
|
|
G_DEFINE_INTERFACE (NMConnection, nm_connection, G_TYPE_OBJECT)
|
|
|
|
static NMConnectionPrivate *nm_connection_get_private (NMConnection *connection);
|
|
#define NM_CONNECTION_GET_PRIVATE(o) (nm_connection_get_private ((NMConnection *)o))
|
|
|
|
/*****************************************************************************/
|
|
|
|
static gpointer
|
|
_gtype_to_hash_key (GType gtype)
|
|
{
|
|
#if NM_MORE_ASSERTS
|
|
_nm_unused const gsize *const test_gtype_typedef = >ype;
|
|
|
|
nm_assert ((GType) (GPOINTER_TO_SIZE (GSIZE_TO_POINTER (gtype))) == gtype);
|
|
G_STATIC_ASSERT_EXPR (sizeof (gpointer) >= sizeof (gsize));
|
|
G_STATIC_ASSERT_EXPR (sizeof (gsize) == sizeof (GType));
|
|
#endif
|
|
|
|
return GSIZE_TO_POINTER (gtype);
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
static void
|
|
setting_changed_cb (NMSetting *setting,
|
|
GParamSpec *pspec,
|
|
NMConnection *self)
|
|
{
|
|
g_signal_emit (self, signals[CHANGED], 0);
|
|
}
|
|
|
|
static void
|
|
_setting_release (NMConnection *connection, NMSetting *setting)
|
|
{
|
|
g_signal_handlers_disconnect_by_func (setting, setting_changed_cb, connection);
|
|
}
|
|
|
|
static gboolean
|
|
_setting_release_hfr (gpointer key, gpointer value, gpointer user_data)
|
|
{
|
|
_setting_release (user_data, value);
|
|
return TRUE;
|
|
}
|
|
|
|
static void
|
|
_nm_connection_add_setting (NMConnection *connection, NMSetting *setting)
|
|
{
|
|
NMConnectionPrivate *priv;
|
|
GType setting_type;
|
|
NMSetting *s_old;
|
|
|
|
nm_assert (NM_IS_CONNECTION (connection));
|
|
nm_assert (NM_IS_SETTING (setting));
|
|
|
|
priv = NM_CONNECTION_GET_PRIVATE (connection);
|
|
setting_type = G_OBJECT_TYPE (setting);
|
|
|
|
if ((s_old = g_hash_table_lookup (priv->settings, _gtype_to_hash_key (setting_type))))
|
|
_setting_release (connection, s_old);
|
|
|
|
g_hash_table_insert (priv->settings, _gtype_to_hash_key (setting_type), setting);
|
|
|
|
g_signal_connect (setting, "notify", (GCallback) setting_changed_cb, connection);
|
|
}
|
|
|
|
/**
|
|
* nm_connection_add_setting:
|
|
* @connection: a #NMConnection
|
|
* @setting: (transfer full): the #NMSetting to add to the connection object
|
|
*
|
|
* Adds a #NMSetting to the connection, replacing any previous #NMSetting of the
|
|
* same name which has previously been added to the #NMConnection. The
|
|
* connection takes ownership of the #NMSetting object and does not increase
|
|
* the setting object's reference count.
|
|
**/
|
|
void
|
|
nm_connection_add_setting (NMConnection *connection, NMSetting *setting)
|
|
{
|
|
g_return_if_fail (NM_IS_CONNECTION (connection));
|
|
g_return_if_fail (NM_IS_SETTING (setting));
|
|
|
|
_nm_connection_add_setting (connection, setting);
|
|
g_signal_emit (connection, signals[CHANGED], 0);
|
|
}
|
|
|
|
gboolean
|
|
_nm_connection_remove_setting (NMConnection *connection, GType setting_type)
|
|
{
|
|
NMConnectionPrivate *priv;
|
|
NMSetting *setting;
|
|
|
|
g_return_val_if_fail (NM_IS_CONNECTION (connection), FALSE);
|
|
g_return_val_if_fail (g_type_is_a (setting_type, NM_TYPE_SETTING), FALSE);
|
|
|
|
priv = NM_CONNECTION_GET_PRIVATE (connection);
|
|
setting = g_hash_table_lookup (priv->settings, _gtype_to_hash_key (setting_type));
|
|
if (setting) {
|
|
g_signal_handlers_disconnect_by_func (setting, setting_changed_cb, connection);
|
|
g_hash_table_remove (priv->settings, _gtype_to_hash_key (setting_type));
|
|
g_signal_emit (connection, signals[CHANGED], 0);
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
/**
|
|
* nm_connection_remove_setting:
|
|
* @connection: a #NMConnection
|
|
* @setting_type: the #GType of the setting object to remove
|
|
*
|
|
* Removes the #NMSetting with the given #GType from the #NMConnection. This
|
|
* operation dereferences the #NMSetting object.
|
|
**/
|
|
void
|
|
nm_connection_remove_setting (NMConnection *connection, GType setting_type)
|
|
{
|
|
_nm_connection_remove_setting (connection, setting_type);
|
|
}
|
|
|
|
static gpointer
|
|
_connection_get_setting (NMConnection *connection, GType setting_type)
|
|
{
|
|
NMSetting *setting;
|
|
|
|
nm_assert (NM_IS_CONNECTION (connection));
|
|
nm_assert (g_type_is_a (setting_type, NM_TYPE_SETTING));
|
|
|
|
setting = g_hash_table_lookup (NM_CONNECTION_GET_PRIVATE (connection)->settings,
|
|
_gtype_to_hash_key (setting_type));
|
|
nm_assert (!setting || G_TYPE_CHECK_INSTANCE_TYPE (setting, setting_type));
|
|
return setting;
|
|
}
|
|
|
|
static gpointer
|
|
_connection_get_setting_check (NMConnection *connection, GType setting_type)
|
|
{
|
|
g_return_val_if_fail (NM_IS_CONNECTION (connection), NULL);
|
|
|
|
return _connection_get_setting (connection, setting_type);
|
|
}
|
|
|
|
/**
|
|
* nm_connection_get_setting:
|
|
* @connection: a #NMConnection
|
|
* @setting_type: the #GType of the setting object to return
|
|
*
|
|
* Gets the #NMSetting with the given #GType, if one has been previously added
|
|
* to the #NMConnection.
|
|
*
|
|
* Returns: (transfer none): the #NMSetting, or %NULL if no setting of that type was previously
|
|
* added to the #NMConnection
|
|
**/
|
|
NMSetting *
|
|
nm_connection_get_setting (NMConnection *connection, GType setting_type)
|
|
{
|
|
g_return_val_if_fail (g_type_is_a (setting_type, NM_TYPE_SETTING), NULL);
|
|
|
|
return _connection_get_setting_check (connection, setting_type);
|
|
}
|
|
|
|
NMSettingIPConfig *
|
|
nm_connection_get_setting_ip_config (NMConnection *connection,
|
|
int addr_family)
|
|
{
|
|
nm_assert_addr_family (addr_family);
|
|
|
|
return NM_SETTING_IP_CONFIG (_connection_get_setting (connection,
|
|
(addr_family == AF_INET)
|
|
? NM_TYPE_SETTING_IP4_CONFIG
|
|
: NM_TYPE_SETTING_IP6_CONFIG));
|
|
}
|
|
|
|
/**
|
|
* nm_connection_get_setting_by_name:
|
|
* @connection: a #NMConnection
|
|
* @name: a setting name
|
|
*
|
|
* Gets the #NMSetting with the given name, if one has been previously added
|
|
* the #NMConnection.
|
|
*
|
|
* Returns: (transfer none): the #NMSetting, or %NULL if no setting with that name was previously
|
|
* added to the #NMConnection
|
|
**/
|
|
NMSetting *
|
|
nm_connection_get_setting_by_name (NMConnection *connection, const char *name)
|
|
{
|
|
GType type;
|
|
|
|
g_return_val_if_fail (NM_IS_CONNECTION (connection), NULL);
|
|
|
|
type = nm_setting_lookup_type (name);
|
|
return type ? _connection_get_setting (connection, type) : NULL;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
gpointer /* (NMSetting *) */
|
|
_nm_connection_check_main_setting (NMConnection *connection,
|
|
const char *setting_name,
|
|
GError **error)
|
|
{
|
|
NMSetting *setting;
|
|
|
|
nm_assert (NM_IS_CONNECTION (connection));
|
|
nm_assert (setting_name);
|
|
|
|
if (!nm_connection_is_type (connection, setting_name)) {
|
|
nm_utils_error_set (error,
|
|
NM_UTILS_ERROR_CONNECTION_AVAILABLE_INCOMPATIBLE,
|
|
"connection type is not \"%s\"",
|
|
setting_name);
|
|
return NULL;
|
|
}
|
|
|
|
setting = nm_connection_get_setting_by_name (connection, setting_name);
|
|
if (!setting) {
|
|
nm_utils_error_set (error,
|
|
NM_UTILS_ERROR_CONNECTION_AVAILABLE_INCOMPATIBLE,
|
|
"connection misses \"%s\" settings",
|
|
setting_name);
|
|
return NULL;
|
|
}
|
|
|
|
return setting;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
static gboolean
|
|
validate_permissions_type (GVariant *variant, GError **error)
|
|
{
|
|
GVariant *s_con;
|
|
GVariant *permissions;
|
|
gboolean valid = TRUE;
|
|
|
|
/* Ensure the connection::permissions item (if present) is the correct
|
|
* type, otherwise the g_object_set() will throw a warning and ignore the
|
|
* error, leaving us with no permissions.
|
|
*/
|
|
s_con = g_variant_lookup_value (variant, NM_SETTING_CONNECTION_SETTING_NAME, NM_VARIANT_TYPE_SETTING);
|
|
if (!s_con)
|
|
return TRUE;
|
|
|
|
permissions = g_variant_lookup_value (s_con, NM_SETTING_CONNECTION_PERMISSIONS, NULL);
|
|
if (permissions) {
|
|
if (!g_variant_is_of_type (permissions, G_VARIANT_TYPE_STRING_ARRAY)) {
|
|
g_set_error_literal (error,
|
|
NM_CONNECTION_ERROR,
|
|
NM_CONNECTION_ERROR_INVALID_PROPERTY,
|
|
_("wrong type; should be a list of strings."));
|
|
g_prefix_error (error, "%s.%s: ", NM_SETTING_CONNECTION_SETTING_NAME, NM_SETTING_CONNECTION_PERMISSIONS);
|
|
valid = FALSE;
|
|
}
|
|
g_variant_unref (permissions);
|
|
}
|
|
|
|
g_variant_unref (s_con);
|
|
return valid;
|
|
}
|
|
|
|
/**
|
|
* _nm_connection_replace_settings:
|
|
* @connection: a #NMConnection
|
|
* @new_settings: a #GVariant of type %NM_VARIANT_TYPE_CONNECTION, with the new settings
|
|
* @parse_flags: flags.
|
|
* @error: location to store error, or %NULL
|
|
*
|
|
* Replaces @connection's settings with @new_settings (which must be
|
|
* syntactically valid, and describe a known type of connection, but does not
|
|
* need to result in a connection that passes nm_connection_verify()).
|
|
*
|
|
* Returns: %TRUE if connection was updated, %FALSE if @new_settings could not
|
|
* be deserialized (in which case @connection will be unchanged).
|
|
* Only exception is the NM_SETTING_PARSE_FLAGS_NORMALIZE flag: if normalization
|
|
* fails, the input @connection is already modified and the original settings
|
|
* are lost.
|
|
**/
|
|
gboolean
|
|
_nm_connection_replace_settings (NMConnection *connection,
|
|
GVariant *new_settings,
|
|
NMSettingParseFlags parse_flags,
|
|
GError **error)
|
|
{
|
|
NMConnectionPrivate *priv;
|
|
GVariantIter iter;
|
|
const char *setting_name;
|
|
GVariant *setting_dict;
|
|
GSList *settings = NULL, *s;
|
|
gboolean changed, success;
|
|
|
|
g_return_val_if_fail (NM_IS_CONNECTION (connection), FALSE);
|
|
g_return_val_if_fail (g_variant_is_of_type (new_settings, NM_VARIANT_TYPE_CONNECTION), FALSE);
|
|
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
|
|
|
|
nm_assert (!NM_FLAGS_ANY (parse_flags, ~NM_SETTING_PARSE_FLAGS_ALL));
|
|
nm_assert (!NM_FLAGS_ALL (parse_flags, NM_SETTING_PARSE_FLAGS_STRICT | NM_SETTING_PARSE_FLAGS_BEST_EFFORT));
|
|
|
|
priv = NM_CONNECTION_GET_PRIVATE (connection);
|
|
|
|
if ( !NM_FLAGS_HAS (parse_flags, NM_SETTING_PARSE_FLAGS_BEST_EFFORT)
|
|
&& !validate_permissions_type (new_settings, error))
|
|
return FALSE;
|
|
|
|
g_variant_iter_init (&iter, new_settings);
|
|
while (g_variant_iter_next (&iter, "{&s@a{sv}}", &setting_name, &setting_dict)) {
|
|
gs_unref_variant GVariant *setting_dict_free = NULL;
|
|
GError *local = NULL;
|
|
NMSetting *setting;
|
|
GType type;
|
|
|
|
setting_dict_free = setting_dict;
|
|
|
|
type = nm_setting_lookup_type (setting_name);
|
|
if (type == G_TYPE_INVALID) {
|
|
if (NM_FLAGS_HAS (parse_flags, NM_SETTING_PARSE_FLAGS_BEST_EFFORT))
|
|
continue;
|
|
g_set_error_literal (error,
|
|
NM_CONNECTION_ERROR,
|
|
NM_CONNECTION_ERROR_INVALID_SETTING,
|
|
_("unknown setting name"));
|
|
g_prefix_error (error, "%s: ", setting_name);
|
|
g_slist_free_full (settings, g_object_unref);
|
|
return FALSE;
|
|
}
|
|
|
|
for (s = settings; s; s = s->next) {
|
|
if (G_OBJECT_TYPE (s->data) == type) {
|
|
if (NM_FLAGS_HAS (parse_flags, NM_SETTING_PARSE_FLAGS_STRICT)) {
|
|
g_set_error_literal (error,
|
|
NM_CONNECTION_ERROR,
|
|
NM_CONNECTION_ERROR_INVALID_SETTING,
|
|
_("duplicate setting name"));
|
|
g_prefix_error (error, "%s: ", setting_name);
|
|
g_slist_free_full (settings, g_object_unref);
|
|
return FALSE;
|
|
}
|
|
/* last wins. */
|
|
g_object_unref (s->data);
|
|
settings = g_slist_delete_link (settings, s);
|
|
break;
|
|
}
|
|
}
|
|
|
|
setting = _nm_setting_new_from_dbus (type, setting_dict, new_settings, parse_flags, &local);
|
|
|
|
if (!setting) {
|
|
if (NM_FLAGS_HAS (parse_flags, NM_SETTING_PARSE_FLAGS_BEST_EFFORT))
|
|
continue;
|
|
g_propagate_error (error, local);
|
|
g_slist_free_full (settings, g_object_unref);
|
|
return FALSE;
|
|
}
|
|
|
|
settings = g_slist_prepend (settings, setting);
|
|
}
|
|
|
|
if (g_hash_table_size (priv->settings) > 0) {
|
|
g_hash_table_foreach_remove (priv->settings, _setting_release_hfr, connection);
|
|
changed = TRUE;
|
|
} else
|
|
changed = (settings != NULL);
|
|
|
|
/* Note: @settings might be empty in which case the connection
|
|
* has no NMSetting instances... which is fine, just something
|
|
* to be aware of. */
|
|
for (s = settings; s; s = s->next)
|
|
_nm_connection_add_setting (connection, s->data);
|
|
|
|
g_slist_free (settings);
|
|
|
|
/* If verification/normalization fails, the original connection
|
|
* is already lost. From an API point of view, it would be nicer
|
|
* not to touch the input argument if we fail at the end.
|
|
* However, that would require creating a temporary connection
|
|
* to validate it first. As none of the caller cares about the
|
|
* state of the @connection when normalization fails, just do it
|
|
* this way. */
|
|
if (NM_FLAGS_HAS (parse_flags, NM_SETTING_PARSE_FLAGS_NORMALIZE))
|
|
success = nm_connection_normalize (connection, NULL, NULL, error);
|
|
else
|
|
success = TRUE;
|
|
|
|
if (changed)
|
|
g_signal_emit (connection, signals[CHANGED], 0);
|
|
return success;
|
|
}
|
|
|
|
/**
|
|
* nm_connection_replace_settings:
|
|
* @connection: a #NMConnection
|
|
* @new_settings: a #GVariant of type %NM_VARIANT_TYPE_CONNECTION, with the new settings
|
|
* @error: location to store error, or %NULL
|
|
*
|
|
* Replaces @connection's settings with @new_settings (which must be
|
|
* syntactically valid, and describe a known type of connection, but does not
|
|
* need to result in a connection that passes nm_connection_verify()).
|
|
*
|
|
* Returns: %TRUE if connection was updated, %FALSE if @new_settings could not
|
|
* be deserialized (in which case @connection will be unchanged).
|
|
**/
|
|
gboolean
|
|
nm_connection_replace_settings (NMConnection *connection,
|
|
GVariant *new_settings,
|
|
GError **error)
|
|
{
|
|
return _nm_connection_replace_settings (connection, new_settings, NM_SETTING_PARSE_FLAGS_NONE, error);
|
|
}
|
|
|
|
/**
|
|
* nm_connection_replace_settings_from_connection:
|
|
* @connection: a #NMConnection
|
|
* @new_connection: a #NMConnection to replace the settings of @connection with
|
|
*
|
|
* Deep-copies the settings of @new_connection and replaces the settings of @connection
|
|
* with the copied settings.
|
|
**/
|
|
void
|
|
nm_connection_replace_settings_from_connection (NMConnection *connection,
|
|
NMConnection *new_connection)
|
|
{
|
|
NMConnectionPrivate *priv, *new_priv;
|
|
GHashTableIter iter;
|
|
NMSetting *setting;
|
|
gboolean changed;
|
|
|
|
g_return_if_fail (NM_IS_CONNECTION (connection));
|
|
g_return_if_fail (NM_IS_CONNECTION (new_connection));
|
|
|
|
/* When 'connection' and 'new_connection' are the same object simply return
|
|
* in order not to destroy 'connection'.
|
|
*/
|
|
if (connection == new_connection)
|
|
return;
|
|
|
|
/* No need to validate permissions like nm_connection_replace_settings()
|
|
* since we're dealing with an NMConnection which has already done that.
|
|
*/
|
|
|
|
priv = NM_CONNECTION_GET_PRIVATE (connection);
|
|
new_priv = NM_CONNECTION_GET_PRIVATE (new_connection);
|
|
|
|
if ((changed = g_hash_table_size (priv->settings) > 0))
|
|
g_hash_table_foreach_remove (priv->settings, _setting_release_hfr, connection);
|
|
|
|
if (g_hash_table_size (new_priv->settings)) {
|
|
g_hash_table_iter_init (&iter, new_priv->settings);
|
|
while (g_hash_table_iter_next (&iter, NULL, (gpointer) &setting))
|
|
_nm_connection_add_setting (connection, nm_setting_duplicate (setting));
|
|
changed = TRUE;
|
|
}
|
|
|
|
if (changed)
|
|
g_signal_emit (connection, signals[CHANGED], 0);
|
|
}
|
|
|
|
/**
|
|
* nm_connection_clear_settings:
|
|
* @connection: a #NMConnection
|
|
*
|
|
* Deletes all of @connection's settings.
|
|
**/
|
|
void
|
|
nm_connection_clear_settings (NMConnection *connection)
|
|
{
|
|
NMConnectionPrivate *priv;
|
|
|
|
g_return_if_fail (NM_IS_CONNECTION (connection));
|
|
|
|
priv = NM_CONNECTION_GET_PRIVATE (connection);
|
|
|
|
if (g_hash_table_size (priv->settings) > 0) {
|
|
g_hash_table_foreach_remove (priv->settings, _setting_release_hfr, connection);
|
|
g_signal_emit (connection, signals[CHANGED], 0);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* nm_connection_compare:
|
|
* @a: a #NMConnection
|
|
* @b: a second #NMConnection to compare with the first
|
|
* @flags: compare flags, e.g. %NM_SETTING_COMPARE_FLAG_EXACT
|
|
*
|
|
* Compares two #NMConnection objects for similarity, with comparison behavior
|
|
* modified by a set of flags. See nm_setting_compare() for a description of
|
|
* each flag's behavior.
|
|
*
|
|
* Returns: %TRUE if the comparison succeeds, %FALSE if it does not
|
|
**/
|
|
gboolean
|
|
nm_connection_compare (NMConnection *a,
|
|
NMConnection *b,
|
|
NMSettingCompareFlags flags)
|
|
{
|
|
GHashTableIter iter;
|
|
NMSetting *src;
|
|
|
|
if (a == b)
|
|
return TRUE;
|
|
if (!a || !b)
|
|
return FALSE;
|
|
|
|
/* B / A: ensure settings in B that are not in A make the comparison fail */
|
|
if (g_hash_table_size (NM_CONNECTION_GET_PRIVATE (a)->settings) !=
|
|
g_hash_table_size (NM_CONNECTION_GET_PRIVATE (b)->settings))
|
|
return FALSE;
|
|
|
|
/* A / B: ensure all settings in A match corresponding ones in B */
|
|
g_hash_table_iter_init (&iter, NM_CONNECTION_GET_PRIVATE (a)->settings);
|
|
while (g_hash_table_iter_next (&iter, NULL, (gpointer) &src)) {
|
|
NMSetting *cmp = nm_connection_get_setting (b, G_OBJECT_TYPE (src));
|
|
|
|
if ( !cmp
|
|
|| !_nm_setting_compare (a, src, b, cmp, flags))
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
diff_one_connection (NMConnection *a,
|
|
NMConnection *b,
|
|
NMSettingCompareFlags flags,
|
|
gboolean invert_results,
|
|
GHashTable *diffs)
|
|
{
|
|
NMConnectionPrivate *priv = NM_CONNECTION_GET_PRIVATE (a);
|
|
GHashTableIter iter;
|
|
NMSetting *a_setting = NULL;
|
|
gboolean diff_found = FALSE;
|
|
|
|
g_hash_table_iter_init (&iter, priv->settings);
|
|
while (g_hash_table_iter_next (&iter, NULL, (gpointer) &a_setting)) {
|
|
NMSetting *b_setting = NULL;
|
|
const char *setting_name = nm_setting_get_name (a_setting);
|
|
GHashTable *results;
|
|
gboolean new_results = TRUE;
|
|
|
|
if (b)
|
|
b_setting = nm_connection_get_setting (b, G_OBJECT_TYPE (a_setting));
|
|
|
|
results = g_hash_table_lookup (diffs, setting_name);
|
|
if (results)
|
|
new_results = FALSE;
|
|
|
|
if (!_nm_setting_diff (a, a_setting, b, b_setting, flags, invert_results, &results))
|
|
diff_found = TRUE;
|
|
|
|
if (new_results && results)
|
|
g_hash_table_insert (diffs, g_strdup (setting_name), results);
|
|
}
|
|
|
|
return diff_found;
|
|
}
|
|
|
|
/**
|
|
* nm_connection_diff:
|
|
* @a: a #NMConnection
|
|
* @b: a second #NMConnection to compare with the first
|
|
* @flags: compare flags, e.g. %NM_SETTING_COMPARE_FLAG_EXACT
|
|
* @out_settings: (element-type utf8 GLib.HashTable): if the
|
|
* connections differ, on return a hash table mapping setting names to
|
|
* second-level GHashTable (utf8 to guint32), which contains the key names that
|
|
* differ mapped to one or more of %NMSettingDiffResult as a bitfield
|
|
*
|
|
* Compares two #NMConnection objects for similarity, with comparison behavior
|
|
* modified by a set of flags. See nm_setting_compare() for a description of
|
|
* each flag's behavior. If the connections differ, settings and keys within
|
|
* each setting that differ are added to the returned @out_settings hash table.
|
|
* No values are returned, only key names.
|
|
*
|
|
* Returns: %TRUE if the connections contain the same values, %FALSE if they do
|
|
* not
|
|
**/
|
|
gboolean
|
|
nm_connection_diff (NMConnection *a,
|
|
NMConnection *b,
|
|
NMSettingCompareFlags flags,
|
|
GHashTable **out_settings)
|
|
{
|
|
GHashTable *diffs;
|
|
gboolean diff_found = FALSE;
|
|
|
|
g_return_val_if_fail (NM_IS_CONNECTION (a), FALSE);
|
|
g_return_val_if_fail (!out_settings || !*out_settings, FALSE);
|
|
g_return_val_if_fail (!b || NM_IS_CONNECTION (b), FALSE);
|
|
|
|
if (a == b)
|
|
return TRUE;
|
|
|
|
diffs = g_hash_table_new_full (nm_str_hash, g_str_equal, g_free, (GDestroyNotify) g_hash_table_destroy);
|
|
|
|
/* Diff A to B, then B to A to capture keys in B that aren't in A */
|
|
if (diff_one_connection (a, b, flags, FALSE, diffs))
|
|
diff_found = TRUE;
|
|
if ( b
|
|
&& diff_one_connection (b, a, flags, TRUE, diffs))
|
|
diff_found = TRUE;
|
|
|
|
nm_assert (diff_found == (g_hash_table_size (diffs) != 0));
|
|
|
|
if (g_hash_table_size (diffs) == 0) {
|
|
g_hash_table_destroy (diffs);
|
|
diffs = NULL;
|
|
}
|
|
|
|
NM_SET_OUT (out_settings, diffs);
|
|
|
|
return !diff_found;
|
|
}
|
|
|
|
NMSetting *
|
|
_nm_connection_find_base_type_setting (NMConnection *connection)
|
|
{
|
|
NMConnectionPrivate *priv = NM_CONNECTION_GET_PRIVATE (connection);
|
|
GHashTableIter iter;
|
|
NMSetting *setting = NULL;
|
|
NMSetting *s_iter;
|
|
NMSettingPriority setting_prio = NM_SETTING_PRIORITY_USER;
|
|
NMSettingPriority s_iter_prio;
|
|
|
|
g_hash_table_iter_init (&iter, priv->settings);
|
|
while (g_hash_table_iter_next (&iter, NULL, (gpointer *) &s_iter)) {
|
|
s_iter_prio = _nm_setting_get_base_type_priority (s_iter);
|
|
if (s_iter_prio == NM_SETTING_PRIORITY_INVALID)
|
|
continue;
|
|
|
|
if (setting) {
|
|
if (s_iter_prio > setting_prio) {
|
|
continue;
|
|
} else if (s_iter_prio == setting_prio) {
|
|
NMSettingConnection *s_con = nm_connection_get_setting_connection (connection);
|
|
const char *type;
|
|
|
|
if (s_con) {
|
|
type = nm_setting_connection_get_connection_type (s_con);
|
|
if (type)
|
|
return nm_connection_get_setting_by_name (connection, type);
|
|
}
|
|
return NULL;
|
|
}
|
|
}
|
|
setting = s_iter;
|
|
setting_prio = s_iter_prio;
|
|
}
|
|
return setting;
|
|
}
|
|
|
|
static gboolean
|
|
_normalize_connection_uuid (NMConnection *self)
|
|
{
|
|
NMSettingConnection *s_con = nm_connection_get_setting_connection (self);
|
|
char uuid[37];
|
|
|
|
nm_assert (s_con);
|
|
|
|
if (nm_setting_connection_get_uuid (s_con))
|
|
return FALSE;
|
|
|
|
g_object_set (s_con,
|
|
NM_SETTING_CONNECTION_UUID,
|
|
nm_utils_uuid_generate_buf (uuid),
|
|
NULL);
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
_normalize_connection_type (NMConnection *self)
|
|
{
|
|
NMSettingConnection *s_con = nm_connection_get_setting_connection (self);
|
|
NMSetting *s_base = NULL;
|
|
const char *type;
|
|
|
|
type = nm_setting_connection_get_connection_type (s_con);
|
|
|
|
if (type) {
|
|
s_base = nm_connection_get_setting_by_name (self, type);
|
|
|
|
if (!s_base) {
|
|
GType base_type = nm_setting_lookup_type (type);
|
|
|
|
g_return_val_if_fail (base_type, FALSE);
|
|
nm_connection_add_setting (self, g_object_new (base_type, NULL));
|
|
return TRUE;
|
|
}
|
|
} else {
|
|
s_base = _nm_connection_find_base_type_setting (self);
|
|
g_return_val_if_fail (s_base, FALSE);
|
|
|
|
type = nm_setting_get_name (s_base);
|
|
g_object_set (s_con, NM_SETTING_CONNECTION_TYPE, type, NULL);
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
const char *
|
|
_nm_connection_detect_bluetooth_type (NMConnection *self)
|
|
{
|
|
NMSettingBluetooth *s_bt = nm_connection_get_setting_bluetooth (self);
|
|
|
|
if ( s_bt
|
|
&& nm_setting_bluetooth_get_connection_type (s_bt)) {
|
|
if ( nm_connection_get_setting_gsm (self)
|
|
|| nm_connection_get_setting_cdma (self))
|
|
return NM_SETTING_BLUETOOTH_TYPE_DUN;
|
|
if (nm_connection_get_setting_bridge (self))
|
|
return NM_SETTING_BLUETOOTH_TYPE_NAP;
|
|
return NM_SETTING_BLUETOOTH_TYPE_PANU;
|
|
}
|
|
|
|
/* NULL means the connection is not a bluetooth type, or it needs
|
|
* no normalization, as the type is set explicitly. */
|
|
return NULL;
|
|
}
|
|
|
|
const char *
|
|
_nm_connection_detect_slave_type (NMConnection *connection, NMSetting **out_s_port)
|
|
{
|
|
NMConnectionPrivate *priv = NM_CONNECTION_GET_PRIVATE (connection);
|
|
GHashTableIter iter;
|
|
const char *slave_type = NULL;
|
|
NMSetting *s_port = NULL, *s_iter;
|
|
|
|
g_hash_table_iter_init (&iter, priv->settings);
|
|
while (g_hash_table_iter_next (&iter, NULL, (gpointer *) &s_iter)) {
|
|
const char *name = nm_setting_get_name (s_iter);
|
|
const char *i_slave_type = NULL;
|
|
|
|
if (!strcmp (name, NM_SETTING_BRIDGE_PORT_SETTING_NAME))
|
|
i_slave_type = NM_SETTING_BRIDGE_SETTING_NAME;
|
|
else if (!strcmp (name, NM_SETTING_TEAM_PORT_SETTING_NAME))
|
|
i_slave_type = NM_SETTING_TEAM_SETTING_NAME;
|
|
else if (!strcmp (name, NM_SETTING_OVS_PORT_SETTING_NAME))
|
|
i_slave_type = NM_SETTING_OVS_BRIDGE_SETTING_NAME;
|
|
else if (!strcmp (name, NM_SETTING_OVS_INTERFACE_SETTING_NAME))
|
|
i_slave_type = NM_SETTING_OVS_PORT_SETTING_NAME;
|
|
else
|
|
continue;
|
|
|
|
if (slave_type) {
|
|
/* there are more then one matching port types, cannot detect the slave type. */
|
|
slave_type = NULL;
|
|
s_port = NULL;
|
|
break;
|
|
}
|
|
slave_type = i_slave_type;
|
|
s_port = s_iter;
|
|
}
|
|
|
|
if (out_s_port)
|
|
*out_s_port = s_port;
|
|
return slave_type;
|
|
}
|
|
|
|
static gboolean
|
|
_normalize_connection_slave_type (NMConnection *self)
|
|
{
|
|
NMSettingConnection *s_con = nm_connection_get_setting_connection (self);
|
|
const char *slave_type, *port_type;
|
|
|
|
if (!s_con)
|
|
return FALSE;
|
|
if (!nm_setting_connection_get_master (s_con))
|
|
return FALSE;
|
|
|
|
slave_type = nm_setting_connection_get_slave_type (s_con);
|
|
if (slave_type) {
|
|
if ( _nm_setting_slave_type_is_valid (slave_type, &port_type)
|
|
&& port_type) {
|
|
NMSetting *s_port;
|
|
|
|
s_port = nm_connection_get_setting_by_name (self, port_type);
|
|
if (!s_port) {
|
|
GType p_type = nm_setting_lookup_type (port_type);
|
|
|
|
g_return_val_if_fail (p_type, FALSE);
|
|
nm_connection_add_setting (self, g_object_new (p_type, NULL));
|
|
return TRUE;
|
|
}
|
|
}
|
|
} else {
|
|
if ((slave_type = _nm_connection_detect_slave_type (self, NULL))) {
|
|
g_object_set (s_con, NM_SETTING_CONNECTION_SLAVE_TYPE, slave_type, NULL);
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
static gboolean
|
|
_normalize_ethernet_link_neg (NMConnection *self)
|
|
{
|
|
NMSettingWired *s_wired = nm_connection_get_setting_wired (self);
|
|
|
|
if (s_wired) {
|
|
guint32 speed = nm_setting_wired_get_speed (s_wired);
|
|
const char *duplex = nm_setting_wired_get_duplex (s_wired);
|
|
|
|
if ( (speed && !duplex)
|
|
|| (!speed && duplex)) {
|
|
speed = 0;
|
|
duplex = NULL;
|
|
g_object_set (s_wired,
|
|
NM_SETTING_WIRED_SPEED, (guint) speed,
|
|
NM_SETTING_WIRED_DUPLEX, duplex,
|
|
NULL);
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
/**
|
|
* _supports_addr_family:
|
|
* @self: a #NMConnection
|
|
* @family: AF_*
|
|
*
|
|
* Check whether the connection supports certain L3 address family,
|
|
* in order to be able to tell whether is should have the corresponding
|
|
* setting ("ipv4" for AF_INET and "ipv6" for AF_INET6).
|
|
*
|
|
* If AF_UNSPEC is given, then the function checks whether the connection
|
|
* supports any L3 configuration at all.
|
|
*
|
|
* Returns: %TRUE if the AF is supported, %FALSE otherwise
|
|
**/
|
|
static gboolean
|
|
_supports_addr_family (NMConnection *self, int family)
|
|
{
|
|
const char *connection_type = nm_connection_get_connection_type (self);
|
|
NMSettingConnection *s_con;
|
|
|
|
g_return_val_if_fail (connection_type, TRUE);
|
|
if (strcmp (connection_type, NM_SETTING_OVS_INTERFACE_SETTING_NAME) == 0)
|
|
return TRUE;
|
|
if (strcmp (connection_type, NM_SETTING_WPAN_SETTING_NAME) == 0)
|
|
return FALSE;
|
|
if (strcmp (connection_type, NM_SETTING_6LOWPAN_SETTING_NAME) == 0)
|
|
return family == AF_INET6 || family == AF_UNSPEC;
|
|
if ( (s_con = nm_connection_get_setting_connection (self))
|
|
&& (nm_streq0 (nm_setting_connection_get_slave_type (s_con), NM_SETTING_VRF_SETTING_NAME)))
|
|
return TRUE;
|
|
|
|
return !nm_setting_connection_get_master (nm_connection_get_setting_connection (self));
|
|
}
|
|
|
|
static gboolean
|
|
_normalize_ip_config (NMConnection *self, GHashTable *parameters)
|
|
{
|
|
NMSettingIPConfig *s_ip4, *s_ip6;
|
|
NMSettingProxy *s_proxy;
|
|
NMSetting *setting;
|
|
gboolean changed = FALSE;
|
|
guint num, i;
|
|
|
|
s_ip4 = nm_connection_get_setting_ip4_config (self);
|
|
s_ip6 = nm_connection_get_setting_ip6_config (self);
|
|
s_proxy = nm_connection_get_setting_proxy (self);
|
|
|
|
if (_supports_addr_family (self, AF_INET)) {
|
|
|
|
if (!s_ip4) {
|
|
const char *default_ip4_method = NM_SETTING_IP4_CONFIG_METHOD_AUTO;
|
|
|
|
if (nm_connection_is_type (self, NM_SETTING_WIREGUARD_SETTING_NAME))
|
|
default_ip4_method = NM_SETTING_IP4_CONFIG_METHOD_DISABLED;
|
|
|
|
/* But if no IP4 setting was specified, assume the caller was just
|
|
* being lazy and use the default method.
|
|
*/
|
|
setting = nm_setting_ip4_config_new ();
|
|
|
|
g_object_set (setting,
|
|
NM_SETTING_IP_CONFIG_METHOD, default_ip4_method,
|
|
NULL);
|
|
nm_connection_add_setting (self, setting);
|
|
changed = TRUE;
|
|
} else {
|
|
if ( nm_setting_ip_config_get_gateway (s_ip4)
|
|
&& nm_setting_ip_config_get_never_default (s_ip4)) {
|
|
g_object_set (s_ip4, NM_SETTING_IP_CONFIG_GATEWAY, NULL, NULL);
|
|
changed = TRUE;
|
|
}
|
|
|
|
if ( nm_streq0 (nm_setting_ip_config_get_method (s_ip4),
|
|
NM_SETTING_IP4_CONFIG_METHOD_DISABLED)
|
|
&& !nm_setting_ip_config_get_may_fail (s_ip4)) {
|
|
g_object_set (s_ip4, NM_SETTING_IP_CONFIG_MAY_FAIL, TRUE, NULL);
|
|
changed = TRUE;
|
|
}
|
|
|
|
num = nm_setting_ip_config_get_num_addresses (s_ip4);
|
|
if ( num > 1
|
|
&& nm_streq0 (nm_setting_ip_config_get_method (s_ip4),
|
|
NM_SETTING_IP4_CONFIG_METHOD_SHARED)) {
|
|
for (i = num - 1; i > 0; i--)
|
|
nm_setting_ip_config_remove_address (s_ip4, i);
|
|
changed = TRUE;
|
|
}
|
|
}
|
|
} else {
|
|
if (s_ip4) {
|
|
nm_connection_remove_setting (self, NM_TYPE_SETTING_IP4_CONFIG);
|
|
changed = TRUE;
|
|
}
|
|
}
|
|
|
|
if (_supports_addr_family (self, AF_INET6)) {
|
|
if (!s_ip6) {
|
|
const char *default_ip6_method = NULL;
|
|
|
|
if (parameters)
|
|
default_ip6_method = g_hash_table_lookup (parameters, NM_CONNECTION_NORMALIZE_PARAM_IP6_CONFIG_METHOD);
|
|
if (!default_ip6_method) {
|
|
if (nm_connection_is_type (self, NM_SETTING_WIREGUARD_SETTING_NAME))
|
|
default_ip6_method = NM_SETTING_IP6_CONFIG_METHOD_IGNORE;
|
|
else
|
|
default_ip6_method = NM_SETTING_IP6_CONFIG_METHOD_AUTO;
|
|
}
|
|
|
|
/* If no IP6 setting was specified, then assume that means IP6 config is
|
|
* allowed to fail.
|
|
*/
|
|
setting = nm_setting_ip6_config_new ();
|
|
|
|
g_object_set (setting,
|
|
NM_SETTING_IP_CONFIG_METHOD, default_ip6_method,
|
|
NM_SETTING_IP_CONFIG_MAY_FAIL, TRUE,
|
|
NULL);
|
|
nm_connection_add_setting (self, setting);
|
|
changed = TRUE;
|
|
} else {
|
|
const char *token;
|
|
|
|
token = nm_setting_ip6_config_get_token ((NMSettingIP6Config *) s_ip6);
|
|
if ( token
|
|
&& nm_setting_ip6_config_get_addr_gen_mode ((NMSettingIP6Config *) s_ip6) == NM_SETTING_IP6_CONFIG_ADDR_GEN_MODE_EUI64) {
|
|
struct in6_addr i6_token;
|
|
char normalized[NM_UTILS_INET_ADDRSTRLEN];
|
|
|
|
if ( inet_pton (AF_INET6, token, &i6_token) == 1
|
|
&& _nm_utils_inet6_is_token (&i6_token)) {
|
|
_nm_utils_inet6_ntop (&i6_token, normalized);
|
|
if (g_strcmp0 (token, normalized)) {
|
|
g_object_set (s_ip6, NM_SETTING_IP6_CONFIG_TOKEN, normalized, NULL);
|
|
changed = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( nm_setting_ip_config_get_gateway (s_ip6)
|
|
&& nm_setting_ip_config_get_never_default (s_ip6)) {
|
|
g_object_set (s_ip6, NM_SETTING_IP_CONFIG_GATEWAY, NULL, NULL);
|
|
changed = TRUE;
|
|
}
|
|
|
|
if ( NM_IN_STRSET (nm_setting_ip_config_get_method (s_ip6),
|
|
NM_SETTING_IP6_CONFIG_METHOD_IGNORE,
|
|
NM_SETTING_IP6_CONFIG_METHOD_DISABLED)
|
|
&& !nm_setting_ip_config_get_may_fail (s_ip6)) {
|
|
g_object_set (s_ip6, NM_SETTING_IP_CONFIG_MAY_FAIL, TRUE, NULL);
|
|
changed = TRUE;
|
|
}
|
|
}
|
|
} else {
|
|
if (s_ip6) {
|
|
nm_connection_remove_setting (self, NM_TYPE_SETTING_IP6_CONFIG);
|
|
changed = TRUE;
|
|
}
|
|
}
|
|
|
|
if (_supports_addr_family (self, AF_UNSPEC)) {
|
|
if (!s_proxy) {
|
|
setting = nm_setting_proxy_new ();
|
|
nm_connection_add_setting (self, setting);
|
|
changed = TRUE;
|
|
}
|
|
} else {
|
|
if (s_proxy) {
|
|
nm_connection_remove_setting (self, NM_TYPE_SETTING_PROXY);
|
|
changed = TRUE;
|
|
}
|
|
}
|
|
|
|
return changed;
|
|
}
|
|
|
|
static gboolean
|
|
_normalize_infiniband_mtu (NMConnection *self)
|
|
{
|
|
NMSettingInfiniband *s_infini = nm_connection_get_setting_infiniband (self);
|
|
|
|
if ( !s_infini
|
|
|| nm_setting_infiniband_get_mtu (s_infini) <= NM_INFINIBAND_MAX_MTU
|
|
|| !NM_IN_STRSET (nm_setting_infiniband_get_transport_mode (s_infini), "datagram",
|
|
"connected"))
|
|
return FALSE;
|
|
|
|
g_object_set (s_infini, NM_SETTING_INFINIBAND_MTU, (guint) NM_INFINIBAND_MAX_MTU, NULL);
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
_normalize_bond_mode (NMConnection *self)
|
|
{
|
|
NMSettingBond *s_bond = nm_connection_get_setting_bond (self);
|
|
|
|
/* Convert mode from numeric to string notation */
|
|
if (s_bond) {
|
|
const char *mode = nm_setting_bond_get_option_by_name (s_bond, NM_SETTING_BOND_OPTION_MODE);
|
|
int mode_int = nm_utils_bond_mode_string_to_int (mode);
|
|
|
|
if (mode_int != -1) {
|
|
const char *mode_new = nm_utils_bond_mode_int_to_string (mode_int);
|
|
if (g_strcmp0 (mode_new, mode) != 0) {
|
|
nm_setting_bond_add_option (s_bond, NM_SETTING_BOND_OPTION_MODE, mode_new);
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
static gboolean
|
|
_normalize_bond_options (NMConnection *self)
|
|
{
|
|
NMSettingBond *s_bond = nm_connection_get_setting_bond (self);
|
|
gboolean changed = FALSE;
|
|
const char *name, *mode_str;
|
|
NMBondMode mode;
|
|
guint32 num, i;
|
|
|
|
/* Strip away unsupported options for current mode */
|
|
if (s_bond) {
|
|
mode_str = nm_setting_bond_get_option_by_name (s_bond, NM_SETTING_BOND_OPTION_MODE);
|
|
mode = _nm_setting_bond_mode_from_string (mode_str);
|
|
if (mode == NM_BOND_MODE_UNKNOWN)
|
|
return FALSE;
|
|
again:
|
|
num = nm_setting_bond_get_num_options (s_bond);
|
|
for (i = 0; i < num; i++) {
|
|
if ( nm_setting_bond_get_option (s_bond, i, &name, NULL)
|
|
&& !_nm_setting_bond_option_supported (name, mode)) {
|
|
nm_setting_bond_remove_option (s_bond, name);
|
|
changed = TRUE;
|
|
goto again;
|
|
}
|
|
}
|
|
}
|
|
|
|
return changed;
|
|
}
|
|
|
|
static gboolean
|
|
_normalize_wireless_mac_address_randomization (NMConnection *self)
|
|
{
|
|
NMSettingWireless *s_wifi = nm_connection_get_setting_wireless (self);
|
|
const char *cloned_mac_address;
|
|
NMSettingMacRandomization mac_address_randomization;
|
|
|
|
if (!s_wifi)
|
|
return FALSE;
|
|
|
|
mac_address_randomization = nm_setting_wireless_get_mac_address_randomization (s_wifi);
|
|
if (!NM_IN_SET (mac_address_randomization,
|
|
NM_SETTING_MAC_RANDOMIZATION_DEFAULT,
|
|
NM_SETTING_MAC_RANDOMIZATION_NEVER,
|
|
NM_SETTING_MAC_RANDOMIZATION_ALWAYS))
|
|
return FALSE;
|
|
|
|
cloned_mac_address = nm_setting_wireless_get_cloned_mac_address (s_wifi);
|
|
if (cloned_mac_address) {
|
|
if (nm_streq (cloned_mac_address, "random")) {
|
|
if (mac_address_randomization == NM_SETTING_MAC_RANDOMIZATION_ALWAYS)
|
|
return FALSE;
|
|
mac_address_randomization = NM_SETTING_MAC_RANDOMIZATION_ALWAYS;
|
|
} else if (nm_streq (cloned_mac_address, "permanent")) {
|
|
if (mac_address_randomization == NM_SETTING_MAC_RANDOMIZATION_NEVER)
|
|
return FALSE;
|
|
mac_address_randomization = NM_SETTING_MAC_RANDOMIZATION_NEVER;
|
|
} else {
|
|
if (mac_address_randomization == NM_SETTING_MAC_RANDOMIZATION_DEFAULT)
|
|
return FALSE;
|
|
mac_address_randomization = NM_SETTING_MAC_RANDOMIZATION_DEFAULT;
|
|
}
|
|
g_object_set (s_wifi, NM_SETTING_WIRELESS_MAC_ADDRESS_RANDOMIZATION, mac_address_randomization, NULL);
|
|
return TRUE;
|
|
}
|
|
if (mac_address_randomization != NM_SETTING_MAC_RANDOMIZATION_DEFAULT) {
|
|
g_object_set (s_wifi,
|
|
NM_SETTING_WIRELESS_CLONED_MAC_ADDRESS,
|
|
mac_address_randomization == NM_SETTING_MAC_RANDOMIZATION_ALWAYS
|
|
? "random" : "permanent",
|
|
NULL);
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
static gboolean
|
|
_normalize_macsec (NMConnection *self)
|
|
{
|
|
NMSettingMacsec *s_macsec = nm_connection_get_setting_macsec (self);
|
|
gboolean changed = FALSE;
|
|
|
|
if (!s_macsec)
|
|
return FALSE;
|
|
|
|
if (nm_setting_macsec_get_mode (s_macsec) != NM_SETTING_MACSEC_MODE_PSK) {
|
|
if (nm_setting_macsec_get_mka_cak (s_macsec)) {
|
|
g_object_set (s_macsec, NM_SETTING_MACSEC_MKA_CAK, NULL, NULL);
|
|
changed = TRUE;
|
|
}
|
|
if (nm_setting_macsec_get_mka_ckn (s_macsec)) {
|
|
g_object_set (s_macsec, NM_SETTING_MACSEC_MKA_CKN, NULL, NULL);
|
|
changed = TRUE;
|
|
}
|
|
}
|
|
|
|
return changed;
|
|
}
|
|
|
|
static gboolean
|
|
_normalize_team_config (NMConnection *self)
|
|
{
|
|
NMSettingTeam *s_team = nm_connection_get_setting_team (self);
|
|
|
|
if (s_team) {
|
|
const char *config = nm_setting_team_get_config (s_team);
|
|
|
|
if (config && !*config) {
|
|
g_object_set (s_team, NM_SETTING_TEAM_CONFIG, NULL, NULL);
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
static gboolean
|
|
_normalize_team_port_config (NMConnection *self)
|
|
{
|
|
NMSettingTeamPort *s_team_port = nm_connection_get_setting_team_port (self);
|
|
|
|
if (s_team_port) {
|
|
const char *config = nm_setting_team_port_get_config (s_team_port);
|
|
|
|
if (config && !*config) {
|
|
g_object_set (s_team_port, NM_SETTING_TEAM_PORT_CONFIG, NULL, NULL);
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
static gboolean
|
|
_normalize_bluetooth_type (NMConnection *self)
|
|
{
|
|
const char *type = _nm_connection_detect_bluetooth_type (self);
|
|
|
|
if (type) {
|
|
g_object_set (nm_connection_get_setting_bluetooth (self),
|
|
NM_SETTING_BLUETOOTH_TYPE, type,
|
|
NULL);
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
static gboolean
|
|
_normalize_ovs_interface_type (NMConnection *self)
|
|
{
|
|
NMSettingOvsInterface *s_ovs_interface = nm_connection_get_setting_ovs_interface (self);
|
|
gboolean modified;
|
|
int v;
|
|
|
|
if (!s_ovs_interface)
|
|
return FALSE;
|
|
|
|
v = _nm_setting_ovs_interface_verify_interface_type (s_ovs_interface,
|
|
nm_setting_ovs_interface_get_interface_type (s_ovs_interface),
|
|
self,
|
|
TRUE,
|
|
&modified,
|
|
NULL,
|
|
NULL);
|
|
if (v != TRUE)
|
|
g_return_val_if_reached (modified);
|
|
|
|
return modified;
|
|
}
|
|
|
|
static gboolean
|
|
_normalize_ip_tunnel_wired_setting (NMConnection *self)
|
|
{
|
|
NMSettingIPTunnel *s_ip_tunnel;
|
|
|
|
s_ip_tunnel = nm_connection_get_setting_ip_tunnel (self);
|
|
if (!s_ip_tunnel)
|
|
return FALSE;
|
|
|
|
if ( nm_connection_get_setting_wired (self)
|
|
&& !NM_IN_SET (nm_setting_ip_tunnel_get_mode (s_ip_tunnel),
|
|
NM_IP_TUNNEL_MODE_GRETAP,
|
|
NM_IP_TUNNEL_MODE_IP6GRETAP)) {
|
|
nm_connection_remove_setting (self, NM_TYPE_SETTING_WIRED);
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static gboolean
|
|
_normalize_sriov_vf_order (NMConnection *self)
|
|
{
|
|
NMSettingSriov *s_sriov;
|
|
|
|
s_sriov = NM_SETTING_SRIOV (nm_connection_get_setting (self, NM_TYPE_SETTING_SRIOV));
|
|
if (!s_sriov)
|
|
return FALSE;
|
|
|
|
return _nm_setting_sriov_sort_vfs (s_sriov);
|
|
}
|
|
|
|
static gboolean
|
|
_normalize_bridge_vlan_order (NMConnection *self)
|
|
{
|
|
NMSettingBridge *s_bridge;
|
|
|
|
s_bridge = nm_connection_get_setting_bridge (self);
|
|
if (!s_bridge)
|
|
return FALSE;
|
|
|
|
return _nm_setting_bridge_sort_vlans (s_bridge);
|
|
}
|
|
|
|
static gboolean
|
|
_normalize_bridge_port_vlan_order (NMConnection *self)
|
|
{
|
|
NMSettingBridgePort *s_port;
|
|
|
|
s_port = nm_connection_get_setting_bridge_port (self);
|
|
if (!s_port)
|
|
return FALSE;
|
|
|
|
return _nm_setting_bridge_port_sort_vlans (s_port);
|
|
}
|
|
|
|
static gboolean
|
|
_normalize_gsm_auto_config (NMConnection *self)
|
|
{
|
|
NMSettingGsm *s_gsm;
|
|
|
|
s_gsm = nm_connection_get_setting_gsm (self);
|
|
if (!s_gsm)
|
|
return FALSE;
|
|
|
|
if (!nm_setting_gsm_get_auto_config (s_gsm))
|
|
return FALSE;
|
|
|
|
if ( !nm_setting_gsm_get_apn (s_gsm)
|
|
&& !nm_setting_gsm_get_username (s_gsm)
|
|
&& !nm_setting_gsm_get_password (s_gsm))
|
|
return FALSE;
|
|
|
|
g_object_set (s_gsm,
|
|
NM_SETTING_GSM_AUTO_CONFIG, FALSE,
|
|
NULL);
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
_normalize_required_settings (NMConnection *self)
|
|
{
|
|
NMSettingBluetooth *s_bt = nm_connection_get_setting_bluetooth (self);
|
|
NMSetting *s_bridge;
|
|
gboolean changed = FALSE;
|
|
|
|
if (nm_connection_get_setting_vlan (self)) {
|
|
if (!nm_connection_get_setting_wired (self)) {
|
|
nm_connection_add_setting (self, nm_setting_wired_new ());
|
|
changed = TRUE;
|
|
}
|
|
}
|
|
if (s_bt && nm_streq0 (nm_setting_bluetooth_get_connection_type (s_bt), NM_SETTING_BLUETOOTH_TYPE_NAP)) {
|
|
if (!nm_connection_get_setting_bridge (self)) {
|
|
s_bridge = nm_setting_bridge_new ();
|
|
g_object_set (s_bridge, NM_SETTING_BRIDGE_STP, FALSE, NULL);
|
|
nm_connection_add_setting (self, s_bridge);
|
|
changed = TRUE;
|
|
}
|
|
}
|
|
return changed;
|
|
}
|
|
|
|
static gboolean
|
|
_normalize_invalid_slave_port_settings (NMConnection *self)
|
|
{
|
|
NMSettingConnection *s_con = nm_connection_get_setting_connection (self);
|
|
const char *slave_type;
|
|
gboolean changed = FALSE;
|
|
|
|
slave_type = nm_setting_connection_get_slave_type (s_con);
|
|
|
|
if ( !nm_streq0 (slave_type, NM_SETTING_BRIDGE_SETTING_NAME)
|
|
&& _nm_connection_remove_setting (self, NM_TYPE_SETTING_BRIDGE_PORT))
|
|
changed = TRUE;
|
|
|
|
if ( !nm_streq0 (slave_type, NM_SETTING_TEAM_SETTING_NAME)
|
|
&& _nm_connection_remove_setting (self, NM_TYPE_SETTING_TEAM_PORT))
|
|
changed = TRUE;
|
|
|
|
return changed;
|
|
}
|
|
|
|
/**
|
|
* nm_connection_verify:
|
|
* @connection: the #NMConnection to verify
|
|
* @error: location to store error, or %NULL
|
|
*
|
|
* Validates the connection and all its settings. Each setting's properties
|
|
* have allowed values, and some values are dependent on other values. For
|
|
* example, if a Wi-Fi connection is security enabled, the #NMSettingWireless
|
|
* setting object's 'security' property must contain the setting name of the
|
|
* #NMSettingWirelessSecurity object, which must also be present in the
|
|
* connection for the connection to be valid. As another example, the
|
|
* #NMSettingWired object's 'mac-address' property must be a validly formatted
|
|
* MAC address. The returned #GError contains information about which
|
|
* setting and which property failed validation, and how it failed validation.
|
|
*
|
|
* Returns: %TRUE if the connection is valid, %FALSE if it is not
|
|
**/
|
|
gboolean
|
|
nm_connection_verify (NMConnection *connection, GError **error)
|
|
{
|
|
NMSettingVerifyResult result;
|
|
|
|
result = _nm_connection_verify (connection, error);
|
|
|
|
/* we treat normalizable connections as valid. */
|
|
if (result == NM_SETTING_VERIFY_NORMALIZABLE)
|
|
g_clear_error (error);
|
|
|
|
return result == NM_SETTING_VERIFY_SUCCESS || result == NM_SETTING_VERIFY_NORMALIZABLE;
|
|
}
|
|
|
|
NMSettingVerifyResult
|
|
_nm_connection_verify (NMConnection *connection, GError **error)
|
|
{
|
|
NMSettingIPConfig *s_ip4, *s_ip6;
|
|
NMSettingProxy *s_proxy;
|
|
gs_free NMSetting **settings = NULL;
|
|
gs_free_error GError *normalizable_error = NULL;
|
|
NMSettingVerifyResult normalizable_error_type = NM_SETTING_VERIFY_SUCCESS;
|
|
guint i;
|
|
|
|
g_return_val_if_fail (NM_IS_CONNECTION (connection), NM_SETTING_VERIFY_ERROR);
|
|
g_return_val_if_fail (!error || !*error, NM_SETTING_VERIFY_ERROR);
|
|
|
|
settings = nm_connection_get_settings (connection, NULL);
|
|
if ( !settings
|
|
|| !NM_IS_SETTING_CONNECTION (settings[0])) {
|
|
g_set_error_literal (error,
|
|
NM_CONNECTION_ERROR,
|
|
NM_CONNECTION_ERROR_MISSING_SETTING,
|
|
_("setting not found"));
|
|
g_prefix_error (error, "%s: ", NM_SETTING_CONNECTION_SETTING_NAME);
|
|
return NM_SETTING_VERIFY_ERROR;
|
|
}
|
|
|
|
for (i = 0; settings[i]; i++) {
|
|
GError *verify_error = NULL;
|
|
NMSettingVerifyResult verify_result;
|
|
|
|
nm_assert (NM_IS_SETTING (settings[i]));
|
|
nm_assert (NM_IS_SETTING_CONNECTION (settings[i]) == (i == 0));
|
|
|
|
/* verify all settings. We stop if we find the first non-normalizable
|
|
* @NM_SETTING_VERIFY_ERROR. If we find normalizable errors we continue
|
|
* but remember the error to return it to the user.
|
|
* @NM_SETTING_VERIFY_NORMALIZABLE_ERROR has a higher priority then
|
|
* @NM_SETTING_VERIFY_NORMALIZABLE, so, if we encounter such an error type,
|
|
* we remember it instead (to return it as output).
|
|
**/
|
|
verify_result = _nm_setting_verify (settings[i], connection, &verify_error);
|
|
if (verify_result == NM_SETTING_VERIFY_NORMALIZABLE ||
|
|
verify_result == NM_SETTING_VERIFY_NORMALIZABLE_ERROR) {
|
|
if ( verify_result == NM_SETTING_VERIFY_NORMALIZABLE_ERROR
|
|
&& normalizable_error_type == NM_SETTING_VERIFY_NORMALIZABLE) {
|
|
/* NORMALIZABLE_ERROR has higher priority. */
|
|
g_clear_error (&normalizable_error);
|
|
}
|
|
if (!normalizable_error) {
|
|
g_propagate_error (&normalizable_error, verify_error);
|
|
verify_error = NULL;
|
|
normalizable_error_type = verify_result;
|
|
}
|
|
} else if (verify_result != NM_SETTING_VERIFY_SUCCESS) {
|
|
g_propagate_error (error, verify_error);
|
|
g_return_val_if_fail (verify_result == NM_SETTING_VERIFY_ERROR, NM_SETTING_VERIFY_ERROR);
|
|
return NM_SETTING_VERIFY_ERROR;
|
|
}
|
|
g_clear_error (&verify_error);
|
|
}
|
|
|
|
s_ip4 = nm_connection_get_setting_ip4_config (connection);
|
|
s_ip6 = nm_connection_get_setting_ip6_config (connection);
|
|
s_proxy = nm_connection_get_setting_proxy (connection);
|
|
|
|
nm_assert (normalizable_error_type != NM_SETTING_VERIFY_ERROR);
|
|
if (NM_IN_SET (normalizable_error_type, NM_SETTING_VERIFY_SUCCESS,
|
|
NM_SETTING_VERIFY_NORMALIZABLE)) {
|
|
if (_supports_addr_family (connection, AF_INET)) {
|
|
if (!s_ip4 && normalizable_error_type == NM_SETTING_VERIFY_SUCCESS) {
|
|
g_set_error_literal (&normalizable_error,
|
|
NM_CONNECTION_ERROR,
|
|
NM_CONNECTION_ERROR_MISSING_SETTING,
|
|
_("setting is required for non-slave connections"));
|
|
g_prefix_error (&normalizable_error, "%s: ", NM_SETTING_IP4_CONFIG_SETTING_NAME);
|
|
|
|
/* having a master without IP config was not a verify() error, accept
|
|
* it for backward compatibility. */
|
|
normalizable_error_type = NM_SETTING_VERIFY_NORMALIZABLE;
|
|
}
|
|
} else {
|
|
if (s_ip4) {
|
|
g_clear_error (&normalizable_error);
|
|
g_set_error_literal (&normalizable_error,
|
|
NM_CONNECTION_ERROR,
|
|
NM_CONNECTION_ERROR_INVALID_SETTING,
|
|
_("setting not allowed in slave connection"));
|
|
g_prefix_error (&normalizable_error, "%s: ", NM_SETTING_IP4_CONFIG_SETTING_NAME);
|
|
/* having a slave with IP config *was* and is a verify() error. */
|
|
normalizable_error_type = NM_SETTING_VERIFY_NORMALIZABLE_ERROR;
|
|
}
|
|
}
|
|
|
|
if (_supports_addr_family (connection, AF_INET6)) {
|
|
if (!s_ip6 && normalizable_error_type == NM_SETTING_VERIFY_SUCCESS) {
|
|
g_set_error_literal (&normalizable_error,
|
|
NM_CONNECTION_ERROR,
|
|
NM_CONNECTION_ERROR_MISSING_SETTING,
|
|
_("setting is required for non-slave connections"));
|
|
g_prefix_error (&normalizable_error, "%s: ", NM_SETTING_IP6_CONFIG_SETTING_NAME);
|
|
|
|
/* having a master without IP config was not a verify() error, accept
|
|
* it for backward compatibility. */
|
|
normalizable_error_type = NM_SETTING_VERIFY_NORMALIZABLE;
|
|
}
|
|
} else {
|
|
if (s_ip6) {
|
|
g_clear_error (&normalizable_error);
|
|
g_set_error_literal (&normalizable_error,
|
|
NM_CONNECTION_ERROR,
|
|
NM_CONNECTION_ERROR_INVALID_SETTING,
|
|
_("setting not allowed in slave connection"));
|
|
g_prefix_error (&normalizable_error, "%s: ", NM_SETTING_IP6_CONFIG_SETTING_NAME);
|
|
/* having a slave with IP config *was* and is a verify() error. */
|
|
normalizable_error_type = NM_SETTING_VERIFY_NORMALIZABLE_ERROR;
|
|
}
|
|
}
|
|
|
|
if (_supports_addr_family (connection, AF_UNSPEC)) {
|
|
if (!s_proxy && normalizable_error_type == NM_SETTING_VERIFY_SUCCESS) {
|
|
g_set_error_literal (&normalizable_error,
|
|
NM_CONNECTION_ERROR,
|
|
NM_CONNECTION_ERROR_MISSING_SETTING,
|
|
_("setting is required for non-slave connections"));
|
|
g_prefix_error (&normalizable_error, "%s: ", NM_SETTING_PROXY_SETTING_NAME);
|
|
|
|
/* having a master without proxy config was not a verify() error, accept
|
|
* it for backward compatibility. */
|
|
normalizable_error_type = NM_SETTING_VERIFY_NORMALIZABLE;
|
|
}
|
|
} else {
|
|
if (s_proxy) {
|
|
g_clear_error (&normalizable_error);
|
|
g_set_error_literal (&normalizable_error,
|
|
NM_CONNECTION_ERROR,
|
|
NM_CONNECTION_ERROR_INVALID_SETTING,
|
|
_("setting not allowed in slave connection"));
|
|
g_prefix_error (&normalizable_error, "%s: ", NM_SETTING_PROXY_SETTING_NAME);
|
|
/* having a slave with proxy config *was* and is a verify() error. */
|
|
normalizable_error_type = NM_SETTING_VERIFY_NORMALIZABLE_ERROR;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (normalizable_error_type != NM_SETTING_VERIFY_SUCCESS) {
|
|
g_propagate_error (error, normalizable_error);
|
|
normalizable_error = NULL;
|
|
return normalizable_error_type;
|
|
}
|
|
|
|
return NM_SETTING_VERIFY_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
* nm_connection_verify_secrets:
|
|
* @connection: the #NMConnection to verify in
|
|
* @error: location to store error, or %NULL
|
|
*
|
|
* Verifies the secrets in the connection.
|
|
*
|
|
* Returns: %TRUE if the secrets are valid, %FALSE if they are not
|
|
*
|
|
* Since: 1.2
|
|
**/
|
|
gboolean
|
|
nm_connection_verify_secrets (NMConnection *connection, GError **error)
|
|
{
|
|
GHashTableIter iter;
|
|
NMSetting *setting;
|
|
|
|
g_return_val_if_fail (NM_IS_CONNECTION (connection), FALSE);
|
|
g_return_val_if_fail (!error || !*error, FALSE);
|
|
|
|
g_hash_table_iter_init (&iter, NM_CONNECTION_GET_PRIVATE (connection)->settings);
|
|
while (g_hash_table_iter_next (&iter, NULL, (gpointer) &setting)) {
|
|
if (!nm_setting_verify_secrets (setting, connection, error))
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
_connection_normalize (NMConnection *connection,
|
|
GHashTable *parameters,
|
|
gboolean *modified,
|
|
GError **error)
|
|
{
|
|
NMSettingVerifyResult success;
|
|
gboolean was_modified;
|
|
|
|
#if NM_MORE_ASSERTS > 10
|
|
/* only call this _nm_connection_verify() confirms that the connection
|
|
* requires normalization and is normalizable. */
|
|
nm_assert (NM_IN_SET (_nm_connection_verify (connection, NULL),
|
|
NM_SETTING_VERIFY_NORMALIZABLE,
|
|
NM_SETTING_VERIFY_NORMALIZABLE_ERROR));
|
|
#endif
|
|
|
|
/* Try to perform all kind of normalizations on the settings to fix it.
|
|
* We only do this, after verifying that the connection contains no un-normalizable
|
|
* errors, because in that case we rather fail without touching the settings. */
|
|
|
|
was_modified = FALSE;
|
|
|
|
was_modified |= _normalize_connection_uuid (connection);
|
|
was_modified |= _normalize_connection_type (connection);
|
|
was_modified |= _normalize_connection_slave_type (connection);
|
|
was_modified |= _normalize_required_settings (connection);
|
|
was_modified |= _normalize_invalid_slave_port_settings (connection);
|
|
was_modified |= _normalize_ip_config (connection, parameters);
|
|
was_modified |= _normalize_ethernet_link_neg (connection);
|
|
was_modified |= _normalize_infiniband_mtu (connection);
|
|
was_modified |= _normalize_bond_mode (connection);
|
|
was_modified |= _normalize_bond_options (connection);
|
|
was_modified |= _normalize_wireless_mac_address_randomization (connection);
|
|
was_modified |= _normalize_macsec (connection);
|
|
was_modified |= _normalize_team_config (connection);
|
|
was_modified |= _normalize_team_port_config (connection);
|
|
was_modified |= _normalize_bluetooth_type (connection);
|
|
was_modified |= _normalize_ovs_interface_type (connection);
|
|
was_modified |= _normalize_ip_tunnel_wired_setting (connection);
|
|
was_modified |= _normalize_sriov_vf_order (connection);
|
|
was_modified |= _normalize_bridge_vlan_order (connection);
|
|
was_modified |= _normalize_bridge_port_vlan_order (connection);
|
|
was_modified |= _normalize_gsm_auto_config (connection);
|
|
|
|
was_modified = !!was_modified;
|
|
|
|
/* Verify anew */
|
|
success = _nm_connection_verify (connection, error);
|
|
|
|
NM_SET_OUT (modified, was_modified);
|
|
|
|
if (success != NM_SETTING_VERIFY_SUCCESS) {
|
|
/* we would expect, that after normalization, the connection can be verified.
|
|
* Also treat NM_SETTING_VERIFY_NORMALIZABLE as failure, because there is something
|
|
* odd going on. */
|
|
if (error && !*error) {
|
|
g_set_error_literal (error,
|
|
NM_CONNECTION_ERROR,
|
|
NM_CONNECTION_ERROR_FAILED,
|
|
_("Unexpected failure to normalize the connection"));
|
|
}
|
|
g_warning ("connection did not verify after normalization: %s", error ? (*error)->message : "??");
|
|
g_return_val_if_reached (FALSE);
|
|
}
|
|
|
|
/* we would expect, that the connection was modified during normalization. */
|
|
g_return_val_if_fail (was_modified, TRUE);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/**
|
|
* nm_connection_normalize:
|
|
* @connection: the #NMConnection to normalize
|
|
* @parameters: (allow-none) (element-type utf8 gpointer): a #GHashTable with
|
|
* normalization parameters to allow customization of the normalization by providing
|
|
* specific arguments. Unknown arguments will be ignored and the default will be
|
|
* used. The keys must be strings compared with g_str_equal() function.
|
|
* The values are opaque and depend on the parameter name.
|
|
* @modified: (out) (allow-none): outputs whether any settings were modified.
|
|
* @error: location to store error, or %NULL. Contains the reason,
|
|
* why the connection is invalid, if the function returns an error.
|
|
*
|
|
* Does some basic normalization and fixup of well known inconsistencies
|
|
* and deprecated fields. If the connection was modified in any way,
|
|
* the output parameter @modified is set %TRUE.
|
|
*
|
|
* Finally the connection will be verified and %TRUE returns if the connection
|
|
* is valid. As this function only performs some specific normalization steps
|
|
* it cannot repair all connections. If the connection has errors that
|
|
* cannot be normalized, the connection will not be modified.
|
|
*
|
|
* Returns: %TRUE if the connection is valid, %FALSE if it is not
|
|
**/
|
|
gboolean
|
|
nm_connection_normalize (NMConnection *connection,
|
|
GHashTable *parameters,
|
|
gboolean *modified,
|
|
GError **error)
|
|
{
|
|
NMSettingVerifyResult success;
|
|
gs_free_error GError *normalizable_error = NULL;
|
|
|
|
success = _nm_connection_verify (connection, &normalizable_error);
|
|
|
|
if (!NM_IN_SET (success,
|
|
NM_SETTING_VERIFY_NORMALIZABLE,
|
|
NM_SETTING_VERIFY_NORMALIZABLE_ERROR)) {
|
|
if (normalizable_error) {
|
|
nm_assert (success == NM_SETTING_VERIFY_ERROR);
|
|
g_propagate_error (error, g_steal_pointer (&normalizable_error));
|
|
} else
|
|
nm_assert (success == NM_SETTING_VERIFY_SUCCESS);
|
|
|
|
NM_SET_OUT (modified, FALSE);
|
|
|
|
if (success != NM_SETTING_VERIFY_SUCCESS) {
|
|
if ( error
|
|
&& !*error) {
|
|
g_set_error_literal (error,
|
|
NM_CONNECTION_ERROR,
|
|
NM_CONNECTION_ERROR_FAILED,
|
|
_("Unexpected failure to verify the connection"));
|
|
return FALSE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
if (error && *error)
|
|
return FALSE;
|
|
return TRUE;
|
|
}
|
|
|
|
return _connection_normalize (connection, parameters, modified, error);
|
|
}
|
|
|
|
gboolean
|
|
_nm_connection_ensure_normalized (NMConnection *connection,
|
|
gboolean allow_modify,
|
|
const char *expected_uuid,
|
|
gboolean coerce_uuid,
|
|
NMConnection **out_connection_clone,
|
|
GError **error)
|
|
{
|
|
gs_unref_object NMConnection *connection_clone = NULL;
|
|
gs_free_error GError *local = NULL;
|
|
NMSettingVerifyResult vresult;
|
|
|
|
nm_assert (NM_IS_CONNECTION (connection));
|
|
nm_assert (!out_connection_clone || !*out_connection_clone);
|
|
nm_assert (!expected_uuid || nm_utils_is_uuid (expected_uuid));
|
|
|
|
if (expected_uuid) {
|
|
if (nm_streq0 (expected_uuid, nm_connection_get_uuid (connection)))
|
|
expected_uuid = NULL;
|
|
else if ( !coerce_uuid
|
|
|| (!allow_modify && !out_connection_clone)) {
|
|
g_set_error (error, NM_CONNECTION_ERROR, NM_CONNECTION_ERROR_INVALID_PROPERTY,
|
|
_("unexpected uuid %s instead of %s"),
|
|
nm_connection_get_uuid (connection),
|
|
expected_uuid);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
vresult = _nm_connection_verify (connection, &local);
|
|
if (vresult != NM_SETTING_VERIFY_SUCCESS) {
|
|
if (!NM_IN_SET (vresult, NM_SETTING_VERIFY_NORMALIZABLE,
|
|
NM_SETTING_VERIFY_NORMALIZABLE_ERROR)) {
|
|
g_propagate_error (error, g_steal_pointer (&local));
|
|
return FALSE;
|
|
}
|
|
if (!allow_modify) {
|
|
if (!out_connection_clone) {
|
|
/* even NM_SETTING_VERIFY_NORMALIZABLE is treated as an error. We could normalize,
|
|
* but are not allowed to (and no out argument is provided for cloning). */
|
|
g_propagate_error (error, g_steal_pointer (&local));
|
|
return FALSE;
|
|
}
|
|
connection_clone = nm_simple_connection_new_clone (connection);
|
|
connection = connection_clone;
|
|
}
|
|
if (!_connection_normalize (connection, NULL, NULL, error))
|
|
g_return_val_if_reached (FALSE);
|
|
}
|
|
|
|
if (expected_uuid) {
|
|
NMSettingConnection *s_con;
|
|
|
|
if ( !allow_modify
|
|
&& !connection_clone) {
|
|
nm_assert (out_connection_clone);
|
|
connection_clone = nm_simple_connection_new_clone (connection);
|
|
connection = connection_clone;
|
|
}
|
|
s_con = nm_connection_get_setting_connection (connection);
|
|
g_object_set (s_con,
|
|
NM_SETTING_CONNECTION_UUID,
|
|
expected_uuid,
|
|
NULL);
|
|
}
|
|
|
|
NM_SET_OUT (out_connection_clone, g_steal_pointer (&connection_clone));
|
|
return TRUE;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
#if NM_MORE_ASSERTS
|
|
static void
|
|
_nmtst_connection_unchanging_changed_cb (NMConnection *connection, gpointer user_data)
|
|
{
|
|
nm_assert_not_reached ();
|
|
}
|
|
|
|
static void
|
|
_nmtst_connection_unchanging_secrets_updated_cb (NMConnection *connection, const char *setting_name, gpointer user_data)
|
|
{
|
|
nm_assert_not_reached ();
|
|
}
|
|
|
|
const char _nmtst_connection_unchanging_user_data = 0;
|
|
|
|
void
|
|
nmtst_connection_assert_unchanging (NMConnection *connection)
|
|
{
|
|
if (!connection)
|
|
return;
|
|
|
|
nm_assert (NM_IS_CONNECTION (connection));
|
|
|
|
if (g_signal_handler_find (connection,
|
|
G_SIGNAL_MATCH_DATA,
|
|
0,
|
|
0,
|
|
NULL,
|
|
NULL,
|
|
(gpointer) &_nmtst_connection_unchanging_user_data) != 0) {
|
|
/* avoid connecting the assertion handler multiple times. */
|
|
return;
|
|
}
|
|
|
|
g_signal_connect (connection,
|
|
NM_CONNECTION_CHANGED,
|
|
G_CALLBACK (_nmtst_connection_unchanging_changed_cb),
|
|
(gpointer) &_nmtst_connection_unchanging_user_data);
|
|
g_signal_connect (connection,
|
|
NM_CONNECTION_SECRETS_CLEARED,
|
|
G_CALLBACK (_nmtst_connection_unchanging_changed_cb),
|
|
(gpointer) &_nmtst_connection_unchanging_user_data);
|
|
g_signal_connect (connection,
|
|
NM_CONNECTION_SECRETS_UPDATED,
|
|
G_CALLBACK (_nmtst_connection_unchanging_secrets_updated_cb),
|
|
(gpointer) &_nmtst_connection_unchanging_user_data);
|
|
}
|
|
#endif
|
|
|
|
/*****************************************************************************/
|
|
|
|
/**
|
|
* nm_connection_update_secrets:
|
|
* @connection: the #NMConnection
|
|
* @setting_name: the setting object name to which the secrets apply
|
|
* @secrets: a #GVariant of secrets, of type %NM_VARIANT_TYPE_CONNECTION
|
|
* or %NM_VARIANT_TYPE_SETTING
|
|
* @error: location to store error, or %NULL
|
|
*
|
|
* Update the specified setting's secrets, given a dictionary of secrets
|
|
* intended for that setting (deserialized from D-Bus for example). Will also
|
|
* extract the given setting's secrets hash if given a connection dictionary.
|
|
* If @setting_name is %NULL, expects a fully serialized #NMConnection as
|
|
* returned by nm_connection_to_dbus() and will update all secrets from all
|
|
* settings contained in @secrets.
|
|
*
|
|
* Returns: %TRUE if the secrets were successfully updated, %FALSE if the update
|
|
* failed (tried to update secrets for a setting that doesn't exist, etc)
|
|
**/
|
|
gboolean
|
|
nm_connection_update_secrets (NMConnection *connection,
|
|
const char *setting_name,
|
|
GVariant *secrets,
|
|
GError **error)
|
|
{
|
|
NMSetting *setting;
|
|
gboolean success = TRUE;
|
|
gboolean updated = FALSE;
|
|
GVariant *setting_dict = NULL;
|
|
GVariantIter iter;
|
|
const char *key;
|
|
gboolean full_connection;
|
|
int success_detail;
|
|
|
|
g_return_val_if_fail (NM_IS_CONNECTION (connection), FALSE);
|
|
|
|
full_connection = g_variant_is_of_type (secrets, NM_VARIANT_TYPE_CONNECTION);
|
|
|
|
g_return_val_if_fail ( full_connection
|
|
|| g_variant_is_of_type (secrets, NM_VARIANT_TYPE_SETTING), FALSE);
|
|
g_return_val_if_fail (!error || !*error, FALSE);
|
|
g_return_val_if_fail (setting_name || full_connection, FALSE);
|
|
|
|
/* Empty @secrets means success */
|
|
if (g_variant_n_children (secrets) == 0)
|
|
return TRUE;
|
|
|
|
if (setting_name) {
|
|
/* Update just one setting's secrets */
|
|
setting = nm_connection_get_setting_by_name (connection, setting_name);
|
|
if (!setting) {
|
|
g_set_error_literal (error,
|
|
NM_CONNECTION_ERROR,
|
|
NM_CONNECTION_ERROR_SETTING_NOT_FOUND,
|
|
setting_name);
|
|
return FALSE;
|
|
}
|
|
|
|
if (full_connection) {
|
|
setting_dict = g_variant_lookup_value (secrets, setting_name, NM_VARIANT_TYPE_SETTING);
|
|
if (!setting_dict) {
|
|
/* The connection dictionary didn't contain any secrets for
|
|
* @setting_name; just return success.
|
|
*/
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
g_signal_handlers_block_by_func (setting, (GCallback) setting_changed_cb, connection);
|
|
success_detail = _nm_setting_update_secrets (setting,
|
|
setting_dict ?: secrets,
|
|
error);
|
|
g_signal_handlers_unblock_by_func (setting, (GCallback) setting_changed_cb, connection);
|
|
|
|
nm_clear_pointer (&setting_dict, g_variant_unref);
|
|
|
|
if (success_detail == NM_SETTING_UPDATE_SECRET_ERROR) {
|
|
nm_assert (!error || *error);
|
|
return FALSE;
|
|
}
|
|
if (success_detail == NM_SETTING_UPDATE_SECRET_SUCCESS_MODIFIED)
|
|
updated = TRUE;
|
|
} else {
|
|
/* check first, whether all the settings exist... */
|
|
g_variant_iter_init (&iter, secrets);
|
|
while (g_variant_iter_next (&iter, "{&s@a{sv}}", &key, NULL)) {
|
|
setting = nm_connection_get_setting_by_name (connection, key);
|
|
if (!setting) {
|
|
g_set_error_literal (error,
|
|
NM_CONNECTION_ERROR,
|
|
NM_CONNECTION_ERROR_SETTING_NOT_FOUND,
|
|
key);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
/* Update each setting with any secrets from the connection dictionary */
|
|
g_variant_iter_init (&iter, secrets);
|
|
while (g_variant_iter_next (&iter, "{&s@a{sv}}", &key, &setting_dict)) {
|
|
gs_free_error GError *local = NULL;
|
|
|
|
/* Update the secrets for this setting */
|
|
setting = nm_connection_get_setting_by_name (connection, key);
|
|
|
|
g_signal_handlers_block_by_func (setting, (GCallback) setting_changed_cb, connection);
|
|
success_detail = _nm_setting_update_secrets (setting, setting_dict, error ? &local : NULL);
|
|
g_signal_handlers_unblock_by_func (setting, (GCallback) setting_changed_cb, connection);
|
|
|
|
g_variant_unref (setting_dict);
|
|
|
|
if (success_detail == NM_SETTING_UPDATE_SECRET_ERROR) {
|
|
if (success) {
|
|
if (error) {
|
|
nm_assert (local);
|
|
g_propagate_error (error, g_steal_pointer (&local));
|
|
error = NULL;
|
|
} else
|
|
nm_assert (!local);
|
|
success = FALSE;
|
|
}
|
|
break;
|
|
}
|
|
if (success_detail == NM_SETTING_UPDATE_SECRET_SUCCESS_MODIFIED)
|
|
updated = TRUE;
|
|
}
|
|
}
|
|
|
|
if (updated)
|
|
g_signal_emit (connection, signals[SECRETS_UPDATED], 0, setting_name);
|
|
|
|
return success;
|
|
}
|
|
|
|
/**
|
|
* nm_connection_need_secrets:
|
|
* @connection: the #NMConnection
|
|
* @hints: (out) (element-type utf8) (allow-none) (transfer container):
|
|
* the address of a pointer to a #GPtrArray, initialized to %NULL, which on
|
|
* return points to an allocated #GPtrArray containing the property names of
|
|
* secrets of the #NMSetting which may be required; the caller owns the array
|
|
* and must free the array itself with g_ptr_array_free(), but not free its
|
|
* elements
|
|
*
|
|
* Returns the name of the first setting object in the connection which would
|
|
* need secrets to make a successful connection. The returned hints are only
|
|
* intended as a guide to what secrets may be required, because in some
|
|
* circumstances, there is no way to conclusively determine exactly which
|
|
* secrets are needed.
|
|
*
|
|
* Returns: the setting name of the #NMSetting object which has invalid or
|
|
* missing secrets
|
|
**/
|
|
const char *
|
|
nm_connection_need_secrets (NMConnection *connection,
|
|
GPtrArray **hints)
|
|
{
|
|
NMConnectionPrivate *priv;
|
|
GHashTableIter hiter;
|
|
GSList *settings = NULL;
|
|
GSList *iter;
|
|
const char *name = NULL;
|
|
NMSetting *setting;
|
|
|
|
g_return_val_if_fail (NM_IS_CONNECTION (connection), NULL);
|
|
if (hints)
|
|
g_return_val_if_fail (*hints == NULL, NULL);
|
|
|
|
priv = NM_CONNECTION_GET_PRIVATE (connection);
|
|
|
|
/* Get list of settings in priority order */
|
|
g_hash_table_iter_init (&hiter, priv->settings);
|
|
while (g_hash_table_iter_next (&hiter, NULL, (gpointer) &setting))
|
|
settings = g_slist_insert_sorted (settings, setting, _nm_setting_compare_priority);
|
|
|
|
for (iter = settings; iter; iter = g_slist_next (iter)) {
|
|
GPtrArray *secrets;
|
|
|
|
setting = NM_SETTING (iter->data);
|
|
secrets = _nm_setting_need_secrets (setting);
|
|
if (secrets) {
|
|
if (hints)
|
|
*hints = secrets;
|
|
else
|
|
g_ptr_array_free (secrets, TRUE);
|
|
|
|
name = nm_setting_get_name (setting);
|
|
break;
|
|
}
|
|
}
|
|
|
|
g_slist_free (settings);
|
|
return name;
|
|
}
|
|
|
|
/**
|
|
* nm_connection_clear_secrets:
|
|
* @connection: the #NMConnection
|
|
*
|
|
* Clears and frees any secrets that may be stored in the connection, to avoid
|
|
* keeping secret data in memory when not needed.
|
|
**/
|
|
void
|
|
nm_connection_clear_secrets (NMConnection *connection)
|
|
{
|
|
return nm_connection_clear_secrets_with_flags (connection, NULL, NULL);
|
|
}
|
|
|
|
/**
|
|
* nm_connection_clear_secrets_with_flags:
|
|
* @connection: the #NMConnection
|
|
* @func: (scope call) (allow-none): function to be called to determine whether a
|
|
* specific secret should be cleared or not. If %NULL, all secrets are cleared.
|
|
* @user_data: caller-supplied data passed to @func
|
|
*
|
|
* Clears and frees secrets determined by @func.
|
|
**/
|
|
void
|
|
nm_connection_clear_secrets_with_flags (NMConnection *connection,
|
|
NMSettingClearSecretsWithFlagsFn func,
|
|
gpointer user_data)
|
|
{
|
|
GHashTableIter iter;
|
|
NMSetting *setting;
|
|
|
|
g_return_if_fail (NM_IS_CONNECTION (connection));
|
|
|
|
g_hash_table_iter_init (&iter, NM_CONNECTION_GET_PRIVATE (connection)->settings);
|
|
while (g_hash_table_iter_next (&iter, NULL, (gpointer) &setting)) {
|
|
g_signal_handlers_block_by_func (setting, (GCallback) setting_changed_cb, connection);
|
|
_nm_setting_clear_secrets (setting, func, user_data);
|
|
g_signal_handlers_unblock_by_func (setting, (GCallback) setting_changed_cb, connection);
|
|
}
|
|
|
|
g_signal_emit (connection, signals[SECRETS_CLEARED], 0);
|
|
}
|
|
|
|
static gboolean
|
|
_clear_secrets_by_secret_flags_cb (NMSetting *setting,
|
|
const char *secret,
|
|
NMSettingSecretFlags flags,
|
|
gpointer user_data)
|
|
{
|
|
NMSettingSecretFlags filter_flags = GPOINTER_TO_UINT (user_data);
|
|
gboolean remove_secret;
|
|
|
|
if (filter_flags == NM_SETTING_SECRET_FLAG_NONE) {
|
|
/* Can't use bitops with SECRET_FLAG_NONE so handle that specifically */
|
|
remove_secret = (flags != NM_SETTING_SECRET_FLAG_NONE);
|
|
} else {
|
|
/* Otherwise, if the secret has at least one of the desired flags keep it */
|
|
remove_secret = !NM_FLAGS_ANY (flags, filter_flags);
|
|
}
|
|
|
|
return remove_secret;
|
|
}
|
|
|
|
/**
|
|
* _nm_connection_clear_secrets_by_secret_flags:
|
|
* @self: the #NMConnection to filter (will be modified)
|
|
* @filter_flags: the secret flags to control whether to drop/remove
|
|
* a secret or to keep it. The meaning of the filter flags is to
|
|
* preserve the secrets. The secrets that have matching (see below)
|
|
* flags are kept, the others are dropped.
|
|
*
|
|
* Removes/drops secrets from @self according to @filter_flags.
|
|
* If @filter_flags is %NM_SETTING_SECRET_NONE, then only secrets that
|
|
* have %NM_SETTING_SECRET_NONE flags are kept.
|
|
* Otherwise, only secrets with secret flags are kept that have at least
|
|
* one of the filter flags.
|
|
*/
|
|
void
|
|
_nm_connection_clear_secrets_by_secret_flags (NMConnection *self,
|
|
NMSettingSecretFlags filter_flags)
|
|
{
|
|
nm_connection_clear_secrets_with_flags (self,
|
|
_clear_secrets_by_secret_flags_cb,
|
|
GUINT_TO_POINTER (filter_flags));
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
|
|
/*****************************************************************************/
|
|
|
|
/* Returns always a non-NULL, floating variant that must
|
|
* be unrefed by the caller. */
|
|
GVariant *
|
|
_nm_connection_for_each_secret (NMConnection *self,
|
|
GVariant *secrets,
|
|
gboolean remove_non_secrets,
|
|
_NMConnectionForEachSecretFunc callback,
|
|
gpointer callback_data)
|
|
{
|
|
GVariantBuilder secrets_builder;
|
|
GVariantBuilder setting_builder;
|
|
GVariantIter secrets_iter;
|
|
GVariantIter *setting_iter;
|
|
const char *setting_name;
|
|
|
|
/* This function, given a dict of dicts representing new secrets of
|
|
* an NMConnection, walks through each toplevel dict (which represents a
|
|
* NMSetting), and for each setting, walks through that setting dict's
|
|
* properties. For each property that's a secret, it will check that
|
|
* secret's flags in the backing NMConnection object, and call a supplied
|
|
* callback.
|
|
*
|
|
* The one complexity is that the VPN setting's 'secrets' property is
|
|
* *also* a dict (since the key/value pairs are arbitrary and known
|
|
* only to the VPN plugin itself). That means we have three levels of
|
|
* dicts that we potentially have to traverse here. The differences
|
|
* are handled by the virtual for_each_secret() function.
|
|
*/
|
|
|
|
g_return_val_if_fail (callback, NULL);
|
|
|
|
g_variant_iter_init (&secrets_iter, secrets);
|
|
g_variant_builder_init (&secrets_builder, NM_VARIANT_TYPE_CONNECTION);
|
|
while (g_variant_iter_next (&secrets_iter, "{&sa{sv}}", &setting_name, &setting_iter)) {
|
|
_nm_unused nm_auto_free_variant_iter GVariantIter *setting_iter_free = setting_iter;
|
|
NMSetting *setting;
|
|
const char *secret_name;
|
|
GVariant *val;
|
|
|
|
setting = nm_connection_get_setting_by_name (self, setting_name);
|
|
if (!setting)
|
|
continue;
|
|
|
|
g_variant_builder_init (&setting_builder, NM_VARIANT_TYPE_SETTING);
|
|
while (g_variant_iter_next (setting_iter, "{&sv}", &secret_name, &val)) {
|
|
_nm_unused gs_unref_variant GVariant *val_free = val;
|
|
|
|
NM_SETTING_GET_CLASS (setting)->for_each_secret (setting,
|
|
secret_name,
|
|
val,
|
|
remove_non_secrets,
|
|
callback,
|
|
callback_data,
|
|
&setting_builder);
|
|
}
|
|
|
|
g_variant_builder_add (&secrets_builder, "{sa{sv}}", setting_name, &setting_builder);
|
|
}
|
|
|
|
return g_variant_builder_end (&secrets_builder);
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
typedef struct {
|
|
NMConnectionFindSecretFunc find_func;
|
|
gpointer find_func_data;
|
|
gboolean found;
|
|
} FindSecretData;
|
|
|
|
static gboolean
|
|
find_secret_for_each_func (NMSettingSecretFlags flags,
|
|
gpointer user_data)
|
|
{
|
|
FindSecretData *data = user_data;
|
|
|
|
if (!data->found)
|
|
data->found = data->find_func (flags, data->find_func_data);
|
|
return FALSE;
|
|
}
|
|
|
|
gboolean
|
|
_nm_connection_find_secret (NMConnection *self,
|
|
GVariant *secrets,
|
|
NMConnectionFindSecretFunc callback,
|
|
gpointer callback_data)
|
|
{
|
|
gs_unref_variant GVariant *dummy = NULL;
|
|
FindSecretData data = {
|
|
.find_func = callback,
|
|
.find_func_data = callback_data,
|
|
.found = FALSE,
|
|
};
|
|
|
|
dummy = _nm_connection_for_each_secret (self, secrets, FALSE, find_secret_for_each_func, &data);
|
|
return data.found;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
/**
|
|
* nm_connection_to_dbus:
|
|
* @connection: the #NMConnection
|
|
* @flags: serialization flags, e.g. %NM_CONNECTION_SERIALIZE_ALL
|
|
*
|
|
* Converts the #NMConnection into a #GVariant of type
|
|
* %NM_VARIANT_TYPE_CONNECTION describing the connection, suitable for
|
|
* marshalling over D-Bus or otherwise serializing.
|
|
*
|
|
* Returns: (transfer none): a new floating #GVariant describing the connection,
|
|
* its settings, and each setting's properties.
|
|
**/
|
|
GVariant *
|
|
nm_connection_to_dbus (NMConnection *connection,
|
|
NMConnectionSerializationFlags flags)
|
|
{
|
|
return nm_connection_to_dbus_full (connection, flags, NULL);
|
|
}
|
|
|
|
GVariant *
|
|
nm_connection_to_dbus_full (NMConnection *connection,
|
|
NMConnectionSerializationFlags flags,
|
|
const NMConnectionSerializationOptions *options)
|
|
{
|
|
GVariantBuilder builder;
|
|
gboolean any = FALSE;
|
|
gs_free NMSetting **settings = NULL;
|
|
guint settings_len = 0;
|
|
guint i;
|
|
|
|
g_return_val_if_fail (NM_IS_CONNECTION (connection), NULL);
|
|
|
|
settings = nm_connection_get_settings (connection, &settings_len);
|
|
for (i = 0; i < settings_len; i++) {
|
|
NMSetting *setting = settings[i];
|
|
GVariant *setting_dict;
|
|
|
|
setting_dict = _nm_setting_to_dbus (setting, connection, flags, options);
|
|
if (!setting_dict)
|
|
continue;
|
|
if (!any) {
|
|
any = TRUE;
|
|
g_variant_builder_init (&builder, NM_VARIANT_TYPE_CONNECTION);
|
|
}
|
|
g_variant_builder_add (&builder, "{s@a{sv}}", nm_setting_get_name (setting), setting_dict);
|
|
}
|
|
|
|
if (!any)
|
|
return NULL;
|
|
|
|
return g_variant_builder_end (&builder);
|
|
}
|
|
|
|
/**
|
|
* nm_connection_is_type:
|
|
* @connection: the #NMConnection
|
|
* @type: a setting name to check the connection's type against (like
|
|
* %NM_SETTING_WIRELESS_SETTING_NAME or %NM_SETTING_WIRED_SETTING_NAME)
|
|
*
|
|
* A convenience function to check if the given @connection is a particular
|
|
* type (ie wired, Wi-Fi, ppp, etc). Checks the #NMSettingConnection:type
|
|
* property of the connection and matches that against @type.
|
|
*
|
|
* Returns: %TRUE if the connection is of the given @type, %FALSE if not
|
|
**/
|
|
gboolean
|
|
nm_connection_is_type (NMConnection *connection, const char *type)
|
|
{
|
|
g_return_val_if_fail (type, FALSE);
|
|
|
|
return nm_streq0 (type, nm_connection_get_connection_type (connection));
|
|
}
|
|
|
|
static int
|
|
_get_settings_sort (gconstpointer p_a, gconstpointer p_b, gpointer unused)
|
|
{
|
|
NMSetting *a = *((NMSetting **) p_a);
|
|
NMSetting *b = *((NMSetting **) p_b);
|
|
|
|
nm_assert (NM_IS_SETTING (a));
|
|
nm_assert (NM_IS_SETTING (b));
|
|
nm_assert (a != b);
|
|
nm_assert (G_OBJECT_TYPE (a) != G_OBJECT_TYPE (b));
|
|
|
|
NM_CMP_RETURN (_nm_setting_compare_priority (a, b));
|
|
NM_CMP_DIRECT_STRCMP (nm_setting_get_name (a), nm_setting_get_name (b));
|
|
|
|
nm_assert_not_reached ();
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* nm_connection_get_settings:
|
|
* @connection: the #NMConnection instance
|
|
* @out_length: (allow-none) (out): the length of the returned array
|
|
*
|
|
* Retrieves the settings in @connection.
|
|
*
|
|
* The returned array is %NULL-terminated.
|
|
*
|
|
* Returns: (array length=out_length) (transfer container): a
|
|
* %NULL-terminated array containing every setting of
|
|
* @connection.
|
|
* If the connection has no settings, %NULL is returned.
|
|
*
|
|
* Since: 1.10
|
|
*/
|
|
NMSetting **
|
|
nm_connection_get_settings (NMConnection *connection,
|
|
guint *out_length)
|
|
{
|
|
g_return_val_if_fail (NM_IS_CONNECTION (connection), NULL);
|
|
|
|
return (NMSetting **) nm_utils_hash_values_to_array (NM_CONNECTION_GET_PRIVATE (connection)->settings,
|
|
_get_settings_sort,
|
|
NULL,
|
|
out_length);
|
|
}
|
|
|
|
/**
|
|
* nm_connection_for_each_setting_value:
|
|
* @connection: the #NMConnection
|
|
* @func: (scope call): user-supplied function called for each setting's property
|
|
* @user_data: user data passed to @func at each invocation
|
|
*
|
|
* Iterates over the properties of each #NMSetting object in the #NMConnection,
|
|
* calling the supplied user function for each property.
|
|
**/
|
|
void
|
|
nm_connection_for_each_setting_value (NMConnection *connection,
|
|
NMSettingValueIterFn func,
|
|
gpointer user_data)
|
|
{
|
|
gs_free NMSetting **settings = NULL;
|
|
guint i, length = 0;
|
|
|
|
g_return_if_fail (NM_IS_CONNECTION (connection));
|
|
g_return_if_fail (func);
|
|
|
|
settings = nm_connection_get_settings (connection, &length);
|
|
for (i = 0; i < length; i++)
|
|
nm_setting_enumerate_values (settings[i], func, user_data);
|
|
}
|
|
|
|
/**
|
|
* _nm_connection_aggregate:
|
|
* @connection: the #NMConnection for which values are to be aggregated.
|
|
* @type: one of the supported aggregate types.
|
|
* @arg: the input/output argument that depends on @type.
|
|
*
|
|
* For example, with %NM_CONNECTION_AGGREGATE_ANY_SECRETS and
|
|
* %NM_CONNECTION_AGGREGATE_ANY_SYSTEM_SECRET_FLAGS @arg is a boolean
|
|
* output argument. It is either %NULL or a pointer to an gboolean
|
|
* out-argument. The function will always set @arg if given.
|
|
* Also, the return value of the function is likewise the result
|
|
* that is set to @arg.
|
|
*
|
|
* Returns: a boolean result with the meaning depending on the aggregation
|
|
* type @type.
|
|
*/
|
|
gboolean
|
|
_nm_connection_aggregate (NMConnection *connection,
|
|
NMConnectionAggregateType type,
|
|
gpointer arg)
|
|
{
|
|
NMConnectionPrivate *priv;
|
|
GHashTableIter iter;
|
|
NMSetting *setting;
|
|
gboolean arg_boolean;
|
|
gboolean completed_early;
|
|
gpointer my_arg;
|
|
|
|
g_return_val_if_fail (NM_IS_CONNECTION (connection), FALSE);
|
|
|
|
switch (type) {
|
|
case NM_CONNECTION_AGGREGATE_ANY_SECRETS:
|
|
arg_boolean = FALSE;
|
|
my_arg = &arg_boolean;
|
|
goto good;
|
|
case NM_CONNECTION_AGGREGATE_ANY_SYSTEM_SECRET_FLAGS:
|
|
arg_boolean = FALSE;
|
|
my_arg = &arg_boolean;
|
|
goto good;
|
|
}
|
|
g_return_val_if_reached (FALSE);
|
|
|
|
good:
|
|
priv = NM_CONNECTION_GET_PRIVATE (connection);
|
|
|
|
completed_early = FALSE;
|
|
g_hash_table_iter_init (&iter, priv->settings);
|
|
while (g_hash_table_iter_next (&iter, NULL, (gpointer) &setting)) {
|
|
if (_nm_setting_aggregate (setting, type, my_arg)) {
|
|
completed_early = TRUE;
|
|
break;
|
|
}
|
|
nm_assert ( my_arg != &arg_boolean
|
|
|| !arg_boolean);
|
|
}
|
|
|
|
if (my_arg == &arg_boolean) {
|
|
nm_assert (completed_early == arg_boolean);
|
|
if (arg)
|
|
*((gboolean *) arg) = arg_boolean;
|
|
return arg_boolean;
|
|
}
|
|
|
|
nm_assert_not_reached ();
|
|
return FALSE;
|
|
}
|
|
|
|
/**
|
|
* nm_connection_dump:
|
|
* @connection: the #NMConnection
|
|
*
|
|
* Print the connection (including secrets!) to stdout. For debugging
|
|
* purposes ONLY, should NOT be used for serialization of the setting,
|
|
* or machine-parsed in any way. The output format is not guaranteed to
|
|
* be stable and may change at any time.
|
|
**/
|
|
void
|
|
nm_connection_dump (NMConnection *connection)
|
|
{
|
|
GHashTableIter iter;
|
|
NMSetting *setting;
|
|
char *str;
|
|
|
|
if (!connection)
|
|
return;
|
|
|
|
g_hash_table_iter_init (&iter, NM_CONNECTION_GET_PRIVATE (connection)->settings);
|
|
while (g_hash_table_iter_next (&iter, NULL, (gpointer) &setting)) {
|
|
str = nm_setting_to_string (setting);
|
|
g_print ("%s\n", str);
|
|
g_free (str);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* nm_connection_set_path:
|
|
* @connection: the #NMConnection
|
|
* @path: the D-Bus path of the connection as given by the settings service
|
|
* which provides the connection
|
|
*
|
|
* Sets the D-Bus path of the connection. This property is not serialized, and
|
|
* is only for the reference of the caller. Sets the #NMConnection:path
|
|
* property.
|
|
**/
|
|
void
|
|
nm_connection_set_path (NMConnection *connection, const char *path)
|
|
{
|
|
NMConnectionPrivate *priv;
|
|
|
|
g_return_if_fail (NM_IS_CONNECTION (connection));
|
|
|
|
priv = NM_CONNECTION_GET_PRIVATE (connection);
|
|
|
|
g_free (priv->path);
|
|
priv->path = g_strdup (path);
|
|
}
|
|
|
|
/**
|
|
* nm_connection_get_path:
|
|
* @connection: the #NMConnection
|
|
*
|
|
* Returns the connection's D-Bus path.
|
|
*
|
|
* Returns: the D-Bus path of the connection, previously set by a call to
|
|
* nm_connection_set_path().
|
|
**/
|
|
const char *
|
|
nm_connection_get_path (NMConnection *connection)
|
|
{
|
|
g_return_val_if_fail (NM_IS_CONNECTION (connection), NULL);
|
|
|
|
return NM_CONNECTION_GET_PRIVATE (connection)->path;
|
|
}
|
|
|
|
/**
|
|
* nm_connection_get_interface_name:
|
|
* @connection: The #NMConnection
|
|
*
|
|
* Returns the interface name as stored in NMSettingConnection:interface_name.
|
|
* If the connection contains no NMSettingConnection, it will return %NULL.
|
|
*
|
|
* For hardware devices and software devices created outside of NetworkManager,
|
|
* this name is used to match the device. for software devices created by
|
|
* NetworkManager, this is the name of the created interface.
|
|
*
|
|
* Returns: Name of the kernel interface or %NULL
|
|
*/
|
|
const char *
|
|
nm_connection_get_interface_name (NMConnection *connection)
|
|
{
|
|
NMSettingConnection *s_con;
|
|
|
|
s_con = nm_connection_get_setting_connection (connection);
|
|
return s_con ? nm_setting_connection_get_interface_name (s_con) : NULL;
|
|
}
|
|
|
|
NMConnectionMultiConnect
|
|
_nm_connection_get_multi_connect (NMConnection *connection)
|
|
{
|
|
NMSettingConnection *s_con;
|
|
NMConnectionMultiConnect multi_connect;
|
|
const NMConnectionMultiConnect DEFAULT = NM_CONNECTION_MULTI_CONNECT_SINGLE;
|
|
|
|
/* connection.multi_connect property cannot be specified via regular
|
|
* connection defaults in NetworkManager.conf, because those are per-device,
|
|
* and we need to determine the multi_connect independent of a particular
|
|
* device.
|
|
*
|
|
* There is however still a default-value, so theoretically, the default
|
|
* value could be specified in NetworkManager.conf. Just not as [connection*]
|
|
* and indepdented of a device. */
|
|
|
|
s_con = nm_connection_get_setting_connection (connection);
|
|
if (!s_con)
|
|
return DEFAULT;
|
|
|
|
multi_connect = nm_setting_connection_get_multi_connect (s_con);
|
|
return multi_connect == NM_CONNECTION_MULTI_CONNECT_DEFAULT
|
|
? DEFAULT
|
|
: multi_connect;
|
|
}
|
|
|
|
gboolean
|
|
_nm_connection_verify_required_interface_name (NMConnection *connection,
|
|
GError **error)
|
|
{
|
|
const char *interface_name;
|
|
|
|
if (!connection)
|
|
return TRUE;
|
|
|
|
interface_name = nm_connection_get_interface_name (connection);
|
|
if (interface_name)
|
|
return TRUE;
|
|
|
|
g_set_error_literal (error,
|
|
NM_CONNECTION_ERROR,
|
|
NM_CONNECTION_ERROR_MISSING_PROPERTY,
|
|
_("property is missing"));
|
|
g_prefix_error (error, "%s.%s: ", NM_SETTING_CONNECTION_SETTING_NAME, NM_SETTING_CONNECTION_INTERFACE_NAME);
|
|
return FALSE;
|
|
}
|
|
|
|
/**
|
|
* nm_connection_get_uuid:
|
|
* @connection: the #NMConnection
|
|
*
|
|
* A shortcut to return the UUID from the connection's #NMSettingConnection.
|
|
*
|
|
* Returns: the UUID from the connection's 'connection' setting
|
|
**/
|
|
const char *
|
|
nm_connection_get_uuid (NMConnection *connection)
|
|
{
|
|
NMSettingConnection *s_con;
|
|
|
|
s_con = nm_connection_get_setting_connection (connection);
|
|
return s_con ? nm_setting_connection_get_uuid (s_con) : NULL;
|
|
}
|
|
|
|
/**
|
|
* nm_connection_get_id:
|
|
* @connection: the #NMConnection
|
|
*
|
|
* A shortcut to return the ID from the connection's #NMSettingConnection.
|
|
*
|
|
* Returns: the ID from the connection's 'connection' setting
|
|
**/
|
|
const char *
|
|
nm_connection_get_id (NMConnection *connection)
|
|
{
|
|
NMSettingConnection *s_con;
|
|
|
|
s_con = nm_connection_get_setting_connection (connection);
|
|
return s_con ? nm_setting_connection_get_id (s_con) : NULL;
|
|
}
|
|
|
|
/**
|
|
* nm_connection_get_connection_type:
|
|
* @connection: the #NMConnection
|
|
*
|
|
* A shortcut to return the type from the connection's #NMSettingConnection.
|
|
*
|
|
* Returns: the type from the connection's 'connection' setting
|
|
**/
|
|
const char *
|
|
nm_connection_get_connection_type (NMConnection *connection)
|
|
{
|
|
NMSettingConnection *s_con;
|
|
|
|
s_con = nm_connection_get_setting_connection (connection);
|
|
return s_con ? nm_setting_connection_get_connection_type (s_con) : NULL;
|
|
}
|
|
|
|
/**
|
|
* nm_connection_is_virtual:
|
|
* @connection: an #NMConnection
|
|
*
|
|
* Checks if @connection refers to a virtual device (and thus can potentially be
|
|
* activated even if the device it refers to doesn't exist).
|
|
*
|
|
* Returns: whether @connection refers to a virtual device
|
|
*/
|
|
gboolean
|
|
nm_connection_is_virtual (NMConnection *connection)
|
|
{
|
|
const char *type;
|
|
|
|
type = nm_connection_get_connection_type (connection);
|
|
if (!type)
|
|
return FALSE;
|
|
|
|
if (NM_IN_STRSET (type, NM_SETTING_6LOWPAN_SETTING_NAME,
|
|
NM_SETTING_BOND_SETTING_NAME,
|
|
NM_SETTING_BRIDGE_SETTING_NAME,
|
|
NM_SETTING_DUMMY_SETTING_NAME,
|
|
NM_SETTING_IP_TUNNEL_SETTING_NAME,
|
|
NM_SETTING_MACSEC_SETTING_NAME,
|
|
NM_SETTING_MACVLAN_SETTING_NAME,
|
|
NM_SETTING_OVS_BRIDGE_SETTING_NAME,
|
|
NM_SETTING_OVS_INTERFACE_SETTING_NAME,
|
|
NM_SETTING_OVS_PORT_SETTING_NAME,
|
|
NM_SETTING_TEAM_SETTING_NAME,
|
|
NM_SETTING_TUN_SETTING_NAME,
|
|
NM_SETTING_VLAN_SETTING_NAME,
|
|
NM_SETTING_VRF_SETTING_NAME,
|
|
NM_SETTING_VXLAN_SETTING_NAME,
|
|
NM_SETTING_WIREGUARD_SETTING_NAME))
|
|
return TRUE;
|
|
|
|
if (nm_streq (type, NM_SETTING_INFINIBAND_SETTING_NAME)) {
|
|
NMSettingInfiniband *s_ib;
|
|
|
|
s_ib = nm_connection_get_setting_infiniband (connection);
|
|
return s_ib && nm_setting_infiniband_get_virtual_interface_name (s_ib);
|
|
}
|
|
|
|
if (nm_streq (type, NM_SETTING_BLUETOOTH_SETTING_NAME))
|
|
return !!_nm_connection_get_setting_bluetooth_for_nap (connection);
|
|
|
|
if (nm_streq (type, NM_SETTING_PPPOE_SETTING_NAME)) {
|
|
NMSettingPppoe *s_pppoe;
|
|
|
|
s_pppoe = nm_connection_get_setting_pppoe (connection);
|
|
return !!nm_setting_pppoe_get_parent (s_pppoe);
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
/**
|
|
* nm_connection_get_virtual_device_description:
|
|
* @connection: an #NMConnection for a virtual device type
|
|
*
|
|
* Returns the name that nm_device_disambiguate_names() would
|
|
* return for the virtual device that would be created for @connection.
|
|
* Eg, "VLAN (eth1.1)".
|
|
*
|
|
* Returns: (transfer full): the name of @connection's device,
|
|
* or %NULL if @connection is not a virtual connection type
|
|
*/
|
|
char *
|
|
nm_connection_get_virtual_device_description (NMConnection *connection)
|
|
{
|
|
const char *type;
|
|
const char *iface = NULL, *display_type = NULL;
|
|
|
|
type = nm_connection_get_connection_type (connection);
|
|
if (!type)
|
|
return NULL;
|
|
|
|
iface = nm_connection_get_interface_name (connection);
|
|
|
|
if (!strcmp (type, NM_SETTING_BOND_SETTING_NAME))
|
|
display_type = _("Bond");
|
|
else if (!strcmp (type, NM_SETTING_TEAM_SETTING_NAME))
|
|
display_type = _("Team");
|
|
else if (!strcmp (type, NM_SETTING_BRIDGE_SETTING_NAME))
|
|
display_type = _("Bridge");
|
|
else if (!strcmp (type, NM_SETTING_VLAN_SETTING_NAME))
|
|
display_type = _("VLAN");
|
|
else if (!strcmp (type, NM_SETTING_INFINIBAND_SETTING_NAME)) {
|
|
display_type = _("InfiniBand");
|
|
iface = nm_setting_infiniband_get_virtual_interface_name (nm_connection_get_setting_infiniband (connection));
|
|
} else if (!strcmp (type, NM_SETTING_IP_TUNNEL_SETTING_NAME))
|
|
display_type = _("IP Tunnel");
|
|
|
|
if (!iface || !display_type)
|
|
return NULL;
|
|
|
|
return g_strdup_printf ("%s (%s)", display_type, iface);
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
/**
|
|
* nm_connection_get_setting_802_1x:
|
|
* @connection: the #NMConnection
|
|
*
|
|
* A shortcut to return any #NMSetting8021x the connection might contain.
|
|
*
|
|
* Returns: (transfer none): an #NMSetting8021x if the connection contains one, otherwise %NULL
|
|
**/
|
|
NMSetting8021x *
|
|
nm_connection_get_setting_802_1x (NMConnection *connection)
|
|
{
|
|
return _connection_get_setting_check (connection, NM_TYPE_SETTING_802_1X);
|
|
}
|
|
|
|
/**
|
|
* nm_connection_get_setting_bluetooth:
|
|
* @connection: the #NMConnection
|
|
*
|
|
* A shortcut to return any #NMSettingBluetooth the connection might contain.
|
|
*
|
|
* Returns: (transfer none): an #NMSettingBluetooth if the connection contains one, otherwise %NULL
|
|
**/
|
|
NMSettingBluetooth *
|
|
nm_connection_get_setting_bluetooth (NMConnection *connection)
|
|
{
|
|
return _connection_get_setting_check (connection, NM_TYPE_SETTING_BLUETOOTH);
|
|
}
|
|
|
|
/**
|
|
* nm_connection_get_setting_bond:
|
|
* @connection: the #NMConnection
|
|
*
|
|
* A shortcut to return any #NMSettingBond the connection might contain.
|
|
*
|
|
* Returns: (transfer none): an #NMSettingBond if the connection contains one, otherwise %NULL
|
|
**/
|
|
NMSettingBond *
|
|
nm_connection_get_setting_bond (NMConnection *connection)
|
|
{
|
|
return _connection_get_setting_check (connection, NM_TYPE_SETTING_BOND);
|
|
}
|
|
|
|
/**
|
|
* nm_connection_get_setting_team:
|
|
* @connection: the #NMConnection
|
|
*
|
|
* A shortcut to return any #NMSettingTeam the connection might contain.
|
|
*
|
|
* Returns: (transfer none): an #NMSettingTeam if the connection contains one, otherwise %NULL
|
|
**/
|
|
NMSettingTeam *
|
|
nm_connection_get_setting_team (NMConnection *connection)
|
|
{
|
|
return _connection_get_setting_check (connection, NM_TYPE_SETTING_TEAM);
|
|
}
|
|
|
|
/**
|
|
* nm_connection_get_setting_team_port:
|
|
* @connection: the #NMConnection
|
|
*
|
|
* A shortcut to return any #NMSettingTeamPort the connection might contain.
|
|
*
|
|
* Returns: (transfer none): an #NMSettingTeamPort if the connection contains one, otherwise %NULL
|
|
**/
|
|
NMSettingTeamPort *
|
|
nm_connection_get_setting_team_port (NMConnection *connection)
|
|
{
|
|
return _connection_get_setting_check (connection, NM_TYPE_SETTING_TEAM_PORT);
|
|
}
|
|
|
|
/**
|
|
* nm_connection_get_setting_bridge:
|
|
* @connection: the #NMConnection
|
|
*
|
|
* A shortcut to return any #NMSettingBridge the connection might contain.
|
|
*
|
|
* Returns: (transfer none): an #NMSettingBridge if the connection contains one, otherwise %NULL
|
|
**/
|
|
NMSettingBridge *
|
|
nm_connection_get_setting_bridge (NMConnection *connection)
|
|
{
|
|
return _connection_get_setting_check (connection, NM_TYPE_SETTING_BRIDGE);
|
|
}
|
|
|
|
/**
|
|
* nm_connection_get_setting_cdma:
|
|
* @connection: the #NMConnection
|
|
*
|
|
* A shortcut to return any #NMSettingCdma the connection might contain.
|
|
*
|
|
* Returns: (transfer none): an #NMSettingCdma if the connection contains one, otherwise %NULL
|
|
**/
|
|
NMSettingCdma *
|
|
nm_connection_get_setting_cdma (NMConnection *connection)
|
|
{
|
|
return _connection_get_setting_check (connection, NM_TYPE_SETTING_CDMA);
|
|
}
|
|
|
|
/**
|
|
* nm_connection_get_setting_connection:
|
|
* @connection: the #NMConnection
|
|
*
|
|
* A shortcut to return any #NMSettingConnection the connection might contain.
|
|
*
|
|
* Returns: (transfer none): an #NMSettingConnection if the connection contains one, otherwise %NULL
|
|
**/
|
|
NMSettingConnection *
|
|
nm_connection_get_setting_connection (NMConnection *connection)
|
|
{
|
|
return _connection_get_setting_check (connection, NM_TYPE_SETTING_CONNECTION);
|
|
}
|
|
|
|
/**
|
|
* nm_connection_get_setting_dcb:
|
|
* @connection: the #NMConnection
|
|
*
|
|
* A shortcut to return any #NMSettingDcb the connection might contain.
|
|
*
|
|
* Returns: (transfer none): an #NMSettingDcb if the connection contains one, otherwise NULL
|
|
**/
|
|
NMSettingDcb *
|
|
nm_connection_get_setting_dcb (NMConnection *connection)
|
|
{
|
|
return _connection_get_setting_check (connection, NM_TYPE_SETTING_DCB);
|
|
}
|
|
|
|
/**
|
|
* nm_connection_get_setting_dummy:
|
|
* @connection: the #NMConnection
|
|
*
|
|
* A shortcut to return any #NMSettingDummy the connection might contain.
|
|
*
|
|
* Returns: (transfer none): an #NMSettingDummy if the connection contains one, otherwise %NULL
|
|
*
|
|
* Since: 1.8
|
|
**/
|
|
NMSettingDummy *
|
|
nm_connection_get_setting_dummy (NMConnection *connection)
|
|
{
|
|
return _connection_get_setting_check (connection, NM_TYPE_SETTING_DUMMY);
|
|
}
|
|
|
|
/**
|
|
* nm_connection_get_setting_generic:
|
|
* @connection: the #NMConnection
|
|
*
|
|
* A shortcut to return any #NMSettingGeneric the connection might contain.
|
|
*
|
|
* Returns: (transfer none): an #NMSettingGeneric if the connection contains one, otherwise NULL
|
|
**/
|
|
NMSettingGeneric *
|
|
nm_connection_get_setting_generic (NMConnection *connection)
|
|
{
|
|
return _connection_get_setting_check (connection, NM_TYPE_SETTING_GENERIC);
|
|
}
|
|
|
|
/**
|
|
* nm_connection_get_setting_gsm:
|
|
* @connection: the #NMConnection
|
|
*
|
|
* A shortcut to return any #NMSettingGsm the connection might contain.
|
|
*
|
|
* Returns: (transfer none): an #NMSettingGsm if the connection contains one, otherwise %NULL
|
|
**/
|
|
NMSettingGsm *
|
|
nm_connection_get_setting_gsm (NMConnection *connection)
|
|
{
|
|
return _connection_get_setting_check (connection, NM_TYPE_SETTING_GSM);
|
|
}
|
|
|
|
/**
|
|
* nm_connection_get_setting_infiniband:
|
|
* @connection: the #NMConnection
|
|
*
|
|
* A shortcut to return any #NMSettingInfiniband the connection might contain.
|
|
*
|
|
* Returns: (transfer none): an #NMSettingInfiniband if the connection contains one, otherwise %NULL
|
|
**/
|
|
NMSettingInfiniband *
|
|
nm_connection_get_setting_infiniband (NMConnection *connection)
|
|
{
|
|
return _connection_get_setting_check (connection, NM_TYPE_SETTING_INFINIBAND);
|
|
}
|
|
|
|
/**
|
|
* nm_connection_get_setting_ip4_config:
|
|
* @connection: the #NMConnection
|
|
*
|
|
* A shortcut to return any #NMSettingIP4Config the connection might contain.
|
|
*
|
|
* Note that it returns the value as type #NMSettingIPConfig, since the vast
|
|
* majority of IPv4-setting-related methods are on that type, not
|
|
* #NMSettingIP4Config.
|
|
*
|
|
* Returns: (type NMSettingIP4Config) (transfer none): an #NMSettingIP4Config if the
|
|
* connection contains one, otherwise %NULL
|
|
**/
|
|
NMSettingIPConfig *
|
|
nm_connection_get_setting_ip4_config (NMConnection *connection)
|
|
{
|
|
return _connection_get_setting_check (connection, NM_TYPE_SETTING_IP4_CONFIG);
|
|
}
|
|
|
|
/**
|
|
* nm_connection_get_setting_ip_tunnel:
|
|
* @connection: the #NMConnection
|
|
*
|
|
* A shortcut to return any #NMSettingIPTunnel the connection might contain.
|
|
*
|
|
* Returns: (transfer none): an #NMSettingIPTunnel if the connection contains one, otherwise %NULL
|
|
*
|
|
* Since: 1.2
|
|
**/
|
|
NMSettingIPTunnel *
|
|
nm_connection_get_setting_ip_tunnel (NMConnection *connection)
|
|
{
|
|
return _connection_get_setting_check (connection, NM_TYPE_SETTING_IP_TUNNEL);
|
|
}
|
|
|
|
/**
|
|
* nm_connection_get_setting_ip6_config:
|
|
* @connection: the #NMConnection
|
|
*
|
|
* A shortcut to return any #NMSettingIP6Config the connection might contain.
|
|
*
|
|
* Note that it returns the value as type #NMSettingIPConfig, since the vast
|
|
* majority of IPv6-setting-related methods are on that type, not
|
|
* #NMSettingIP6Config.
|
|
*
|
|
* Returns: (type NMSettingIP6Config) (transfer none): an #NMSettingIP6Config if the
|
|
* connection contains one, otherwise %NULL
|
|
**/
|
|
NMSettingIPConfig *
|
|
nm_connection_get_setting_ip6_config (NMConnection *connection)
|
|
{
|
|
return _connection_get_setting_check (connection, NM_TYPE_SETTING_IP6_CONFIG);
|
|
}
|
|
|
|
/**
|
|
* nm_connection_get_setting_macsec:
|
|
* @connection: the #NMConnection
|
|
*
|
|
* A shortcut to return any #NMSettingMacsec the connection might contain.
|
|
*
|
|
* Returns: (transfer none): an #NMSettingMacsec if the connection contains one, otherwise %NULL
|
|
*
|
|
* Since: 1.6
|
|
**/
|
|
NMSettingMacsec *
|
|
nm_connection_get_setting_macsec (NMConnection *connection)
|
|
{
|
|
return _connection_get_setting_check (connection, NM_TYPE_SETTING_MACSEC);
|
|
}
|
|
|
|
/**
|
|
* nm_connection_get_setting_macvlan:
|
|
* @connection: the #NMConnection
|
|
*
|
|
* A shortcut to return any #NMSettingMacvlan the connection might contain.
|
|
*
|
|
* Returns: (transfer none): an #NMSettingMacvlan if the connection contains one, otherwise %NULL
|
|
*
|
|
* Since: 1.2
|
|
**/
|
|
NMSettingMacvlan *
|
|
nm_connection_get_setting_macvlan (NMConnection *connection)
|
|
{
|
|
return _connection_get_setting_check (connection, NM_TYPE_SETTING_MACVLAN);
|
|
}
|
|
|
|
/**
|
|
* nm_connection_get_setting_olpc_mesh:
|
|
* @connection: the #NMConnection
|
|
*
|
|
* A shortcut to return any #NMSettingOlpcMesh the connection might contain.
|
|
*
|
|
* Returns: (transfer none): an #NMSettingOlpcMesh if the connection contains one, otherwise %NULL
|
|
**/
|
|
NMSettingOlpcMesh *
|
|
nm_connection_get_setting_olpc_mesh (NMConnection *connection)
|
|
{
|
|
return _connection_get_setting_check (connection, NM_TYPE_SETTING_OLPC_MESH);
|
|
}
|
|
|
|
/**
|
|
* nm_connection_get_setting_ovs_bridge:
|
|
* @connection: the #NMConnection
|
|
*
|
|
* A shortcut to return any #NMSettingOvsBridge the connection might contain.
|
|
*
|
|
* Returns: (transfer none): an #NMSettingOvsBridge if the connection contains one, otherwise %NULL
|
|
*
|
|
* Since: 1.10
|
|
**/
|
|
NMSettingOvsBridge *
|
|
nm_connection_get_setting_ovs_bridge (NMConnection *connection)
|
|
{
|
|
return _connection_get_setting_check (connection, NM_TYPE_SETTING_OVS_BRIDGE);
|
|
}
|
|
|
|
/**
|
|
* nm_connection_get_setting_ovs_interface:
|
|
* @connection: the #NMConnection
|
|
*
|
|
* A shortcut to return any #NMSettingOvsInterface the connection might contain.
|
|
*
|
|
* Returns: (transfer none): an #NMSettingOvsInterface if the connection contains one, otherwise %NULL
|
|
*
|
|
* Since: 1.10
|
|
**/
|
|
NMSettingOvsInterface *
|
|
nm_connection_get_setting_ovs_interface (NMConnection *connection)
|
|
{
|
|
return _connection_get_setting_check (connection, NM_TYPE_SETTING_OVS_INTERFACE);
|
|
}
|
|
|
|
/**
|
|
* nm_connection_get_setting_ovs_patch:
|
|
* @connection: the #NMConnection
|
|
*
|
|
* A shortcut to return any #NMSettingOvsPatch the connection might contain.
|
|
*
|
|
* Returns: (transfer none): an #NMSettingOvsPatch if the connection contains one, otherwise %NULL
|
|
*
|
|
* Since: 1.10
|
|
**/
|
|
NMSettingOvsPatch *
|
|
nm_connection_get_setting_ovs_patch (NMConnection *connection)
|
|
{
|
|
return _connection_get_setting_check (connection, NM_TYPE_SETTING_OVS_PATCH);
|
|
}
|
|
|
|
/**
|
|
* nm_connection_get_setting_ovs_port:
|
|
* @connection: the #NMConnection
|
|
*
|
|
* A shortcut to return any #NMSettingOvsPort the connection might contain.
|
|
*
|
|
* Returns: (transfer none): an #NMSettingOvsPort if the connection contains one, otherwise %NULL
|
|
*
|
|
* Since: 1.10
|
|
**/
|
|
NMSettingOvsPort *
|
|
nm_connection_get_setting_ovs_port (NMConnection *connection)
|
|
{
|
|
return _connection_get_setting_check (connection, NM_TYPE_SETTING_OVS_PORT);
|
|
}
|
|
|
|
/**
|
|
* nm_connection_get_setting_ppp:
|
|
* @connection: the #NMConnection
|
|
*
|
|
* A shortcut to return any #NMSettingPpp the connection might contain.
|
|
*
|
|
* Returns: (transfer none): an #NMSettingPpp if the connection contains one, otherwise %NULL
|
|
**/
|
|
NMSettingPpp *
|
|
nm_connection_get_setting_ppp (NMConnection *connection)
|
|
{
|
|
return _connection_get_setting_check (connection, NM_TYPE_SETTING_PPP);
|
|
}
|
|
|
|
/**
|
|
* nm_connection_get_setting_pppoe:
|
|
* @connection: the #NMConnection
|
|
*
|
|
* A shortcut to return any #NMSettingPppoe the connection might contain.
|
|
*
|
|
* Returns: (transfer none): an #NMSettingPppoe if the connection contains one, otherwise %NULL
|
|
**/
|
|
NMSettingPppoe *
|
|
nm_connection_get_setting_pppoe (NMConnection *connection)
|
|
{
|
|
return _connection_get_setting_check (connection, NM_TYPE_SETTING_PPPOE);
|
|
}
|
|
|
|
/**
|
|
* nm_connection_get_setting_proxy:
|
|
* @connection: the #NMConnection
|
|
*
|
|
* A shortcut to return any #NMSettingProxy the connection might contain.
|
|
*
|
|
* Returns: (transfer none): an #NMSettingProxy if the connection contains one, otherwise %NULL
|
|
*
|
|
* Since: 1.6
|
|
**/
|
|
NMSettingProxy *
|
|
nm_connection_get_setting_proxy (NMConnection *connection)
|
|
{
|
|
return _connection_get_setting_check (connection, NM_TYPE_SETTING_PROXY);
|
|
}
|
|
|
|
/**
|
|
* nm_connection_get_setting_serial:
|
|
* @connection: the #NMConnection
|
|
*
|
|
* A shortcut to return any #NMSettingSerial the connection might contain.
|
|
*
|
|
* Returns: (transfer none): an #NMSettingSerial if the connection contains one, otherwise %NULL
|
|
**/
|
|
NMSettingSerial *
|
|
nm_connection_get_setting_serial (NMConnection *connection)
|
|
{
|
|
return _connection_get_setting_check (connection, NM_TYPE_SETTING_SERIAL);
|
|
}
|
|
|
|
/**
|
|
* nm_connection_get_setting_tc_config:
|
|
* @connection: the #NMConnection
|
|
*
|
|
* A shortcut to return any #NMSettingTCConfig the connection might contain.
|
|
*
|
|
* Returns: (transfer none): an #NMSettingTCConfig if the connection contains one, otherwise %NULL
|
|
*
|
|
* Since: 1.12
|
|
**/
|
|
NMSettingTCConfig *
|
|
nm_connection_get_setting_tc_config (NMConnection *connection)
|
|
{
|
|
return _connection_get_setting_check (connection, NM_TYPE_SETTING_TC_CONFIG);
|
|
}
|
|
|
|
/**
|
|
* nm_connection_get_setting_tun:
|
|
* @connection: the #NMConnection
|
|
*
|
|
* A shortcut to return any #NMSettingTun the connection might contain.
|
|
*
|
|
* Returns: (transfer none): an #NMSettingTun if the connection contains one, otherwise %NULL
|
|
*
|
|
* Since: 1.2
|
|
**/
|
|
NMSettingTun *
|
|
nm_connection_get_setting_tun (NMConnection *connection)
|
|
{
|
|
return _connection_get_setting_check (connection, NM_TYPE_SETTING_TUN);
|
|
}
|
|
|
|
/**
|
|
* nm_connection_get_setting_vpn:
|
|
* @connection: the #NMConnection
|
|
*
|
|
* A shortcut to return any #NMSettingVpn the connection might contain.
|
|
*
|
|
* Returns: (transfer none): an #NMSettingVpn if the connection contains one, otherwise %NULL
|
|
**/
|
|
NMSettingVpn *
|
|
nm_connection_get_setting_vpn (NMConnection *connection)
|
|
{
|
|
return _connection_get_setting_check (connection, NM_TYPE_SETTING_VPN);
|
|
}
|
|
|
|
/**
|
|
* nm_connection_get_setting_vxlan:
|
|
* @connection: the #NMConnection
|
|
*
|
|
* A shortcut to return any #NMSettingVxlan the connection might contain.
|
|
*
|
|
* Returns: (transfer none): an #NMSettingVxlan if the connection contains one, otherwise %NULL
|
|
*
|
|
* Since: 1.2
|
|
**/
|
|
NMSettingVxlan *
|
|
nm_connection_get_setting_vxlan (NMConnection *connection)
|
|
{
|
|
return _connection_get_setting_check (connection, NM_TYPE_SETTING_VXLAN);
|
|
}
|
|
|
|
/**
|
|
* nm_connection_get_setting_wimax:
|
|
* @connection: the #NMConnection
|
|
*
|
|
* A shortcut to return any #NMSettingWimax the connection might contain.
|
|
*
|
|
* Returns: (transfer none): an #NMSettingWimax if the connection contains one, otherwise %NULL
|
|
**/
|
|
NMSettingWimax *
|
|
nm_connection_get_setting_wimax (NMConnection *connection)
|
|
{
|
|
return _connection_get_setting_check (connection, NM_TYPE_SETTING_WIMAX);
|
|
}
|
|
|
|
/**
|
|
* nm_connection_get_setting_wired:
|
|
* @connection: the #NMConnection
|
|
*
|
|
* A shortcut to return any #NMSettingWired the connection might contain.
|
|
*
|
|
* Returns: (transfer none): an #NMSettingWired if the connection contains one, otherwise %NULL
|
|
**/
|
|
NMSettingWired *
|
|
nm_connection_get_setting_wired (NMConnection *connection)
|
|
{
|
|
return _connection_get_setting_check (connection, NM_TYPE_SETTING_WIRED);
|
|
}
|
|
|
|
/**
|
|
* nm_connection_get_setting_adsl:
|
|
* @connection: the #NMConnection
|
|
*
|
|
* A shortcut to return any #NMSettingAdsl the connection might contain.
|
|
*
|
|
* Returns: (transfer none): an #NMSettingAdsl if the connection contains one, otherwise %NULL
|
|
**/
|
|
NMSettingAdsl *
|
|
nm_connection_get_setting_adsl (NMConnection *connection)
|
|
{
|
|
return _connection_get_setting_check (connection, NM_TYPE_SETTING_ADSL);
|
|
}
|
|
|
|
/**
|
|
* nm_connection_get_setting_wireless:
|
|
* @connection: the #NMConnection
|
|
*
|
|
* A shortcut to return any #NMSettingWireless the connection might contain.
|
|
*
|
|
* Returns: (transfer none): an #NMSettingWireless if the connection contains one, otherwise %NULL
|
|
**/
|
|
NMSettingWireless *
|
|
nm_connection_get_setting_wireless (NMConnection *connection)
|
|
{
|
|
return _connection_get_setting_check (connection, NM_TYPE_SETTING_WIRELESS);
|
|
}
|
|
|
|
/**
|
|
* nm_connection_get_setting_wireless_security:
|
|
* @connection: the #NMConnection
|
|
*
|
|
* A shortcut to return any #NMSettingWirelessSecurity the connection might contain.
|
|
*
|
|
* Returns: (transfer none): an #NMSettingWirelessSecurity if the connection contains one, otherwise %NULL
|
|
**/
|
|
NMSettingWirelessSecurity *
|
|
nm_connection_get_setting_wireless_security (NMConnection *connection)
|
|
{
|
|
return _connection_get_setting_check (connection, NM_TYPE_SETTING_WIRELESS_SECURITY);
|
|
}
|
|
|
|
/**
|
|
* nm_connection_get_setting_bridge_port:
|
|
* @connection: the #NMConnection
|
|
*
|
|
* A shortcut to return any #NMSettingBridgePort the connection might contain.
|
|
*
|
|
* Returns: (transfer none): an #NMSettingBridgePort if the connection contains one, otherwise %NULL
|
|
**/
|
|
NMSettingBridgePort *
|
|
nm_connection_get_setting_bridge_port (NMConnection *connection)
|
|
{
|
|
return _connection_get_setting_check (connection, NM_TYPE_SETTING_BRIDGE_PORT);
|
|
}
|
|
|
|
/**
|
|
* nm_connection_get_setting_vlan:
|
|
* @connection: the #NMConnection
|
|
*
|
|
* A shortcut to return any #NMSettingVlan the connection might contain.
|
|
*
|
|
* Returns: (transfer none): an #NMSettingVlan if the connection contains one, otherwise %NULL
|
|
**/
|
|
NMSettingVlan *
|
|
nm_connection_get_setting_vlan (NMConnection *connection)
|
|
{
|
|
return _connection_get_setting_check (connection, NM_TYPE_SETTING_VLAN);
|
|
}
|
|
|
|
NMSettingBluetooth *
|
|
_nm_connection_get_setting_bluetooth_for_nap (NMConnection *connection)
|
|
{
|
|
NMSettingBluetooth *s_bt = nm_connection_get_setting_bluetooth (connection);
|
|
|
|
if ( s_bt
|
|
&& nm_streq0 (nm_setting_bluetooth_get_connection_type (s_bt), NM_SETTING_BLUETOOTH_TYPE_NAP))
|
|
return s_bt;
|
|
return NULL;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
static void
|
|
nm_connection_private_free (NMConnectionPrivate *priv)
|
|
{
|
|
NMConnection *self = priv->self;
|
|
|
|
g_hash_table_foreach_remove (priv->settings, _setting_release_hfr, self);
|
|
g_hash_table_destroy (priv->settings);
|
|
g_free (priv->path);
|
|
|
|
g_slice_free (NMConnectionPrivate, priv);
|
|
}
|
|
|
|
static NMConnectionPrivate *
|
|
nm_connection_get_private (NMConnection *connection)
|
|
{
|
|
GQuark key;
|
|
NMConnectionPrivate *priv;
|
|
|
|
nm_assert (NM_IS_CONNECTION (connection));
|
|
|
|
key = NM_CACHED_QUARK ("NMConnectionPrivate");
|
|
|
|
priv = g_object_get_qdata ((GObject *) connection, key);
|
|
if (G_UNLIKELY (!priv)) {
|
|
priv = g_slice_new0 (NMConnectionPrivate);
|
|
g_object_set_qdata_full ((GObject *) connection, key,
|
|
priv, (GDestroyNotify) nm_connection_private_free);
|
|
|
|
priv->self = connection;
|
|
priv->settings = g_hash_table_new_full (nm_direct_hash,
|
|
NULL,
|
|
NULL,
|
|
g_object_unref);
|
|
}
|
|
|
|
return priv;
|
|
}
|
|
|
|
static void
|
|
nm_connection_default_init (NMConnectionInterface *iface)
|
|
{
|
|
/**
|
|
* NMConnection::secrets-updated:
|
|
* @connection: the object on which the signal is emitted
|
|
* @setting_name: the setting name of the #NMSetting for which secrets were
|
|
* updated
|
|
*
|
|
* The ::secrets-updated signal is emitted when the secrets of a setting
|
|
* have been changed.
|
|
*/
|
|
signals[SECRETS_UPDATED] =
|
|
g_signal_new (NM_CONNECTION_SECRETS_UPDATED,
|
|
NM_TYPE_CONNECTION,
|
|
G_SIGNAL_RUN_FIRST,
|
|
G_STRUCT_OFFSET (NMConnectionInterface, secrets_updated),
|
|
NULL, NULL,
|
|
g_cclosure_marshal_VOID__STRING,
|
|
G_TYPE_NONE, 1,
|
|
G_TYPE_STRING);
|
|
|
|
/**
|
|
* NMConnection::secrets-cleared:
|
|
* @connection: the object on which the signal is emitted
|
|
*
|
|
* The ::secrets-cleared signal is emitted when the secrets of a connection
|
|
* are cleared.
|
|
*/
|
|
signals[SECRETS_CLEARED] =
|
|
g_signal_new (NM_CONNECTION_SECRETS_CLEARED,
|
|
NM_TYPE_CONNECTION,
|
|
G_SIGNAL_RUN_FIRST,
|
|
G_STRUCT_OFFSET (NMConnectionInterface, secrets_cleared),
|
|
NULL, NULL,
|
|
g_cclosure_marshal_VOID__VOID,
|
|
G_TYPE_NONE, 0);
|
|
|
|
/**
|
|
* NMConnection::changed:
|
|
* @connection: the object on which the signal is emitted
|
|
*
|
|
* The ::changed signal is emitted when any property of any property
|
|
* (including secrets) of any setting of the connection is modified,
|
|
* or when settings are added or removed.
|
|
*/
|
|
signals[CHANGED] =
|
|
g_signal_new (NM_CONNECTION_CHANGED,
|
|
NM_TYPE_CONNECTION,
|
|
G_SIGNAL_RUN_FIRST,
|
|
G_STRUCT_OFFSET (NMConnectionInterface, changed),
|
|
NULL, NULL,
|
|
g_cclosure_marshal_VOID__VOID,
|
|
G_TYPE_NONE, 0);
|
|
}
|