fdo-mirrors/NetworkManager
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/NetworkManager/NetworkManager.git synced 2026-02-23 19:00:34 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

all: merge branch 'th/gvariant-helpers'

Browse source 
https://gitlab.freedesktop.org/NetworkManager/NetworkManager/-/merge_requests/817
This commit is contained in:
Thomas Haller 2021-04-16 15:17:28 +02:00
commit e4537e9021
No known key found for this signature in database
GPG key ID: 29C2366E4DFC5728
25 changed files with 165 additions and 150 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
src/core/NetworkManagerUtils.c
View file

@ -1496,12 +1496,7 @@ nm_utils_ip_addresses_to_dbus(int addr_family,
: (guint32) 0,
};
g_variant_builder_add(&builder_legacy,
"@au",
g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
dbus_addr,
3,
sizeof(guint32)));
g_variant_builder_add(&builder_legacy, "@au", nm_g_variant_new_au(dbus_addr, 3));
} else {
g_variant_builder_add(
&builder_legacy,
@ -1623,12 +1618,7 @@ nm_utils_ip_routes_to_dbus(int addr_family,
r->r4.metric,
};
g_variant_builder_add(&builder_legacy,
"@au",
g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
dbus_route,
4,
sizeof(guint32)));
g_variant_builder_add(&builder_legacy, "@au", nm_g_variant_new_au(dbus_route, 4));
} else {
g_variant_builder_add(&builder_legacy,
"(@ayu@ayu)",

8
src/core/devices/nm-device-wireguard.c
View file

@ -1939,11 +1939,9 @@ get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
switch (prop_id) {
case PROP_PUBLIC_KEY:
g_value_take_variant(value,
g_variant_new_fixed_array(G_VARIANT_TYPE_BYTE,
priv->lnk_curr.public_key,
sizeof(priv->lnk_curr.public_key),
1));
g_value_take_variant(
value,
nm_g_variant_new_ay(priv->lnk_curr.public_key, sizeof(priv->lnk_curr.public_key)));
break;
case PROP_LISTEN_PORT:
g_value_set_uint(value, priv->lnk_curr.listen_port);

13
src/core/devices/nm-device.c
View file

@ -12968,7 +12968,7 @@ impl_device_get_applied_connection(NMDBusObject * obj,
var_settings =
nm_connection_to_dbus(applied_connection, NM_CONNECTION_SERIALIZE_WITH_NON_SECRET);
if (!var_settings)
var_settings = g_variant_new_array(G_VARIANT_TYPE("{sa{sv}}"), NULL, 0);
var_settings = nm_g_variant_singleton_aLsaLsvII();
g_dbus_method_invocation_return_value(
invocation,
@ -17900,7 +17900,6 @@ get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
{
NMDevice * self = NM_DEVICE(object);
NMDevicePrivate *priv = NM_DEVICE_GET_PRIVATE(self);
GVariantBuilder array_builder;
switch (prop_id) {
case PROP_UDI:
@ -18051,12 +18050,10 @@ get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
g_value_set_uint(value, priv->metered);
break;
case PROP_LLDP_NEIGHBORS:
if (priv->lldp_listener)
g_value_set_variant(value, nm_lldp_listener_get_neighbors(priv->lldp_listener));
else {
g_variant_builder_init(&array_builder, G_VARIANT_TYPE("aa{sv}"));
g_value_take_variant(value, g_variant_builder_end(&array_builder));
}
g_value_set_variant(value,
priv->lldp_listener
? nm_lldp_listener_get_neighbors(priv->lldp_listener)
: nm_g_variant_singleton_aaLsvI());
break;
case PROP_REAL:
g_value_set_boolean(value, nm_device_is_real(self));

2
src/core/dhcp/nm-dhcp-helper.c
View file

@ -92,7 +92,7 @@ build_signal_parameters(void)
g_variant_builder_add(&builder,
"{sv}",
name,
g_variant_new_fixed_array(G_VARIANT_TYPE_BYTE, val, strlen(val), 1));
nm_g_variant_new_ay((const guint8 *) val, strlen(val)));
next:;
}

5
src/core/dns/nm-dns-systemd-resolved.c
View file

@ -201,10 +201,7 @@ update_add_ip_config(NMDnsSystemdResolved *self,
g_variant_builder_add(dns, "i", addr_family);
g_variant_builder_add_value(
dns,
g_variant_new_fixed_array(G_VARIANT_TYPE_BYTE,
nm_ip_config_get_nameserver(data->ip_config, i),
addr_size,
1));
nm_g_variant_new_ay(nm_ip_config_get_nameserver(data->ip_config, i), addr_size));
g_variant_builder_close(dns);
has_config = TRUE;
}

3
src/core/nm-dhcp-config.c
View file

@ -116,8 +116,7 @@ get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
switch (prop_id) {
case PROP_OPTIONS:
g_value_set_variant(value,
priv->options ?: g_variant_new_array(G_VARIANT_TYPE("{sv}"), NULL, 0));
g_value_set_variant(value, priv->options ?: nm_g_variant_singleton_aLsvI());
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);

16
src/core/nm-dispatcher.c
View file

@ -206,10 +206,7 @@ dump_ip_to_props(NMIPConfig *ip, GVariantBuilder *builder)
array[0] = addr->a4.address;
array[1] = addr->a4.plen;
array[2] = gw;
g_variant_builder_add(
&int_builder,
"@au",
g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32, array, 3, sizeof(guint32)));
g_variant_builder_add(&int_builder, "@au", nm_g_variant_new_au(array, 3));
} else {
const struct in6_addr *gw = &in6addr_any;
@ -278,10 +275,7 @@ dump_ip_to_props(NMIPConfig *ip, GVariantBuilder *builder)
array[1] = route->r4.plen;
array[2] = route->r4.gateway;
array[3] = route->r4.metric;
g_variant_builder_add(
&int_builder,
"@au",
g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32, array, 4, sizeof(guint32)));
g_variant_builder_add(&int_builder, "@au", nm_g_variant_new_au(array, 4));
} else {
var1 = nm_g_variant_new_ay_in6addr(&route->r6.network);
var2 = nm_g_variant_new_ay_in6addr(&route->r6.gateway);
@ -552,7 +546,7 @@ _dispatcher_call(NMDispatcherAction action,
connection_dict =
nm_connection_to_dbus(applied_connection, NM_CONNECTION_SERIALIZE_WITH_NON_SECRET);
else
connection_dict = g_variant_new_array(G_VARIANT_TYPE("{sa{sv}}"), NULL, 0);
connection_dict = nm_g_variant_singleton_aLsaLsvII();
g_variant_builder_init(&connection_props, G_VARIANT_TYPE_VARDICT);
if (settings_connection) {
@ -620,8 +614,8 @@ _dispatcher_call(NMDispatcherAction action,
&device_proxy_props,
&device_ip4_props,
&device_ip6_props,
device_dhcp4_props ?: g_variant_new_array(G_VARIANT_TYPE("{sv}"), NULL, 0),
device_dhcp6_props ?: g_variant_new_array(G_VARIANT_TYPE("{sv}"), NULL, 0),
device_dhcp4_props ?: nm_g_variant_singleton_aLsvI(),
device_dhcp6_props ?: nm_g_variant_singleton_aLsvI(),
connectivity_state_string,
vpn_iface ?: "",
&vpn_proxy_props,

16
src/core/nm-ip4-config.c
View file

@ -3016,11 +3016,9 @@ get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
g_value_take_variant(value, g_variant_builder_end(&builder_data));
break;
case PROP_NAMESERVERS:
g_value_take_variant(value,
g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
priv->nameservers->data,
priv->nameservers->len,
sizeof(guint32)));
g_value_take_variant(
value,
nm_g_variant_new_au((const guint32 *) priv->nameservers->data, priv->nameservers->len));
break;
case PROP_DOMAINS:
nm_utils_g_value_set_strv(value, priv->domains);
@ -3045,11 +3043,9 @@ get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
g_value_take_variant(value, g_variant_builder_end(&builder_data));
break;
case PROP_WINS_SERVERS:
g_value_take_variant(value,
g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
priv->wins->data,
priv->wins->len,
sizeof(guint32)));
g_value_take_variant(
value,
nm_g_variant_new_au((const guint32 *) priv->wins->data, priv->wins->len));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);

4
src/core/nm-ip6-config.c
View file

@ -2409,9 +2409,7 @@ nameservers_to_gvalue(GArray *array, GValue *value)
struct in6_addr *addr;
addr = &g_array_index(array, struct in6_addr, i++);
g_variant_builder_add(&builder,
"@ay",
g_variant_new_fixed_array(G_VARIANT_TYPE_BYTE, addr, 16, 1));
g_variant_builder_add(&builder, "@ay", nm_g_variant_new_ay_in6addr(addr));
}
g_value_take_variant(value, g_variant_builder_end(&builder));

8
src/core/nm-manager.c
View file

@ -5637,7 +5637,7 @@ activation_add_done(NMSettings * settings,
result_floating = g_variant_new("(oo@a{sv})",
nm_dbus_object_get_path(NM_DBUS_OBJECT(new_connection)),
nm_dbus_object_get_path(NM_DBUS_OBJECT(active)),
g_variant_new_array(G_VARIANT_TYPE("{sv}"), NULL, 0));
nm_g_variant_singleton_aLsvI());
}
g_dbus_method_invocation_return_value(context, result_floating);
@ -7940,10 +7940,8 @@ get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
break;
case PROP_CAPABILITIES:
g_value_set_variant(value,
g_variant_new_fixed_array(G_VARIANT_TYPE("u"),
priv->capabilities->data,
priv->capabilities->len,
sizeof(guint32)));
nm_g_variant_new_au((const guint32 *) priv->capabilities->data,
priv->capabilities->len));
break;
case PROP_STATE:
g_value_set_uint(value, priv->state);

