fdo-mirrors/NetworkManager
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/NetworkManager/NetworkManager.git synced 2025-12-25 23:30:07 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions
NetworkManager/src/nmcli/settings.c
Thomas Haller 615221a99c format: reformat source tree with clang-format 13.0 
We use clang-format for automatic formatting of our source files.
Since clang-format is actively maintained software, the actual
formatting depends on the used version of clang-format. That is
unfortunate and painful, but really unavoidable unless clang-format
would be strictly bug-compatible.

So the version that we must use is from the current Fedora release, which
is also tested by our gitlab-ci. Previously, we were using Fedora 34 with
clang-tools-extra-12.0.1-1.fc34.x86_64.

As Fedora 35 comes along, we need to update our formatting as Fedora 35
comes with version "13.0.0~rc1-1.fc35".
An alternative would be to freeze on version 12, but that has different
problems (like, it's cumbersome to rebuild clang 12 on Fedora 35 and it
would be cumbersome for our developers which are on Fedora 35 to use a
clang that they cannot easily install).

The (differently painful) solution is to reformat from time to time, as we
switch to a new Fedora (and thus clang) version.
Usually we would expect that such a reformatting brings minor changes.
But this time, the changes are huge. That is mentioned in the release
notes [1] as

  Makes PointerAligment: Right working with AlignConsecutiveDeclarations. (Fixes https://llvm.org/PR27353)

[1] https://releases.llvm.org/13.0.0/tools/clang/docs/ReleaseNotes.html#clang-format
2021-11-29 09:31:09 +00:00

762 lines
26 KiB
C
Raw Blame History

/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
* Copyright (C) 2010 - 2015 Red Hat, Inc.
*/
#include "libnm-client-aux-extern/nm-default-client.h"
#include "settings.h"
#include <stdlib.h>
#include <arpa/inet.h>
#include "libnm-core-aux-intern/nm-common-macros.h"
#include "libnmc-base/nm-client-utils.h"
#include "libnmc-base/nm-vpn-helpers.h"
#include "libnmc-setting/nm-meta-setting-access.h"
#include "utils.h"
#include "common.h"
/*****************************************************************************/
static gboolean
get_answer(const char *prop, const char *value)
{
char *tmp_str;
char *question;
gboolean answer = FALSE;
if (value)
question = g_strdup_printf(_("Do you also want to set '%s' to '%s'? [yes]: "), prop, value);
else
question = g_strdup_printf(_("Do you also want to clear '%s'? [yes]: "), prop);
tmp_str = nmc_get_user_input(question);
if (!tmp_str || matches(tmp_str, "yes"))
answer = TRUE;
g_free(tmp_str);
g_free(question);
return answer;
}
static void ipv4_method_changed_cb(GObject *object, GParamSpec *pspec, gpointer user_data);
static void ipv6_method_changed_cb(GObject *object, GParamSpec *pspec, gpointer user_data);
static void
ipv4_addresses_changed_cb(GObject *object, GParamSpec *pspec, gpointer user_data)
{
static gboolean answered = FALSE;
static gboolean answer = FALSE;
g_signal_handlers_block_by_func(object, G_CALLBACK(ipv4_method_changed_cb), NULL);
/* If we have some IP addresses set method to 'manual'.
* Else if the method was 'manual', change it back to 'auto'.
*/
if (nm_setting_ip_config_get_num_addresses(NM_SETTING_IP_CONFIG(object))) {
if (g_strcmp0(nm_setting_ip_config_get_method(NM_SETTING_IP_CONFIG(object)),
NM_SETTING_IP4_CONFIG_METHOD_MANUAL)) {
if (!answered) {
answered = TRUE;
answer = get_answer("ipv4.method", "manual");
}
if (answer)
g_object_set(object,
NM_SETTING_IP_CONFIG_METHOD,
NM_SETTING_IP4_CONFIG_METHOD_MANUAL,
NULL);
}
} else {
answered = FALSE;
if (!g_strcmp0(nm_setting_ip_config_get_method(NM_SETTING_IP_CONFIG(object)),
NM_SETTING_IP4_CONFIG_METHOD_MANUAL))
g_object_set(object,
NM_SETTING_IP_CONFIG_METHOD,
NM_SETTING_IP4_CONFIG_METHOD_AUTO,
NULL);
}
g_signal_handlers_unblock_by_func(object, G_CALLBACK(ipv4_method_changed_cb), NULL);
}
static void
ipv4_method_changed_cb(GObject *object, GParamSpec *pspec, gpointer user_data)
{
static GPtrArray *old_value = NULL;
static gboolean answered = FALSE;
static gboolean answer = FALSE;
g_signal_handlers_block_by_func(object, G_CALLBACK(ipv4_addresses_changed_cb), NULL);
/* If method != manual, remove addresses (save them for restoring them later when method becomes 'manual' */
if (g_strcmp0(nm_setting_ip_config_get_method(NM_SETTING_IP_CONFIG(object)),
NM_SETTING_IP4_CONFIG_METHOD_MANUAL)) {
if (nm_setting_ip_config_get_num_addresses(NM_SETTING_IP_CONFIG(object))) {
if (!answered) {
answered = TRUE;
answer = get_answer("ipv4.addresses", NULL);
}
if (answer) {
nm_clear_pointer(&old_value, g_ptr_array_unref);
g_object_get(object, NM_SETTING_IP_CONFIG_ADDRESSES, &old_value, NULL);
g_object_set(object, NM_SETTING_IP_CONFIG_ADDRESSES, NULL, NULL);
}
}
} else {
answered = FALSE;
if (old_value) {
gs_unref_ptrarray GPtrArray *v = g_steal_pointer(&old_value);
g_object_set(object, NM_SETTING_IP_CONFIG_ADDRESSES, v, NULL);
}
}
g_signal_handlers_unblock_by_func(object, G_CALLBACK(ipv4_addresses_changed_cb), NULL);
}
static void
ipv6_addresses_changed_cb(GObject *object, GParamSpec *pspec, gpointer user_data)
{
static gboolean answered = FALSE;
static gboolean answer = FALSE;
g_signal_handlers_block_by_func(object, G_CALLBACK(ipv6_method_changed_cb), NULL);
/* If we have some IP addresses set method to 'manual'.
* Else if the method was 'manual', change it back to 'auto'.
*/
if (nm_setting_ip_config_get_num_addresses(NM_SETTING_IP_CONFIG(object))) {
if (g_strcmp0(nm_setting_ip_config_get_method(NM_SETTING_IP_CONFIG(object)),
NM_SETTING_IP6_CONFIG_METHOD_MANUAL)) {
if (!answered) {
answered = TRUE;
answer = get_answer("ipv6.method", "manual");
}
if (answer)
g_object_set(object,
NM_SETTING_IP_CONFIG_METHOD,
NM_SETTING_IP6_CONFIG_METHOD_MANUAL,
NULL);
}
} else {
answered = FALSE;
/* FIXME: editor_init_existing_connection() and registering handlers is not the
* right approach.
*
* This only happens to work because in nmcli's edit mode
* tends to append addresses -- instead of setting them.
* If we would change that (to behavior I'd expect), we'd get:
*
* nmcli> set ipv6.addresses fc01::1:5/68
* Do you also want to set 'ipv6.method' to 'manual'? [yes]: y
* nmcli> set ipv6.addresses fc01::1:6/68
* Do you also want to set 'ipv6.method' to 'manual'? [yes]:
*
* That's because nmc_setting_set_property() calls set_fcn(). With modifier '\0'
* (set), it would first clear all addresses before adding the address. Thereby
* emitting multiple property changed signals.
*
* That can be avoided by freezing/thawing the signals, but this solution
* here is ugly in general.
*/
if (!g_strcmp0(nm_setting_ip_config_get_method(NM_SETTING_IP_CONFIG(object)),
NM_SETTING_IP6_CONFIG_METHOD_MANUAL))
g_object_set(object,
NM_SETTING_IP_CONFIG_METHOD,
NM_SETTING_IP6_CONFIG_METHOD_AUTO,
NULL);
}
g_signal_handlers_unblock_by_func(object, G_CALLBACK(ipv6_method_changed_cb), NULL);
}
static void
ipv6_method_changed_cb(GObject *object, GParamSpec *pspec, gpointer user_data)
{
static GPtrArray *old_value = NULL;
static gboolean answered = FALSE;
static gboolean answer = FALSE;
g_signal_handlers_block_by_func(object, G_CALLBACK(ipv6_addresses_changed_cb), NULL);
/* If method != manual, remove addresses (save them for restoring them later when method becomes 'manual' */
if (g_strcmp0(nm_setting_ip_config_get_method(NM_SETTING_IP_CONFIG(object)),
NM_SETTING_IP6_CONFIG_METHOD_MANUAL)) {
if (nm_setting_ip_config_get_num_addresses(NM_SETTING_IP_CONFIG(object))) {
if (!answered) {
answered = TRUE;
answer = get_answer("ipv6.addresses", NULL);
}
if (answer) {
nm_clear_pointer(&old_value, g_ptr_array_unref);
g_object_get(object, NM_SETTING_IP_CONFIG_ADDRESSES, &old_value, NULL);
g_object_set(object, NM_SETTING_IP_CONFIG_ADDRESSES, NULL, NULL);
}
}
} else {
answered = FALSE;
if (old_value) {
gs_unref_ptrarray GPtrArray *v = g_steal_pointer(&old_value);
g_object_set(object, NM_SETTING_IP_CONFIG_ADDRESSES, v, NULL);
}
}
g_signal_handlers_unblock_by_func(object, G_CALLBACK(ipv6_addresses_changed_cb), NULL);
}
static void
proxy_method_changed_cb(GObject *object, GParamSpec *pspec, gpointer user_data)
{
NMSettingProxyMethod method;
method = nm_setting_proxy_get_method(NM_SETTING_PROXY(object));
if (method == NM_SETTING_PROXY_METHOD_NONE) {
g_object_set(object,
NM_SETTING_PROXY_PAC_URL,
NULL,
NM_SETTING_PROXY_PAC_SCRIPT,
NULL,
NULL);
}
}
static void
wireless_band_channel_changed_cb(GObject *object, GParamSpec *pspec, gpointer user_data)
{
const char *value = NULL, *mode;
char str[16];
NMSettingWireless *s_wireless = NM_SETTING_WIRELESS(object);
if (strcmp(g_param_spec_get_name(pspec), NM_SETTING_WIRELESS_BAND) == 0) {
value = nm_setting_wireless_get_band(s_wireless);
if (!value)
return;
} else {
guint32 channel = nm_setting_wireless_get_channel(s_wireless);
if (channel == 0)
return;
g_snprintf(str, sizeof(str), "%d", nm_setting_wireless_get_channel(s_wireless));
value = str;
}
mode = nm_setting_wireless_get_mode(NM_SETTING_WIRELESS(object));
if (!mode || !*mode || strcmp(mode, NM_SETTING_WIRELESS_MODE_INFRA) == 0) {
g_print(_("Warning: %s.%s set to '%s', but it might be ignored in infrastructure mode\n"),
nm_setting_get_name(NM_SETTING(s_wireless)),
g_param_spec_get_name(pspec),
value);
}
}
static void
connection_master_changed_cb(GObject *object, GParamSpec *pspec, gpointer user_data)
{
NMSettingConnection *s_con = NM_SETTING_CONNECTION(object);
NMConnection *connection = NM_CONNECTION(user_data);
NMSetting *s_ipv4, *s_ipv6;
const char *value, *tmp_str;
value = nm_setting_connection_get_master(s_con);
if (value) {
s_ipv4 = nm_connection_get_setting_by_name(connection, NM_SETTING_IP4_CONFIG_SETTING_NAME);
s_ipv6 = nm_connection_get_setting_by_name(connection, NM_SETTING_IP6_CONFIG_SETTING_NAME);
if (s_ipv4 || s_ipv6) {
g_print(_("Warning: setting %s.%s requires removing ipv4 and ipv6 settings\n"),
nm_setting_get_name(NM_SETTING(s_con)),
g_param_spec_get_name(pspec));
tmp_str = nmc_get_user_input(_("Do you want to remove them? [yes] "));
if (!tmp_str || matches(tmp_str, "yes")) {
if (s_ipv4)
nm_connection_remove_setting(connection, G_OBJECT_TYPE(s_ipv4));
if (s_ipv6)
nm_connection_remove_setting(connection, G_OBJECT_TYPE(s_ipv6));
}
}
}
}
void
nmc_setting_ip4_connect_handlers(NMSettingIPConfig *setting)
{
g_return_if_fail(NM_IS_SETTING_IP4_CONFIG(setting));
g_signal_connect(setting,
"notify::" NM_SETTING_IP_CONFIG_ADDRESSES,
G_CALLBACK(ipv4_addresses_changed_cb),
NULL);
g_signal_connect(setting,
"notify::" NM_SETTING_IP_CONFIG_METHOD,
G_CALLBACK(ipv4_method_changed_cb),
NULL);
}
void
nmc_setting_ip6_connect_handlers(NMSettingIPConfig *setting)
{
g_return_if_fail(NM_IS_SETTING_IP6_CONFIG(setting));
g_signal_connect(setting,
"notify::" NM_SETTING_IP_CONFIG_ADDRESSES,
G_CALLBACK(ipv6_addresses_changed_cb),
NULL);
g_signal_connect(setting,
"notify::" NM_SETTING_IP_CONFIG_METHOD,
G_CALLBACK(ipv6_method_changed_cb),
NULL);
}
void
nmc_setting_proxy_connect_handlers(NMSettingProxy *setting)
{
g_return_if_fail(NM_IS_SETTING_PROXY(setting));
g_signal_connect(setting,
"notify::" NM_SETTING_PROXY_METHOD,
G_CALLBACK(proxy_method_changed_cb),
NULL);
}
void
nmc_setting_wireless_connect_handlers(NMSettingWireless *setting)
{
g_return_if_fail(NM_IS_SETTING_WIRELESS(setting));
g_signal_connect(setting,
"notify::" NM_SETTING_WIRELESS_BAND,
G_CALLBACK(wireless_band_channel_changed_cb),
NULL);
g_signal_connect(setting,
"notify::" NM_SETTING_WIRELESS_CHANNEL,
G_CALLBACK(wireless_band_channel_changed_cb),
NULL);
}
void
nmc_setting_connection_connect_handlers(NMSettingConnection *setting, NMConnection *connection)
{
g_return_if_fail(NM_IS_SETTING_CONNECTION(setting));
g_signal_connect(setting,
"notify::" NM_SETTING_CONNECTION_MASTER,
G_CALLBACK(connection_master_changed_cb),
connection);
}
/*****************************************************************************/
static gboolean
_set_fcn_precheck_connection_secondaries(NMClient *client,
const char *value,
char **value_coerced,
GError **error)
{
const GPtrArray *connections;
NMConnection *con;
gs_free const char **strv0 = NULL;
gs_strfreev char **strv = NULL;
char **iter;
gboolean modified = FALSE;
strv0 = nm_strsplit_set(value, " \t,");
if (!strv0)
return TRUE;
connections = nm_client_get_connections(client);
strv = g_strdupv((char **) strv0);
for (iter = strv; *iter; iter++) {
if (nm_utils_is_uuid(*iter)) {
con = nmc_find_connection(connections, "uuid", *iter, NULL, FALSE);
if (!con) {
g_print(_("Warning: %s is not an UUID of any existing connection profile\n"),
*iter);
} else {
/* Currently, NM only supports VPN connections as secondaries */
if (!nm_connection_is_type(con, NM_SETTING_VPN_SETTING_NAME)) {
g_set_error(error, 1, 0, _("'%s' is not a VPN connection profile"), *iter);
return FALSE;
}
}
} else {
con = nmc_find_connection(connections, "id", *iter, NULL, FALSE);
if (!con) {
g_set_error(error, 1, 0, _("'%s' is not a name of any exiting profile"), *iter);
return FALSE;
}
/* Currently, NM only supports VPN connections as secondaries */
if (!nm_connection_is_type(con, NM_SETTING_VPN_SETTING_NAME)) {
g_set_error(error, 1, 0, _("'%s' is not a VPN connection profile"), *iter);
return FALSE;
}
/* translate id to uuid */
g_free(*iter);
*iter = g_strdup(nm_connection_get_uuid(con));
modified = TRUE;
}
}
if (modified)
*value_coerced = g_strjoinv(" ", strv);
return TRUE;
}
/*****************************************************************************/
static void
_env_warn_fcn_handle(
const NMMetaEnvironment *environment,
gpointer environment_user_data,
NMMetaEnvWarnLevel warn_level,
const char *
fmt_l10n, /* the untranslated format string, but it is marked for translation using N_(). */
va_list ap)
{
NmCli *nmc = environment_user_data;
gs_free char *m = NULL;
if (nmc->complete)
return;
NM_PRAGMA_WARNING_DISABLE("-Wformat-nonliteral")
m = g_strdup_vprintf(_(fmt_l10n), ap);
NM_PRAGMA_WARNING_REENABLE
switch (warn_level) {
case NM_META_ENV_WARN_LEVEL_WARN:
g_print(_("Warning: %s\n"), m);
return;
case NM_META_ENV_WARN_LEVEL_INFO:
g_print(_("Info: %s\n"), m);
return;
}
g_print(_("Error: %s\n"), m);
}
static NMDevice *const *
_env_get_nm_devices(const NMMetaEnvironment *environment,
gpointer environment_user_data,
guint *out_len)
{
NmCli *nmc = environment_user_data;
const GPtrArray *devices;
nm_assert(nmc);
/* the returned list is *not* NULL terminated. Need to
* provide and honor the out_len argument. */
nm_assert(out_len);
devices = nm_client_get_devices(nmc->client);
if (!devices) {
*out_len = 0;
return NULL;
}
*out_len = devices->len;
return (NMDevice *const *) devices->pdata;
}
static NMRemoteConnection *const *
_env_get_nm_connections(const NMMetaEnvironment *environment,
gpointer environment_user_data,
guint *out_len)
{
NmCli *nmc = environment_user_data;
const GPtrArray *values;
nm_assert(nmc);
/* the returned list is *not* NULL terminated. Need to
* provide and honor the out_len argument. */
nm_assert(out_len);
values = nm_client_get_connections(nmc->client);
if (!values) {
*out_len = 0;
return NULL;
}
*out_len = values->len;
return (NMRemoteConnection *const *) values->pdata;
}
/*****************************************************************************/
const NMMetaEnvironment *const nmc_meta_environment = &((NMMetaEnvironment){
.warn_fcn = _env_warn_fcn_handle,
.get_nm_devices = _env_get_nm_devices,
.get_nm_connections = _env_get_nm_connections,
});
static char *
get_property_val(NMSetting *setting,
const char *prop,
NMMetaAccessorGetType get_type,
gboolean show_secrets,
GError **error)
{
const NMMetaPropertyInfo *property_info;
g_return_val_if_fail(NM_IS_SETTING(setting), NULL);
g_return_val_if_fail(!error || !*error, NULL);
g_return_val_if_fail(
NM_IN_SET(get_type, NM_META_ACCESSOR_GET_TYPE_PARSABLE, NM_META_ACCESSOR_GET_TYPE_PRETTY),
NULL);
if ((property_info = nm_meta_property_info_find_by_setting(setting, prop))) {
if (property_info->property_type->get_fcn) {
NMMetaAccessorGetOutFlags out_flags = NM_META_ACCESSOR_GET_OUT_FLAGS_NONE;
char *to_free = NULL;
const char *value;
value = property_info->property_type->get_fcn(
property_info,
nmc_meta_environment,
(gpointer) nmc_meta_environment_arg,
setting,
get_type,
show_secrets ? NM_META_ACCESSOR_GET_FLAGS_SHOW_SECRETS : 0,
&out_flags,
NULL,
(gpointer *) &to_free);
nm_assert(!out_flags);
return to_free ?: g_strdup(value);
}
}
g_set_error_literal(error, 1, 0, _("don't know how to get the property value"));
return NULL;
}
/*
* Generic function for getting property value.
*
* Gets property value as a string by calling specialized functions.
*
* Returns: current property value. The caller must free the returned string.
*/
char *
nmc_setting_get_property(NMSetting *setting, const char *prop, GError **error)
{
return get_property_val(setting, prop, NM_META_ACCESSOR_GET_TYPE_PRETTY, TRUE, error);
}
/*
* Similar to nmc_setting_get_property(), but returns the property in a string
* format that can be parsed via nmc_setting_set_property().
*/
char *
nmc_setting_get_property_parsable(NMSetting *setting, const char *prop, GError **error)
{
return get_property_val(setting, prop, NM_META_ACCESSOR_GET_TYPE_PARSABLE, TRUE, error);
}
gboolean
nmc_setting_set_property(NMClient *client,
NMSetting *setting,
const char *prop,
NMMetaAccessorModifier modifier,
const char *value,
GError **error)
{
const NMMetaPropertyInfo *property_info;
gs_free char *value_to_free = NULL;
gboolean success;
g_return_val_if_fail(NM_IS_SETTING(setting), FALSE);
g_return_val_if_fail(error == NULL || *error == NULL, FALSE);
g_return_val_if_fail(NM_IN_SET(modifier,
NM_META_ACCESSOR_MODIFIER_SET,
NM_META_ACCESSOR_MODIFIER_DEL,
NM_META_ACCESSOR_MODIFIER_ADD),
FALSE);
if (!(property_info = nm_meta_property_info_find_by_setting(setting, prop)))
goto out_fail_read_only;
if (!property_info->property_type->set_fcn)
goto out_fail_read_only;
if (modifier == NM_META_ACCESSOR_MODIFIER_DEL
&& !property_info->property_type->set_supports_remove) {
/* The property is a plain property. It does not support '-'.
*
* Maybe we should fail, but just return silently. */
return TRUE;
}
if (value) {
switch (property_info->setting_info->general->meta_type) {
case NM_META_SETTING_TYPE_CONNECTION:
if (nm_streq(property_info->property_name, NM_SETTING_CONNECTION_SECONDARIES)) {
if (!_set_fcn_precheck_connection_secondaries(client, value, &value_to_free, error))
return FALSE;
if (value_to_free)
value = value_to_free;
}
break;
default:
break;
}
}
if (NM_IN_SET(modifier, NM_META_ACCESSOR_MODIFIER_ADD, NM_META_ACCESSOR_MODIFIER_DEL)
&& (!value || !value[0])) {
/* nothing to do. */
return TRUE;
}
g_object_freeze_notify(G_OBJECT(setting));
success = property_info->property_type->set_fcn(property_info,
nmc_meta_environment,
(gpointer) nmc_meta_environment_arg,
setting,
modifier,
value,
error);
g_object_thaw_notify(G_OBJECT(setting));
return success;
out_fail_read_only:
nm_utils_error_set(error, NM_UTILS_ERROR_UNKNOWN, _("the property can't be changed"));
return FALSE;
}
/*
* Get valid property names for a setting.
*
* Returns: string array with the properties or NULL on failure.
* The returned value should be freed with g_strfreev()
*/
char **
nmc_setting_get_valid_properties(NMSetting *setting)
{
const NMMetaSettingInfoEditor *setting_info;
char **valid_props;
guint i, num;
setting_info = nm_meta_setting_info_editor_find_by_setting(setting);
num = setting_info ? setting_info->properties_num : 0;
valid_props = g_new(char *, num + 1);
for (i = 0; i < num; i++)
valid_props[i] = g_strdup(setting_info->properties[i]->property_name);
valid_props[num] = NULL;
return valid_props;
}
const char *const *
nmc_setting_get_property_allowed_values(NMSetting *setting, const char *prop, char ***out_to_free)
{
const NMMetaPropertyInfo *property_info;
g_return_val_if_fail(NM_IS_SETTING(setting), FALSE);
g_return_val_if_fail(out_to_free, FALSE);
*out_to_free = NULL;
if ((property_info = nm_meta_property_info_find_by_setting(setting, prop))) {
if (property_info->property_type->values_fcn) {
return property_info->property_type->values_fcn(property_info, out_to_free);
} else if (property_info->property_typ_data
&& property_info->property_typ_data->values_static)
return property_info->property_typ_data->values_static;
}
return NULL;
}
/*
* Create a description string for a property.
*
* It returns a description got from property documentation, concatenated with
* nmcli specific description (if it exists).
*
* Returns: property description or NULL on failure. The caller must free the string.
*/
char *
nmc_setting_get_property_desc(NMSetting *setting, const char *prop)
{
gs_free char *desc_to_free = NULL;
const char *setting_desc = NULL;
const char *setting_desc_title = "";
const char *nmcli_desc = NULL;
const char *nmcli_desc_title = "";
const char *nmcli_nl = "";
const NMMetaPropertyInfo *property_info;
const char *desc = NULL;
g_return_val_if_fail(NM_IS_SETTING(setting), FALSE);
property_info = nm_meta_property_info_find_by_setting(setting, prop);
if (!property_info)
return NULL;
if (property_info->describe_doc) {
setting_desc = _(property_info->describe_doc);
setting_desc_title = _("[NM property description]");
}
if (property_info->property_type->describe_fcn) {
desc = property_info->property_type->describe_fcn(property_info, &desc_to_free);
} else
desc = _(property_info->describe_message);
if (desc) {
nmcli_desc = desc;
nmcli_desc_title = _("[nmcli specific description]");
nmcli_nl = "\n";
}
return g_strdup_printf("%s\n%s\n%s%s%s%s",
setting_desc_title,
setting_desc ?: "",
nmcli_nl,
nmcli_desc_title,
nmcli_nl,
nmcli_desc ?: "");
}
/*****************************************************************************/
gboolean
setting_details(const NmcConfig *nmc_config, NMSetting *setting, const char *one_prop)
{
const NMMetaSettingInfoEditor *setting_info;
gs_free_error GError *error = NULL;
gs_free char *fields_str = NULL;
g_return_val_if_fail(NM_IS_SETTING(setting), FALSE);
setting_info = nm_meta_setting_info_editor_find_by_setting(setting);
if (!setting_info)
return FALSE;
if (one_prop) {
/* hack around setting-details being called for one setting. Must prefix the
* property name with the setting name. Later we should remove setting_details()
* and merge it into the caller. */
fields_str = g_strdup_printf("%s.%s", nm_setting_get_name(setting), one_prop);
}
if (!nmc_print(
nmc_config,
(gpointer[]){setting, NULL},
NULL,
NULL,
(const NMMetaAbstractInfo *const[]){(const NMMetaAbstractInfo *) setting_info, NULL},
fields_str,
&error))
return FALSE;
return TRUE;
}
Reference in a new issue View git blame Copy permalink