mirror of
https://gitlab.freedesktop.org/NetworkManager/NetworkManager.git
synced 2025-12-26 13:30:08 +01:00
d964decbbd
Keyfile support was initially added under GPL-2.0+ license as part of
core. It was moved to "libnm-core" in commit 59eb5312a5 ('keyfile: merge
branch 'th/libnm-keyfile-bgo744699'').
"libnm-core" is statically linked with by core and "libnm". In
the former case under terms of GPL-2.0+ (good) and in the latter case
under terms of LGPL-2.1+ (bad).
In fact, to this day, "libnm" doesn't actually use the code. The linker
will probably remove all the GPL-2.0+ symbols when compiled with
gc-sections or LTO. Still, linking them together in the first place
makes "libnm" only available under GPL code (despite the code
not actually being used).
Instead, move the GPL code to a separate static library
"shared/nm-keyfile/libnm-keyfile.la" and only link it to the part
that actually uses the code (and which is GPL licensed too).
This fixes the license violation.
Eventually, it would be very useful to be able to expose keyfile
handling via "libnm". However that is not straight forward due to the
licensing conflict.
https://gitlab.freedesktop.org/NetworkManager/NetworkManager/merge_requests/381
324 lines
9.5 KiB
C
324 lines
9.5 KiB
C
// SPDX-License-Identifier: LGPL-2.1+
|
|
/*
|
|
* Copyright (C) 2014 - 2016 Red Hat, Inc.
|
|
*/
|
|
|
|
#ifndef __NM_TEST_UTILS_CORE_H__
|
|
#define __NM_TEST_UTILS_CORE_H__
|
|
|
|
#include "NetworkManagerUtils.h"
|
|
#include "nm-keyfile/nm-keyfile-internal.h"
|
|
|
|
#define _NMTST_INSIDE_CORE 1
|
|
|
|
#include "nm-utils/nm-test-utils.h"
|
|
|
|
/*****************************************************************************/
|
|
|
|
#define NMTST_EXPECT_NM(level, msg) NMTST_EXPECT ("NetworkManager", level, msg)
|
|
|
|
#define NMTST_EXPECT_NM_ERROR(msg) NMTST_EXPECT_NM (G_LOG_LEVEL_MESSAGE, "*<error> [*] "msg)
|
|
#define NMTST_EXPECT_NM_WARN(msg) NMTST_EXPECT_NM (G_LOG_LEVEL_MESSAGE, "*<warn> [*] "msg)
|
|
#define NMTST_EXPECT_NM_INFO(msg) NMTST_EXPECT_NM (G_LOG_LEVEL_INFO, "*<info> [*] "msg)
|
|
#define NMTST_EXPECT_NM_DEBUG(msg) NMTST_EXPECT_NM (G_LOG_LEVEL_DEBUG, "*<debug> [*] "msg)
|
|
#define NMTST_EXPECT_NM_TRACE(msg) NMTST_EXPECT_NM (G_LOG_LEVEL_DEBUG, "*<trace> [*] "msg)
|
|
|
|
static inline void
|
|
nmtst_init_with_logging (int *argc, char ***argv, const char *log_level, const char *log_domains)
|
|
{
|
|
__nmtst_init (argc, argv, FALSE, log_level, log_domains, NULL);
|
|
}
|
|
static inline void
|
|
nmtst_init_assert_logging (int *argc, char ***argv, const char *log_level, const char *log_domains)
|
|
{
|
|
gboolean set_logging;
|
|
|
|
__nmtst_init (argc, argv, TRUE, NULL, NULL, &set_logging);
|
|
|
|
if (!set_logging) {
|
|
gboolean success;
|
|
|
|
success = nm_logging_setup (log_level, log_domains, NULL, NULL);
|
|
g_assert (success);
|
|
}
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
#ifdef __NETWORKMANAGER_PLATFORM_H__
|
|
|
|
static inline NMPlatformIP4Address *
|
|
nmtst_platform_ip4_address (const char *address, const char *peer_address, guint plen)
|
|
{
|
|
static NMPlatformIP4Address addr;
|
|
|
|
g_assert (plen <= 32);
|
|
|
|
memset (&addr, 0, sizeof (addr));
|
|
addr.address = nmtst_inet4_from_string (address);
|
|
if (peer_address)
|
|
addr.peer_address = nmtst_inet4_from_string (peer_address);
|
|
else
|
|
addr.peer_address = addr.address;
|
|
addr.plen = plen;
|
|
|
|
return &addr;
|
|
}
|
|
|
|
static inline NMPlatformIP4Address *
|
|
nmtst_platform_ip4_address_full (const char *address, const char *peer_address, guint plen,
|
|
int ifindex, NMIPConfigSource source, guint32 timestamp,
|
|
guint32 lifetime, guint32 preferred, guint32 flags,
|
|
const char *label)
|
|
{
|
|
NMPlatformIP4Address *addr = nmtst_platform_ip4_address (address, peer_address, plen);
|
|
|
|
G_STATIC_ASSERT (NMP_IFNAMSIZ == sizeof (addr->label));
|
|
g_assert (!label || strlen (label) < NMP_IFNAMSIZ);
|
|
|
|
addr->ifindex = ifindex;
|
|
addr->addr_source = source;
|
|
addr->timestamp = timestamp;
|
|
addr->lifetime = lifetime;
|
|
addr->preferred = preferred;
|
|
addr->n_ifa_flags = flags;
|
|
if (label)
|
|
g_strlcpy (addr->label, label, sizeof (addr->label));
|
|
|
|
return addr;
|
|
}
|
|
|
|
static inline NMPlatformIP6Address *
|
|
nmtst_platform_ip6_address (const char *address, const char *peer_address, guint plen)
|
|
{
|
|
static NMPlatformIP6Address addr;
|
|
|
|
g_assert (plen <= 128);
|
|
|
|
memset (&addr, 0, sizeof (addr));
|
|
addr.address = *nmtst_inet6_from_string (address);
|
|
addr.peer_address = *nmtst_inet6_from_string (peer_address);
|
|
addr.plen = plen;
|
|
|
|
return &addr;
|
|
}
|
|
|
|
static inline NMPlatformIP6Address *
|
|
nmtst_platform_ip6_address_full (const char *address, const char *peer_address, guint plen,
|
|
int ifindex, NMIPConfigSource source, guint32 timestamp,
|
|
guint32 lifetime, guint32 preferred, guint32 flags)
|
|
{
|
|
NMPlatformIP6Address *addr = nmtst_platform_ip6_address (address, peer_address, plen);
|
|
|
|
addr->ifindex = ifindex;
|
|
addr->addr_source = source;
|
|
addr->timestamp = timestamp;
|
|
addr->lifetime = lifetime;
|
|
addr->preferred = preferred;
|
|
addr->n_ifa_flags = flags;
|
|
|
|
return addr;
|
|
}
|
|
|
|
static inline NMPlatformIP4Route *
|
|
nmtst_platform_ip4_route (const char *network, guint plen, const char *gateway)
|
|
{
|
|
static NMPlatformIP4Route route;
|
|
|
|
g_assert (plen <= 32);
|
|
|
|
memset (&route, 0, sizeof (route));
|
|
route.network = nmtst_inet4_from_string (network);
|
|
route.plen = plen;
|
|
route.gateway = nmtst_inet4_from_string (gateway);
|
|
|
|
return &route;
|
|
}
|
|
|
|
static inline NMPlatformIP4Route *
|
|
nmtst_platform_ip4_route_full (const char *network, guint plen, const char *gateway,
|
|
int ifindex, NMIPConfigSource source,
|
|
guint metric, guint mss,
|
|
guint8 scope,
|
|
const char *pref_src)
|
|
{
|
|
NMPlatformIP4Route *route = nmtst_platform_ip4_route (network, plen, gateway);
|
|
|
|
route->ifindex = ifindex;
|
|
route->rt_source = source;
|
|
route->metric = metric;
|
|
route->mss = mss;
|
|
route->scope_inv = nm_platform_route_scope_inv (scope);
|
|
route->pref_src = nmtst_inet4_from_string (pref_src);
|
|
|
|
return route;
|
|
}
|
|
|
|
static inline NMPlatformIP6Route *
|
|
nmtst_platform_ip6_route (const char *network, guint plen, const char *gateway, const char *pref_src)
|
|
{
|
|
static NMPlatformIP6Route route;
|
|
|
|
nm_assert (plen <= 128);
|
|
|
|
memset (&route, 0, sizeof (route));
|
|
route.network = *nmtst_inet6_from_string (network);
|
|
route.plen = plen;
|
|
route.gateway = *nmtst_inet6_from_string (gateway);
|
|
route.pref_src = *nmtst_inet6_from_string (pref_src);
|
|
|
|
return &route;
|
|
}
|
|
|
|
static inline NMPlatformIP6Route *
|
|
nmtst_platform_ip6_route_full (const char *network, guint plen, const char *gateway,
|
|
int ifindex, NMIPConfigSource source,
|
|
guint metric, guint mss)
|
|
{
|
|
NMPlatformIP6Route *route = nmtst_platform_ip6_route (network, plen, gateway, NULL);
|
|
|
|
route->ifindex = ifindex;
|
|
route->rt_source = source;
|
|
route->metric = metric;
|
|
route->mss = mss;
|
|
|
|
return route;
|
|
}
|
|
|
|
static inline int
|
|
_nmtst_platform_ip4_routes_equal_sort (gconstpointer a, gconstpointer b, gpointer user_data)
|
|
{
|
|
return nm_platform_ip4_route_cmp_full ((const NMPlatformIP4Route *) a, (const NMPlatformIP4Route *) b);
|
|
}
|
|
|
|
static inline void
|
|
nmtst_platform_ip4_routes_equal (const NMPlatformIP4Route *a, const NMPlatformIP4Route *b, gsize len, gboolean ignore_order)
|
|
{
|
|
gsize i;
|
|
gs_free const NMPlatformIP4Route *c_a = NULL, *c_b = NULL;
|
|
|
|
g_assert (a);
|
|
g_assert (b);
|
|
|
|
if (ignore_order) {
|
|
a = c_a = nm_memdup (a, sizeof (NMPlatformIP4Route) * len);
|
|
b = c_b = nm_memdup (b, sizeof (NMPlatformIP4Route) * len);
|
|
g_qsort_with_data (c_a, len, sizeof (NMPlatformIP4Route), _nmtst_platform_ip4_routes_equal_sort, NULL);
|
|
g_qsort_with_data (c_b, len, sizeof (NMPlatformIP4Route), _nmtst_platform_ip4_routes_equal_sort, NULL);
|
|
}
|
|
|
|
for (i = 0; i < len; i++) {
|
|
if (nm_platform_ip4_route_cmp_full (&a[i], &b[i]) != 0) {
|
|
char buf[sizeof (_nm_utils_to_string_buffer)];
|
|
|
|
g_error ("Error comparing IPv4 route[%lu]: %s vs %s", (unsigned long) i,
|
|
nm_platform_ip4_route_to_string (&a[i], NULL, 0),
|
|
nm_platform_ip4_route_to_string (&b[i], buf, sizeof (buf)));
|
|
g_assert_not_reached ();
|
|
}
|
|
}
|
|
}
|
|
|
|
#ifdef __NMP_OBJECT_H__
|
|
|
|
static inline void
|
|
nmtst_platform_ip4_routes_equal_aptr (const NMPObject *const*a, const NMPlatformIP4Route *b, gsize len, gboolean ignore_order)
|
|
{
|
|
gsize i;
|
|
gs_free NMPlatformIP4Route *c_a = NULL;
|
|
|
|
g_assert (len > 0);
|
|
g_assert (a);
|
|
|
|
c_a = g_new (NMPlatformIP4Route, len);
|
|
for (i = 0; i < len; i++)
|
|
c_a[i] = *NMP_OBJECT_CAST_IP4_ROUTE (a[i]);
|
|
nmtst_platform_ip4_routes_equal (c_a, b, len, ignore_order);
|
|
}
|
|
|
|
#endif
|
|
|
|
static inline int
|
|
_nmtst_platform_ip6_routes_equal_sort (gconstpointer a, gconstpointer b, gpointer user_data)
|
|
{
|
|
return nm_platform_ip6_route_cmp_full ((const NMPlatformIP6Route *) a, (const NMPlatformIP6Route *) b);
|
|
}
|
|
|
|
static inline void
|
|
nmtst_platform_ip6_routes_equal (const NMPlatformIP6Route *a, const NMPlatformIP6Route *b, gsize len, gboolean ignore_order)
|
|
{
|
|
gsize i;
|
|
gs_free const NMPlatformIP6Route *c_a = NULL, *c_b = NULL;
|
|
|
|
g_assert (a);
|
|
g_assert (b);
|
|
|
|
if (ignore_order) {
|
|
a = c_a = nm_memdup (a, sizeof (NMPlatformIP6Route) * len);
|
|
b = c_b = nm_memdup (b, sizeof (NMPlatformIP6Route) * len);
|
|
g_qsort_with_data (c_a, len, sizeof (NMPlatformIP6Route), _nmtst_platform_ip6_routes_equal_sort, NULL);
|
|
g_qsort_with_data (c_b, len, sizeof (NMPlatformIP6Route), _nmtst_platform_ip6_routes_equal_sort, NULL);
|
|
}
|
|
|
|
for (i = 0; i < len; i++) {
|
|
if (nm_platform_ip6_route_cmp_full (&a[i], &b[i]) != 0) {
|
|
char buf[sizeof (_nm_utils_to_string_buffer)];
|
|
|
|
g_error ("Error comparing IPv6 route[%lu]: %s vs %s", (unsigned long) i,
|
|
nm_platform_ip6_route_to_string (&a[i], NULL, 0),
|
|
nm_platform_ip6_route_to_string (&b[i], buf, sizeof (buf)));
|
|
g_assert_not_reached ();
|
|
}
|
|
}
|
|
}
|
|
|
|
#ifdef __NMP_OBJECT_H__
|
|
|
|
static inline void
|
|
nmtst_platform_ip6_routes_equal_aptr (const NMPObject *const*a, const NMPlatformIP6Route *b, gsize len, gboolean ignore_order)
|
|
{
|
|
gsize i;
|
|
gs_free NMPlatformIP6Route *c_a = NULL;
|
|
|
|
g_assert (len > 0);
|
|
g_assert (a);
|
|
|
|
c_a = g_new (NMPlatformIP6Route, len);
|
|
for (i = 0; i < len; i++)
|
|
c_a[i] = *NMP_OBJECT_CAST_IP6_ROUTE (a[i]);
|
|
nmtst_platform_ip6_routes_equal (c_a, b, len, ignore_order);
|
|
}
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
#ifdef __NETWORKMANAGER_IP4_CONFIG_H__
|
|
|
|
#include "nm-glib-aux/nm-dedup-multi.h"
|
|
|
|
static inline NMIP4Config *
|
|
nmtst_ip4_config_new (int ifindex)
|
|
{
|
|
nm_auto_unref_dedup_multi_index NMDedupMultiIndex *multi_idx = nm_dedup_multi_index_new ();
|
|
|
|
return nm_ip4_config_new (multi_idx, ifindex);
|
|
}
|
|
|
|
#endif
|
|
|
|
#ifdef __NETWORKMANAGER_IP6_CONFIG_H__
|
|
|
|
#include "nm-glib-aux/nm-dedup-multi.h"
|
|
|
|
static inline NMIP6Config *
|
|
nmtst_ip6_config_new (int ifindex)
|
|
{
|
|
nm_auto_unref_dedup_multi_index NMDedupMultiIndex *multi_idx = nm_dedup_multi_index_new ();
|
|
|
|
return nm_ip6_config_new (multi_idx, ifindex);
|
|
}
|
|
|
|
#endif
|
|
|
|
#endif /* __NM_TEST_UTILS_CORE_H__ */
|