18
src/core/ppp/nm-pppd-plugin.c
View file

@ -226,11 +226,10 @@ nm_ip_up(void *data, int arg)
if (opts.dnsaddr[1])
dns[len++] = opts.dnsaddr[1];
g_variant_builder_add(
&builder,
"{sv}",
NM_PPP_IP4_CONFIG_DNS,
g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32, dns, len, sizeof(guint32)));
g_variant_builder_add(&builder,
"{sv}",
NM_PPP_IP4_CONFIG_DNS,
nm_g_variant_new_au(dns, len));
}
if (opts.winsaddr[0] || opts.winsaddr[1]) {
@ -242,11 +241,10 @@ nm_ip_up(void *data, int arg)
if (opts.winsaddr[1])
wins[len++] = opts.winsaddr[1];
g_variant_builder_add(
&builder,
"{sv}",
NM_PPP_IP4_CONFIG_WINS,
g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32, wins, len, sizeof(guint32)));
g_variant_builder_add(&builder,
"{sv}",
NM_PPP_IP4_CONFIG_WINS,
nm_g_variant_new_au(wins, len));
}
g_message("nm-ppp-plugin: sending IPv4 config to NetworkManager...");

2
src/core/settings/nm-settings-connection.c
View file

@ -1868,7 +1868,7 @@ dbus_get_agent_secrets_cb(NMSettingsConnection * self,
dict = nm_connection_to_dbus(nm_settings_connection_get_connection(self),
NM_CONNECTION_SERIALIZE_WITH_SECRETS);
if (!dict)
dict = g_variant_new_array(G_VARIANT_TYPE("{sa{sv}}"), NULL, 0);
dict = nm_g_variant_singleton_aLsaLsvII();
g_dbus_method_invocation_return_value(context, g_variant_new("(@a{sa{sv}})", dict));
}
}

