/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
* Copyright (C) 2016 - 2017 Red Hat, Inc.
*/
#include <stdlib.h>
#include <unistd.h>
#include <syslog.h>
#include <arpa/inet.h>
#include <linux/if.h>
#include <linux/if_link.h>
#include <linux/ip6_tunnel.h>
#include "libnm-platform/nm-platform.h"
#include "libnm-platform/nmp-object.h"
#include "platform/nm-fake-platform.h"
#include "libnm-platform/nm-linux-platform.h"
#include "nm-test-utils-core.h"
#define DEVICE_NAME "nm-test-device"
/*****************************************************************************/
#define nmtstp_normalize_jiffies_time(requested_value, kernel_value) \
({ \
typeof(kernel_value) _kernel_value = (kernel_value); \
typeof(_kernel_value) _requested_value = (requested_value); \
\
/* kernel stores some values (like bridge's forward_delay) in jiffies. When converting
* back and forth (clock_t_to_jiffies()/jiffies_to_clock_t()), the value reported back
* to user space may have rounding errors (of +/- 1), depending on CONFIG_HZ setting.
*
* Normalize the requested_value to the kernel_value, if it look as if a rounding
* error happens. If the difference is larger than +/- 1, no normalization happens! */ \
\
((_requested_value >= (NM_MAX(_kernel_value, 1) - 1)) \
&& (_requested_value <= (NM_MIN(_kernel_value, ~((typeof(_kernel_value)) 0) - 1) + 1))) \
? _kernel_value \
: _requested_value; \
})
#define _NMLOG_PREFIX_NAME "platform-test"
#define _NMLOG_DOMAIN LOGD_PLATFORM
#define _NMLOG(level, ...) _LOG(level, _NMLOG_DOMAIN, __VA_ARGS__)
#define _LOG(level, domain, ...) \
G_STMT_START \
{ \
const NMLogLevel __level = (level); \
const NMLogDomain __domain = (domain); \
\
if (nm_logging_enabled(__level, __domain)) { \
gint64 _ts = nm_utils_get_monotonic_timestamp_nsec(); \
\
_nm_log(__level, \
__domain, \
0, \
NULL, \
NULL, \
"%s[%ld.%09ld]: " _NM_UTILS_MACRO_FIRST(__VA_ARGS__), \
_NMLOG_PREFIX_NAME, \
(long) (_ts / NM_UTILS_NSEC_PER_SEC), \
(long) (_ts % NM_UTILS_NSEC_PER_SEC) _NM_UTILS_MACRO_REST(__VA_ARGS__)); \
} \
} \
G_STMT_END
/*****************************************************************************/
gboolean nmtstp_is_root_test(void);
gboolean nmtstp_is_sysfs_writable(void);
/*****************************************************************************/
typedef struct _NMTstpNamespaceHandle NMTstpNamespaceHandle;
NMTstpNamespaceHandle *nmtstp_namespace_create(int flags, GError **error);
void nmtstp_namespace_handle_release(NMTstpNamespaceHandle *handle);
pid_t nmtstp_namespace_handle_get_pid(NMTstpNamespaceHandle *handle);
int nmtstp_namespace_get_fd_for_process(pid_t pid, const char *ns_name);
/*****************************************************************************/
void nmtstp_netns_select_random(NMPlatform **platforms, gsize n_platforms, NMPNetns **netns);
/*****************************************************************************/
typedef struct {
gulong handler_id;
const char * name;
NMPlatformSignalChangeType change_type;
int received_count;
GMainLoop * loop;
int ifindex;
const char * ifname;
} SignalData;
SignalData *add_signal_full(const char * name,
NMPlatformSignalChangeType change_type,
GCallback callback,
int ifindex,
const char * ifname);
#define add_signal(name, change_type, callback) \
add_signal_full(name, change_type, (GCallback) callback, 0, NULL)
#define add_signal_ifindex(name, change_type, callback, ifindex) \
add_signal_full(name, change_type, (GCallback) callback, ifindex, NULL)
#define add_signal_ifname(name, change_type, callback, ifname) \
add_signal_full(name, change_type, (GCallback) callback, 0, ifname)
void _accept_signal(const char *file, int line, const char *func, SignalData *data);
void
_accept_signals(const char *file, int line, const char *func, SignalData *data, int min, int max);
void _wait_signal(const char *file, int line, const char *func, SignalData *data);
void _accept_or_wait_signal(const char *file, int line, const char *func, SignalData *data);
void _ensure_no_signal(const char *file, int line, const char *func, SignalData *data);
void _free_signal(const char *file, int line, const char *func, SignalData *data);
#define accept_signal(data) _accept_signal(__FILE__, __LINE__, G_STRFUNC, data)
#define accept_signals(data, min, max) \
_accept_signals(__FILE__, __LINE__, G_STRFUNC, data, min, max)
#define wait_signal(data) _wait_signal(__FILE__, __LINE__, G_STRFUNC, data)
#define accept_or_wait_signal(data) _accept_or_wait_signal(__FILE__, __LINE__, G_STRFUNC, data)
#define ensure_no_signal(data) _ensure_no_signal(__FILE__, __LINE__, G_STRFUNC, data)
#define free_signal(data) _free_signal(__FILE__, __LINE__, G_STRFUNC, data)
void link_callback(NMPlatform * platform,
int obj_type_i,
int ifindex,
NMPlatformLink *received,
int change_type_i,
SignalData * data);
/*****************************************************************************/
int nmtstp_run_command(const char *format, ...) _nm_printf(1, 2);
#define nmtstp_run_command_check(...) \
do { \
g_assert_cmpint(nmtstp_run_command(__VA_ARGS__), ==, 0); \
} while (0)
/*****************************************************************************/
guint nmtstp_wait_for_signal(NMPlatform *platform, gint64 timeout_msec);
guint nmtstp_wait_for_signal_until(NMPlatform *platform, gint64 until_ms);
const NMPlatformLink *nmtstp_wait_for_link(NMPlatform *platform,
const char *ifname,
NMLinkType expected_link_type,
gint64 timeout_msec);
const NMPlatformLink *nmtstp_wait_for_link_until(NMPlatform *platform,
const char *ifname,
NMLinkType expected_link_type,
gint64 until_ms);
#define nmtstp_assert_wait_for_signal(platform, timeout_msec) \
G_STMT_START \
{ \
if (nmtstp_wait_for_signal(platform, timeout_msec) == 0) \
g_assert_not_reached(); \
} \
G_STMT_END
#define nmtstp_assert_wait_for_signal_until(platform, until_ms) \
G_STMT_START \
{ \
if (nmtstp_wait_for_signal_until(platform, until_ms) == 0) \
g_assert_not_reached(); \
} \
G_STMT_END
#define nmtstp_assert_wait_for_link(platform, ifname, expected_link_type, timeout_msec) \
nmtst_assert_nonnull(nmtstp_wait_for_link(platform, ifname, expected_link_type, timeout_msec))
#define nmtstp_assert_wait_for_link_until(platform, ifname, expected_link_type, until_ms) \
nmtst_assert_nonnull(nmtstp_wait_for_link_until(platform, ifname, expected_link_type, until_ms))
/*****************************************************************************/
int nmtstp_run_command_check_external_global(void);
gboolean nmtstp_run_command_check_external(int external_command);
/*****************************************************************************/
const NMPlatformIP4Route *_nmtstp_assert_ip4_route_exists(const char *file,
guint line,
const char *func,
NMPlatform *platform,
int c_exists,
const char *ifname,
guint32 network,
int plen,
guint32 metric,
guint8 tos);
#define nmtstp_assert_ip4_route_exists(platform, c_exists, ifname, network, plen, metric, tos) \
_nmtstp_assert_ip4_route_exists(__FILE__, \
__LINE__, \
G_STRFUNC, \
platform, \
c_exists, \
ifname, \
network, \
plen, \
metric, \
tos)
const NMPlatformIP4Route *nmtstp_ip4_route_get(NMPlatform *platform,
int ifindex,
guint32 network,
int plen,
guint32 metric,
guint8 tos);
const NMPlatformIP6Route *_nmtstp_assert_ip6_route_exists(const char * file,
guint line,
const char * func,
NMPlatform * platform,
int c_exists,
const char * ifname,
const struct in6_addr *network,
guint plen,
guint32 metric,
const struct in6_addr *src,
guint8 src_plen);
#define nmtstp_assert_ip6_route_exists(platform, \
c_exists, \
ifname, \
network, \
plen, \
metric, \
src, \
src_plen) \
_nmtstp_assert_ip6_route_exists(__FILE__, \
__LINE__, \
G_STRFUNC, \
platform, \
c_exists, \
ifname, \
network, \
plen, \
metric, \
src, \
src_plen)
const NMPlatformIP6Route *nmtstp_ip6_route_get(NMPlatform * platform,
int ifindex,
const struct in6_addr *network,
guint plen,
guint32 metric,
const struct in6_addr *src,
guint8 src_plen);
/*****************************************************************************/
gboolean nmtstp_ip_address_check_lifetime(const NMPlatformIPAddress *addr,
gint64 now,
guint32 expected_lifetime,
guint32 expected_preferred);
void nmtstp_ip_address_assert_lifetime(const NMPlatformIPAddress *addr,
gint64 now,
guint32 expected_lifetime,
guint32 expected_preferred);
void nmtstp_ip4_address_add(NMPlatform *platform,
gboolean external_command,
int ifindex,
in_addr_t address,
int plen,
in_addr_t peer_address,
guint32 lifetime,
guint32 preferred,
guint32 flags,
const char *label);
void nmtstp_ip6_address_add(NMPlatform * platform,
gboolean external_command,
int ifindex,
struct in6_addr address,
int plen,
struct in6_addr peer_address,
guint32 lifetime,
guint32 preferred,
guint32 flags);
void nmtstp_ip4_address_del(NMPlatform *platform,
gboolean external_command,
int ifindex,
in_addr_t address,
int plen,
in_addr_t peer_address);
void nmtstp_ip6_address_del(NMPlatform * platform,
gboolean external_command,
int ifindex,
struct in6_addr address,
int plen);
void nmtstp_ip4_route_add(NMPlatform * platform,
int ifindex,
NMIPConfigSource source,
in_addr_t network,
guint8 plen,
in_addr_t gateway,
in_addr_t pref_src,
guint32 metric,
guint32 mss);
void nmtstp_ip6_route_add(NMPlatform * platform,
int ifindex,
NMIPConfigSource source,
struct in6_addr network,
guint8 plen,
struct in6_addr gateway,
struct in6_addr pref_src,
guint32 metric,
guint32 mss);
static inline GPtrArray *
nmtstp_ip4_route_get_all(NMPlatform *platform, int ifindex)
{
return nm_platform_lookup_object_clone(
platform,
NMP_OBJECT_TYPE_IP4_ROUTE,
ifindex,
nm_platform_lookup_predicate_routes_main_skip_rtprot_kernel,
NULL);
}
static inline GPtrArray *
nmtstp_ip6_route_get_all(NMPlatform *platform, int ifindex)
{
return nm_platform_lookup_object_clone(
platform,
NMP_OBJECT_TYPE_IP6_ROUTE,
ifindex,
nm_platform_lookup_predicate_routes_main_skip_rtprot_kernel,
NULL);
}
/*****************************************************************************/
GArray *nmtstp_platform_ip4_address_get_all(NMPlatform *self, int ifindex);
GArray *nmtstp_platform_ip6_address_get_all(NMPlatform *self, int ifindex);
/*****************************************************************************/
const NMPlatformIPAddress *
nmtstp_platform_ip_address_find(NMPlatform *self, int ifindex, int addr_family, gconstpointer addr);
static inline const NMPlatformIP4Address *
nmtstp_platform_ip4_address_find(NMPlatform *self, int ifindex, in_addr_t addr)
{
return (const NMPlatformIP4Address *)
nmtstp_platform_ip_address_find(self, ifindex, AF_INET, &addr);
}
static inline const NMPlatformIP6Address *
nmtstp_platform_ip6_address_find(NMPlatform *self, int ifindex, const struct in6_addr *addr)
{
return (const NMPlatformIP6Address *)
nmtstp_platform_ip_address_find(self, ifindex, AF_INET6, addr);
}
void _nmtstp_platform_ip_addresses_assert(const char * filename,
int lineno,
NMPlatform * self,
int ifindex,
gboolean force_exact_4,
gboolean force_exact_6,
gboolean ignore_ll6,
guint addrs_len,
const char *const *addrs);
#define nmtstp_platform_ip_addresses_assert(self, \
ifindex, \
force_exact_4, \
force_exact_6, \
ignore_ll6, \
...) \
_nmtstp_platform_ip_addresses_assert(__FILE__, \
__LINE__, \
(self), \
(ifindex), \
(force_exact_4), \
(force_exact_6), \
(ignore_ll6), \
NM_NARG(__VA_ARGS__), \
((const char *const[]){"dummy", ##__VA_ARGS__, NULL}) \
+ 1)
/*****************************************************************************/
static inline gboolean
_nmtstp_platform_routing_rules_get_all_predicate(const NMPObject *obj, gpointer user_data)
{
int addr_family = GPOINTER_TO_INT(user_data);
g_assert(NMP_OBJECT_GET_TYPE(obj) == NMP_OBJECT_TYPE_ROUTING_RULE);
return addr_family == AF_UNSPEC
|| NMP_OBJECT_CAST_ROUTING_RULE(obj)->addr_family == addr_family;
}
static inline GPtrArray *
nmtstp_platform_routing_rules_get_all(NMPlatform *platform, int addr_family)
{
NMPLookup lookup;
g_assert(NM_IS_PLATFORM(platform));
g_assert(NM_IN_SET(addr_family, AF_UNSPEC, AF_INET, AF_INET6));
nmp_lookup_init_obj_type(&lookup, NMP_OBJECT_TYPE_ROUTING_RULE);
return nm_platform_lookup_clone(platform,
&lookup,
_nmtstp_platform_routing_rules_get_all_predicate,
GINT_TO_POINTER(addr_family));
}
static inline guint
nmtstp_platform_routing_rules_get_count(NMPlatform *platform, int addr_family)
{
const NMDedupMultiHeadEntry *head_entry;
NMDedupMultiIter iter;
const NMPObject * obj;
NMPLookup lookup;
guint n;
g_assert(NM_IS_PLATFORM(platform));
g_assert(NM_IN_SET(addr_family, AF_UNSPEC, AF_INET, AF_INET6));
nmp_lookup_init_obj_type(&lookup, NMP_OBJECT_TYPE_ROUTING_RULE);
head_entry = nm_platform_lookup(platform, &lookup);
n = 0;
nmp_cache_iter_for_each (&iter, head_entry, &obj) {
if (_nmtstp_platform_routing_rules_get_all_predicate(obj, GINT_TO_POINTER(addr_family)))
n++;
}
return n;
}
gboolean nmtstp_platform_ip4_route_delete(NMPlatform *platform,
int ifindex,
in_addr_t network,
guint8 plen,
guint32 metric);
gboolean nmtstp_platform_ip6_route_delete(NMPlatform * platform,
int ifindex,
struct in6_addr network,
guint8 plen,
guint32 metric);
const NMPlatformLink *
nmtstp_link_get_typed(NMPlatform *platform, int ifindex, const char *name, NMLinkType link_type);
const NMPlatformLink *nmtstp_link_get(NMPlatform *platform, int ifindex, const char *name);
gboolean nmtstp_kernel_support_get(NMPlatformKernelSupportType type);
void
nmtstp_link_set_updown(NMPlatform *platform, gboolean external_command, int ifindex, gboolean up);
const NMPlatformLnkBridge *
nmtstp_link_bridge_normalize_jiffies_time(const NMPlatformLnkBridge *requested,
const NMPlatformLnkBridge *kernel,
NMPlatformLnkBridge * dst);
const NMPlatformLink *nmtstp_link_bridge_add(NMPlatform * platform,
gboolean external_command,
const char * name,
const NMPlatformLnkBridge *lnk);
const NMPlatformLink *nmtstp_link_veth_add(NMPlatform *platform,
gboolean external_command,
const char *name,
const char *peer);
const NMPlatformLink *
nmtstp_link_dummy_add(NMPlatform *platform, gboolean external_command, const char *name);
const NMPlatformLink *nmtstp_link_gre_add(NMPlatform * platform,
gboolean external_command,
const char * name,
const NMPlatformLnkGre *lnk);
const NMPlatformLink *nmtstp_link_ip6tnl_add(NMPlatform * platform,
gboolean external_command,
const char * name,
const NMPlatformLnkIp6Tnl *lnk);
const NMPlatformLink *nmtstp_link_ip6gre_add(NMPlatform * platform,
gboolean external_command,
const char * name,
const NMPlatformLnkIp6Tnl *lnk);
const NMPlatformLink *nmtstp_link_ipip_add(NMPlatform * platform,
gboolean external_command,
const char * name,
const NMPlatformLnkIpIp *lnk);
const NMPlatformLink *nmtstp_link_macvlan_add(NMPlatform * platform,
gboolean external_command,
const char * name,
int parent,
const NMPlatformLnkMacvlan *lnk);
const NMPlatformLink *nmtstp_link_sit_add(NMPlatform * platform,
gboolean external_command,
const char * name,
const NMPlatformLnkSit *lnk);
const NMPlatformLink *nmtstp_link_tun_add(NMPlatform * platform,
gboolean external_command,
const char * name,
const NMPlatformLnkTun *lnk,
int * out_fd);
const NMPlatformLink *nmtstp_link_vrf_add(NMPlatform * platform,
gboolean external_command,
const char * name,
const NMPlatformLnkVrf *lnk,
gboolean * out_not_supported);
const NMPlatformLink *nmtstp_link_vxlan_add(NMPlatform * platform,
gboolean external_command,
const char * name,
const NMPlatformLnkVxlan *lnk);
void nmtstp_link_delete(NMPlatform *platform,
gboolean external_command,
int ifindex,
const char *name,
gboolean require_exist);
/*****************************************************************************/
extern int NMTSTP_ENV1_IFINDEX;
extern int NMTSTP_ENV1_EX;
static inline void
_nmtstp_env1_wrapper_setup(const NmtstTestData *test_data)
{
int * p_ifindex;
gpointer p_ifup;
nmtst_test_data_unpack(test_data, &p_ifindex, NULL, NULL, NULL, &p_ifup);
g_assert(p_ifindex && *p_ifindex == -1);
_LOGT("TEST[%s]: setup", test_data->testpath);
nmtstp_link_delete(NM_PLATFORM_GET, -1, -1, DEVICE_NAME, FALSE);
g_assert(NMTST_NM_ERR_SUCCESS(nm_platform_link_dummy_add(NM_PLATFORM_GET, DEVICE_NAME, NULL)));
*p_ifindex = nm_platform_link_get_ifindex(NM_PLATFORM_GET, DEVICE_NAME);
g_assert_cmpint(*p_ifindex, >, 0);
g_assert_cmpint(NMTSTP_ENV1_IFINDEX, ==, -1);
if (GPOINTER_TO_INT(p_ifup))
g_assert(nm_platform_link_change_flags(NM_PLATFORM_GET, *p_ifindex, IFF_UP, TRUE) >= 0);
nm_platform_process_events(NM_PLATFORM_GET);
NMTSTP_ENV1_IFINDEX = *p_ifindex;
NMTSTP_ENV1_EX = nmtstp_run_command_check_external_global();
}
static inline void
_nmtstp_env1_wrapper_run(gconstpointer user_data)
{
const NmtstTestData *test_data = user_data;
GTestDataFunc test_func_data;
GTestFunc test_func;
gconstpointer d;
nmtst_test_data_unpack(test_data, NULL, &test_func, &test_func_data, &d, NULL);
_LOGT("TEST[%s]: run", test_data->testpath);
if (test_func)
test_func();
else
test_func_data(d);
}
static inline void
_nmtstp_env1_wrapper_teardown(const NmtstTestData *test_data)
{
int *p_ifindex;
nmtst_test_data_unpack(test_data, &p_ifindex, NULL, NULL, NULL, NULL);
g_assert_cmpint(NMTSTP_ENV1_IFINDEX, ==, *p_ifindex);
NMTSTP_ENV1_IFINDEX = -1;
_LOGT("TEST[%s]: teardown", test_data->testpath);
g_assert_cmpint(*p_ifindex, ==, nm_platform_link_get_ifindex(NM_PLATFORM_GET, DEVICE_NAME));
g_assert(nm_platform_link_delete(NM_PLATFORM_GET, *p_ifindex));
nm_platform_process_events(NM_PLATFORM_GET);
_LOGT("TEST[%s]: finished", test_data->testpath);
*p_ifindex = -1;
}
/* add test function, that set's up a particular environment, consisting
* of a dummy device with ifindex NMTSTP_ENV1_IFINDEX. */
#define _nmtstp_env1_add_test_func_full(testpath, test_func, test_data_func, arg, ifup) \
nmtst_add_test_func_full(testpath, \
_nmtstp_env1_wrapper_run, \
_nmtstp_env1_wrapper_setup, \
_nmtstp_env1_wrapper_teardown, \
({ \
static int _ifindex = -1; \
&_ifindex; \
}), \
({ \
GTestFunc _test_func = (test_func); \
_test_func; \
}), \
({ \
GTestDataFunc _test_func = (test_data_func); \
_test_func; \
}), \
(arg), \
({ \
gboolean _ifup = (ifup); \
GINT_TO_POINTER(_ifup); \
}))
#define nmtstp_env1_add_test_func_data(testpath, test_func, arg, ifup) \
_nmtstp_env1_add_test_func_full(testpath, NULL, test_func, arg, ifup)
#define nmtstp_env1_add_test_func(testpath, test_func, ifup) \
_nmtstp_env1_add_test_func_full(testpath, test_func, NULL, NULL, ifup)
/*****************************************************************************/
typedef void (*NMTstpSetupFunc)(void);
extern NMTstpSetupFunc const _nmtstp_setup_platform_func;
void nmtstp_setup_platform(void);
/*****************************************************************************/
typedef struct _NMTstpAcdDefender NMTstpAcdDefender;
NMTstpAcdDefender *
nmtstp_acd_defender_new(int ifindex, in_addr_t ip_addr, const NMEtherAddr *mac_addr);
void nmtstp_acd_defender_destroy(NMTstpAcdDefender *defender);
/*****************************************************************************/
void _nmtstp_init_tests(int *argc, char ***argv);
void _nmtstp_setup_tests(void);