nm-test-utils-core.h 8.69 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- */
/*
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301 USA.
 *
 * Copyright 2014 - 2016 Red Hat, Inc.
 */

#ifndef __NM_TEST_UTILS_CORE_H__
#define __NM_TEST_UTILS_CORE_H__

#include "NetworkManagerUtils.h"
#include "nm-keyfile-internal.h"

#define _NMTST_INSIDE_CORE 1

29
#include "nm-utils/nm-test-utils.h"
30 31 32

/*****************************************************************************/

33
static inline void
34 35 36 37
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);
}
38
static inline void
39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56
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__

57
static inline NMPlatformIP4Address *
58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74
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;
}

75
static inline NMPlatformIP4Address *
76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97
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 (IFNAMSIZ == sizeof (addr->label));
	g_assert (!label || strlen (label) < 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;
}

98
static inline NMPlatformIP6Address *
99 100 101 102 103 104 105 106 107 108 109 110 111 112
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;
}

113
static inline NMPlatformIP6Address *
114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129
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;
}

130
static inline NMPlatformIP4Route *
131 132 133 134 135 136 137 138 139 140 141 142 143 144
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;
}

145
static inline NMPlatformIP4Route *
146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163
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;
}

164
static inline NMPlatformIP6Route *
165
nmtst_platform_ip6_route (const char *network, guint plen, const char *gateway, const char *pref_src)
166 167 168 169 170 171 172 173 174
{
	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);
175
	route.pref_src = *nmtst_inet6_from_string (pref_src);
176 177 178 179

	return &route;
}

180
static inline NMPlatformIP6Route *
181 182 183 184
nmtst_platform_ip6_route_full (const char *network, guint plen, const char *gateway,
                               int ifindex, NMIPConfigSource source,
                               guint metric, guint mss)
{
185
	NMPlatformIP6Route *route = nmtst_platform_ip6_route (network, plen, gateway, NULL);
186 187 188 189 190 191 192 193 194

	route->ifindex = ifindex;
	route->rt_source = source;
	route->metric = metric;
	route->mss = mss;

	return route;
}

195
static inline int
196 197 198 199 200
_nmtst_platform_ip4_routes_equal_sort (gconstpointer a, gconstpointer b, gpointer user_data)
{
	return nm_platform_ip4_route_cmp ((const NMPlatformIP4Route *) a, (const NMPlatformIP4Route *) b);
}

201
static inline void
202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228
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 = g_memdup (a, sizeof (NMPlatformIP4Route) * len);
		b = c_b = g_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 (&a[i], &b[i]) != 0) {
			char buf[sizeof (_nm_utils_to_string_buffer)];

			g_error ("Error comparing IPv4 route[%lu]: %s vs %s", (long unsigned) 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 ();
		}
	}
}

229
static inline int
230 231 232 233 234
_nmtst_platform_ip6_routes_equal_sort (gconstpointer a, gconstpointer b, gpointer user_data)
{
	return nm_platform_ip6_route_cmp ((const NMPlatformIP6Route *) a, (const NMPlatformIP6Route *) b);
}

235
static inline void
236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267
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 = g_memdup (a, sizeof (NMPlatformIP6Route) * len);
		b = c_b = g_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 (&a[i], &b[i]) != 0) {
			char buf[sizeof (_nm_utils_to_string_buffer)];

			g_error ("Error comparing IPv6 route[%lu]: %s vs %s", (long unsigned) 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 ();
		}
	}
}

#endif


#ifdef __NETWORKMANAGER_IP4_CONFIG_H__

268
static inline NMIP4Config *
269 270 271 272 273 274 275 276 277 278 279 280 281 282 283
nmtst_ip4_config_clone (NMIP4Config *config)
{
	NMIP4Config *copy = nm_ip4_config_new (-1);

	g_assert (copy);
	g_assert (config);
	nm_ip4_config_replace (copy, config, NULL);
	return copy;
}

#endif


#ifdef __NETWORKMANAGER_IP6_CONFIG_H__

284
static inline NMIP6Config *
285 286 287 288 289 290 291 292 293 294 295 296 297
nmtst_ip6_config_clone (NMIP6Config *config)
{
	NMIP6Config *copy = nm_ip6_config_new (-1);

	g_assert (copy);
	g_assert (config);
	nm_ip6_config_replace (copy, config, NULL);
	return copy;
}

#endif

#endif /* __NM_TEST_UTILS_CORE_H__ */