9
src/core/supplicant/nm-supplicant-config.c
View file

@ -334,11 +334,10 @@ nm_supplicant_config_to_variant(NMSupplicantConfig *self)
break;
case NM_SUPPL_OPT_TYPE_BYTES:
case NM_SUPPL_OPT_TYPE_UTF8:
g_variant_builder_add(
&builder,
"{sv}",
key,
g_variant_new_fixed_array(G_VARIANT_TYPE_BYTE, option->value, option->len, 1));
g_variant_builder_add(&builder,
"{sv}",
key,
nm_g_variant_new_ay((const guint8 *) option->value, option->len));
break;
case NM_SUPPL_OPT_TYPE_KEYWORD:
case NM_SUPPL_OPT_TYPE_STRING:

9
src/core/supplicant/nm-supplicant-interface.c
View file

@ -1619,11 +1619,10 @@ _wps_handle_set_pc_cb(GVariant *res, GError *error, gpointer user_data)
* enroll with any BSS in range. */
if (!nm_utils_hwaddr_aton(wps_data->bssid, bssid_buf, sizeof(bssid_buf)))
nm_assert_not_reached();
g_variant_builder_add(
&start_args,
"{sv}",
"Bssid",
g_variant_new_fixed_array(G_VARIANT_TYPE_BYTE, bssid_buf, ETH_ALEN, sizeof(guint8)));
g_variant_builder_add(&start_args,
"{sv}",
"Bssid",
nm_g_variant_new_ay(bssid_buf, ETH_ALEN));
}
wps_data->needs_cancelling = TRUE;

41
src/libnm-client-impl/nm-client.c
View file

@ -5137,11 +5137,11 @@ _add_and_activate_connection(NMClient * self,
if (partial)
arg_connection = nm_connection_to_dbus(partial, NM_CONNECTION_SERIALIZE_ALL);
if (!arg_connection)
arg_connection = g_variant_new_array(G_VARIANT_TYPE("{sa{sv}}"), NULL, 0);
arg_connection = nm_g_variant_singleton_aLsaLsvII();
if (is_v2) {
if (!options)
options = g_variant_new_array(G_VARIANT_TYPE("{sv}"), NULL, 0);
options = nm_g_variant_singleton_aLsvI();
use_add_and_activate_v2 = TRUE;
source_tag = nm_client_add_and_activate_connection2;
} else {
@ -5641,7 +5641,7 @@ _add_connection_call(NMClient * self,
NML_NMCLIENT_LOG_D(self, "AddConnection() started...");
if (!settings)
settings = g_variant_new_array(G_VARIANT_TYPE("{sa{sv}}"), NULL, 0);
settings = nm_g_variant_singleton_aLsaLsvII();
/* Although AddConnection2() being capable to handle also AddConnection() and
* AddConnectionUnsaved() variants, we prefer to use the old D-Bus methods when
@ -5678,24 +5678,23 @@ _add_connection_call(NMClient * self,
NM_DBUS_DEFAULT_TIMEOUT_MSEC,
_add_connection_cb_without_extra_result);
} else {
_nm_client_dbus_call(
self,
self,
source_tag,
cancellable,
callback,
user_data,
NM_DBUS_PATH_SETTINGS,
NM_DBUS_INTERFACE_SETTINGS,
"AddConnection2",
g_variant_new("(@a{sa{sv}}u@a{sv})",
settings,
(guint32) flags,
args ?: g_variant_new_array(G_VARIANT_TYPE("{sv}"), NULL, 0)),
G_VARIANT_TYPE("(oa{sv})"),
G_DBUS_CALL_FLAGS_NONE,
NM_DBUS_DEFAULT_TIMEOUT_MSEC,
_add_connection_cb_with_extra_result);
_nm_client_dbus_call(self,
self,
source_tag,
cancellable,
callback,
user_data,
NM_DBUS_PATH_SETTINGS,
NM_DBUS_INTERFACE_SETTINGS,
"AddConnection2",
g_variant_new("(@a{sa{sv}}u@a{sv})",
settings,
(guint32) flags,
args ?: nm_g_variant_singleton_aLsvI()),
G_VARIANT_TYPE("(oa{sv})"),
G_DBUS_CALL_FLAGS_NONE,
NM_DBUS_DEFAULT_TIMEOUT_MSEC,
_add_connection_cb_with_extra_result);
}
}

2
src/libnm-client-impl/nm-device-wifi-p2p.c
View file

@ -156,7 +156,7 @@ nm_device_wifi_p2p_start_find(NMDeviceWifiP2P * device,
g_return_if_fail(!cancellable || G_IS_CANCELLABLE(cancellable));
if (!options)
options = g_variant_new_array(G_VARIANT_TYPE("{sv}"), NULL, 0);
options = nm_g_variant_singleton_aLsvI();
_nm_client_dbus_call(_nm_object_get_client(device),
device,

4
src/libnm-client-impl/nm-device-wifi.c
View file

@ -309,7 +309,7 @@ nm_device_wifi_request_scan_options(NMDeviceWifi *device,
g_return_val_if_fail(!error || !*error, FALSE);
if (!options)
options = g_variant_new_array(G_VARIANT_TYPE("{sv}"), NULL, 0);
options = nm_g_variant_singleton_aLsvI();
return _nm_client_dbus_call_sync_void(_nm_object_get_client(device),
cancellable,
@ -382,7 +382,7 @@ nm_device_wifi_request_scan_options_async(NMDeviceWifi * device,
g_return_if_fail(!cancellable || G_IS_CANCELLABLE(cancellable));
if (!options)
options = g_variant_new_array(G_VARIANT_TYPE("{sv}"), NULL, 0);
options = nm_g_variant_singleton_aLsvI();
_nm_client_dbus_call(_nm_object_get_client(device),
device,

4
src/libnm-client-impl/nm-device.c
View file

@ -2303,7 +2303,7 @@ nm_device_reapply(NMDevice * device,
if (connection)
arg_connection = nm_connection_to_dbus(connection, NM_CONNECTION_SERIALIZE_ALL);
if (!arg_connection)
arg_connection = g_variant_new_array(G_VARIANT_TYPE("{sa{sv}}"), NULL, 0);
arg_connection = nm_g_variant_singleton_aLsaLsvII();
return _nm_client_dbus_call_sync_void(
_nm_object_get_client(device),
@ -2355,7 +2355,7 @@ nm_device_reapply_async(NMDevice * device,
if (connection)
arg_connection = nm_connection_to_dbus(connection, NM_CONNECTION_SERIALIZE_ALL);
if (!arg_connection)
arg_connection = g_variant_new_array(G_VARIANT_TYPE("{sa{sv}}"), NULL, 0);
arg_connection = nm_g_variant_singleton_aLsaLsvII();
_nm_client_dbus_call(_nm_object_get_client(device),
device,

6
src/libnm-client-impl/nm-remote-connection.c
View file

@ -95,9 +95,9 @@ nm_remote_connection_update2(NMRemoteConnection * connection,
g_return_if_fail(!cancellable || G_IS_CANCELLABLE(cancellable));
if (!settings)
settings = g_variant_new_array(G_VARIANT_TYPE("{sa{sv}}"), NULL, 0);
settings = nm_g_variant_singleton_aLsaLsvII();
if (!args)
args = g_variant_new_array(G_VARIANT_TYPE("{sv}"), NULL, 0);
args = nm_g_variant_singleton_aLsvI();
_nm_client_dbus_call(_nm_object_get_client(connection),
connection,
@ -185,7 +185,7 @@ nm_remote_connection_commit_changes(NMRemoteConnection *connection,
nm_connection_to_dbus(NM_CONNECTION(connection), NM_CONNECTION_SERIALIZE_ALL),
(guint32)(save_to_disk ? NM_SETTINGS_UPDATE2_FLAG_TO_DISK
: NM_SETTINGS_UPDATE2_FLAG_IN_MEMORY),
g_variant_new_array(G_VARIANT_TYPE("{sv}"), NULL, 0)),
nm_g_variant_singleton_aLsvI()),
G_VARIANT_TYPE("(a{sv})"),
G_DBUS_CALL_FLAGS_NONE,
NM_DBUS_DEFAULT_TIMEOUT_MSEC,

2
src/libnm-core-impl/nm-setting-dcb.c
View file

@ -733,7 +733,7 @@ _nm_setting_dcb_uint_array_to_dbus(const GValue *prop_value)
{
GArray *src = g_value_get_boxed(prop_value);
return g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32, src->data, src->len, sizeof(guint32));
return nm_g_variant_new_au((const guint32 *) src->data, src->len);
}
static void

12
src/libnm-core-impl/nm-utils.c
View file

@ -1377,10 +1377,7 @@ nm_utils_ip4_addresses_to_variant(GPtrArray *addresses, const char *gateway)
array[1] = nm_ip_address_get_prefix(addr);
array[2] = gw;
g_variant_builder_add(
&builder,
"@au",
g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32, array, 3, sizeof(guint32)));
g_variant_builder_add(&builder, "@au", nm_g_variant_new_au(array, 3));
}
}
@ -1479,10 +1476,7 @@ nm_utils_ip4_routes_to_variant(GPtrArray *routes)
/* The old routes format uses "0" for default, not "-1" */
array[3] = MAX(0, nm_ip_route_get_metric(route));
g_variant_builder_add(
&builder,
"@au",
g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32, array, 4, sizeof(guint32)));
g_variant_builder_add(&builder, "@au", nm_g_variant_new_au(array, 4));
}
}
@ -4227,7 +4221,7 @@ _nm_utils_hwaddr_to_dbus_impl(const char *str)
if (!_nm_utils_hwaddr_aton(str, buf, sizeof(buf), &len))
return NULL;
return g_variant_new_fixed_array(G_VARIANT_TYPE_BYTE, buf, len, 1);
return nm_g_variant_new_ay(buf, len);
}
static GVariant *

19
src/libnm-core-impl/tests/test-secrets.c
View file

@ -526,20 +526,25 @@ test_update_secrets_whole_connection(void)
static void
test_update_secrets_whole_connection_empty_hash(void)
{
NMConnection *connection;
GVariant * secrets;
GError * error = NULL;
gboolean success;
gs_unref_object NMConnection *connection = NULL;
GVariant * secrets;
GError * error = NULL;
gboolean success;
/* Test that updating secrets with an empty connection hash returns success */
connection = wifi_connection_new();
secrets = g_variant_new_array(G_VARIANT_TYPE("{sa{sv}}"), NULL, 0);
success = nm_connection_update_secrets(connection, NULL, secrets, &error);
g_assert_no_error(error);
g_assert(success == TRUE);
nmtst_assert_success(success, error);
g_variant_unref(secrets);
g_object_unref(connection);
g_clear_object(&connection);
connection = wifi_connection_new();
secrets = nm_g_variant_singleton_aLsaLsvII();
success = nm_connection_update_secrets(connection, NULL, secrets, &error);
nmtst_assert_success(success, error);
}
static void

59
src/libnm-glib-aux/nm-shared-utils.c
View file

@ -516,16 +516,15 @@ nm_utils_gbytes_equal_mem(GBytes *bytes, gconstpointer mem_data, gsize mem_len)
GVariant *
nm_utils_gbytes_to_variant_ay(GBytes *bytes)
{
const guint8 *p;
gsize l;
const guint8 *p = NULL;
gsize l = 0;
if (!bytes) {
/* for convenience, accept NULL to return an empty variant */
return g_variant_new_array(G_VARIANT_TYPE_BYTE, NULL, 0);
}
} else
p = g_bytes_get_data(bytes, &l);
p = g_bytes_get_data(bytes, &l);
return g_variant_new_fixed_array(G_VARIANT_TYPE_BYTE, p, l, 1);
return nm_g_variant_new_ay(p, l);
}
/*****************************************************************************/
@ -556,6 +555,54 @@ nm_g_variant_singleton_u_0(void)
return _variant_singleton_get(g_variant_new_uint32(0));
}
static GVariant *
_variant_singleton_get_array_init(GVariant **p_singleton, const char *variant_type)
{
GVariant *v;
v = g_variant_new_array(G_VARIANT_TYPE(variant_type), NULL, 0);
g_variant_ref_sink(v);
if (G_LIKELY(g_atomic_pointer_compare_and_exchange(p_singleton, NULL, v)))
return v;
g_variant_unref(v);
return g_atomic_pointer_get(p_singleton);
}
#define _variant_singleton_get_array(variant_type) \
({ \
static GVariant *_singleton = NULL; \
GVariant * _v; \
\
_v = g_atomic_pointer_get(&_singleton); \
if (G_UNLIKELY(!_v)) { \
_v = _variant_singleton_get_array_init(&_singleton, "" variant_type ""); \
nm_assert(_v); \
} \
nm_assert(g_variant_is_of_type(_v, G_VARIANT_TYPE("a" variant_type ""))); \
_v; \
})
GVariant *
nm_g_variant_singleton_aLsvI(void)
{
return _variant_singleton_get_array("{sv}");
}
GVariant *
nm_g_variant_singleton_aLsaLsvII(void)
{
return _variant_singleton_get_array("{sa{sv}}");
}
GVariant *
nm_g_variant_singleton_aaLsvI(void)
{
return _variant_singleton_get_array("a{sv}");
}
/*****************************************************************************/
GHashTable *

25
src/libnm-glib-aux/nm-shared-utils.h
View file

@ -1442,6 +1442,9 @@ char *nm_utils_str_utf8safe_unescape_cp(const char *str, NMUtilsStrUtf8SafeFlags
char *nm_utils_str_utf8safe_escape_take(char *str, NMUtilsStrUtf8SafeFlags flags);
GVariant *nm_g_variant_singleton_u_0(void);
GVariant *nm_g_variant_singleton_aLsvI(void);
GVariant *nm_g_variant_singleton_aLsaLsvII(void);
GVariant *nm_g_variant_singleton_aaLsvI(void);
static inline void
nm_g_variant_unref_floating(GVariant *var)
@ -1479,13 +1482,22 @@ nm_g_variant_is_of_type(GVariant *value, const GVariantType *type)
return value && g_variant_is_of_type(value, type);
}
static inline GVariant *
nm_g_variant_new_ay(const guint8 *data, gsize len)
{
return g_variant_new_fixed_array(G_VARIANT_TYPE_BYTE, data, len, 1);
}
static inline GVariant *
nm_g_variant_new_au(const guint32 *data, gsize len)
{
return g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32, data, len, sizeof(guint32));
}
static inline GVariant *
nm_g_variant_new_ay_inaddr(int addr_family, gconstpointer addr)
{
return g_variant_new_fixed_array(G_VARIANT_TYPE_BYTE,
addr ?: &nm_ip_addr_zero,
nm_utils_addr_family_to_size(addr_family),
1);
return nm_g_variant_new_ay(addr ?: &nm_ip_addr_zero, nm_utils_addr_family_to_size(addr_family));
}
static inline GVariant *
@ -1512,10 +1524,7 @@ nm_g_variant_builder_add_sv_bytearray(GVariantBuilder *builder,
const guint8 * arr,
gsize len)
{
g_variant_builder_add(builder,
"{sv}",
key,
g_variant_new_fixed_array(G_VARIANT_TYPE_BYTE, arr, len, 1));
g_variant_builder_add(builder, "{sv}", key, nm_g_variant_new_ay(arr, len));
}
static inline void

14
src/nmcli/devices.c
View file

@ -3774,10 +3774,9 @@ do_device_wifi_connect(const NMCCommand *cmd, NmCli *nmc, int argc, const char *
g_variant_builder_init(&builder, G_VARIANT_TYPE_VARDICT);
g_variant_builder_init(&array_builder, G_VARIANT_TYPE("aay"));
g_variant_builder_add(
&array_builder,
"@ay",
g_variant_new_fixed_array(G_VARIANT_TYPE_BYTE, param_user, strlen(param_user), 1));
g_variant_builder_add(&array_builder,
"@ay",
nm_g_variant_new_ay((const guint8 *) param_user, strlen(param_user)));
g_variant_builder_add(&builder, "{sv}", "ssids", g_variant_builder_end(&array_builder));
options = g_variant_builder_end(&builder);
@ -4538,10 +4537,9 @@ do_device_wifi_rescan(const NMCCommand *cmd, NmCli *nmc, int argc, const char *c
for (i = 0; i < ssids->len; i++) {
const char *ssid = g_ptr_array_index(ssids, i);
g_variant_builder_add(
&array_builder,
"@ay",
g_variant_new_fixed_array(G_VARIANT_TYPE_BYTE, ssid, strlen(ssid), 1));
g_variant_builder_add(&array_builder,
"@ay",
nm_g_variant_new_ay((const guint8 *) ssid, strlen(ssid)));
}
g_variant_builder_add(&builder, "{sv}", "ssids", g_variant_builder_end(&array_builder));