Debian Codegraph @

tests/cksuite-route-nexthop.c

raw
1 /* SPDX-License-Identifier: LGPL-2.1-only */
2
3 /*
4 * Tests for include/netlink/route/nexthop.h getters and setters.
5 *
6 * We cover two aspects:
7 * 1. Pure userspace logic – manipulating an allocated rtnl_nexthop object
8 * and validating all getters, including negative/error conditions.
9 * 2. Kernel round-trips – create real routes with nexthops in a private
10 * network namespace, query them back and verify attributes round-trip.
11 */
12
13 #include "nl-default.h"
14
15 #include <linux/rtnetlink.h>
16 #include <linux/if.h>
17
18 #include <netlink/addr.h>
19 #include <netlink/route/addr.h>
20 #include <netlink/route/link.h>
21 #include <netlink/route/route.h>
22 #include <netlink/route/nexthop.h>
23
24 #include "cksuite-all.h"
25 #include "nl-priv-dynamic-route/nl-priv-dynamic-route.h"
26
27 /*****************************************************************************/
28 /* Userspace API tests */
29
30 START_TEST(test_route_nexthop_api_set_get_all)
31 {
32 _nl_auto_rtnl_nexthop struct rtnl_nexthop *nh = NULL;
33 _nl_auto_nl_addr struct nl_addr *gw4 = NULL;
34 _nl_auto_nl_addr struct nl_addr *gw6 = NULL;
35 _nl_auto_nl_addr struct nl_addr *newdst4 = NULL;
36 _nl_auto_nl_addr struct nl_addr *via6 = NULL;
37 _nl_auto_nl_addr struct nl_addr *mpls = NULL;
38 _nl_auto_rtnl_nexthop struct rtnl_nexthop *clone = NULL;
39 _nl_auto_rtnl_nexthop struct rtnl_nexthop *clone_with_encap = NULL;
40 struct rtnl_nh_encap *encap = NULL;
41 struct rtnl_nh_encap *got = NULL;
42 struct rtnl_nh_encap *encap_clone = NULL;
43 uint32_t realms = 0xAABBCCDDu;
44 char flags_buf[64];
45 int flags_parsed;
46
47 nh = rtnl_route_nh_alloc();
48 ck_assert_ptr_nonnull(nh);
49
50 /* Ifindex set/get */
51 ck_assert_int_eq(rtnl_route_nh_get_ifindex(nh), 0);
52 rtnl_route_nh_set_ifindex(nh, 123);
53 ck_assert_int_eq(rtnl_route_nh_get_ifindex(nh), 123);
54
55 /* Weight set/get */
56 ck_assert_uint_eq(rtnl_route_nh_get_weight(nh), 0);
57 rtnl_route_nh_set_weight(nh, 7);
58 ck_assert_uint_eq(rtnl_route_nh_get_weight(nh), 7);
59
60 /* Flags set/unset/get and string conversion */
61 ck_assert_uint_eq(rtnl_route_nh_get_flags(nh), 0U);
62 rtnl_route_nh_set_flags(nh, RTNH_F_ONLINK);
63 ck_assert_int_eq((int)(rtnl_route_nh_get_flags(nh) & RTNH_F_ONLINK),
64 (int)RTNH_F_ONLINK);
65 ck_assert_ptr_nonnull(rtnl_route_nh_flags2str(RTNH_F_ONLINK, flags_buf,
66 sizeof(flags_buf)));
67 flags_parsed = rtnl_route_nh_str2flags("onlink");
68 ck_assert_int_eq(flags_parsed, RTNH_F_ONLINK);
69 rtnl_route_nh_unset_flags(nh, RTNH_F_ONLINK);
70 ck_assert_int_eq((int)(rtnl_route_nh_get_flags(nh) & RTNH_F_ONLINK), 0);
71
72 /* Realms set/get */
73 ck_assert_uint_eq(rtnl_route_nh_get_realms(nh), 0U);
74 rtnl_route_nh_set_realms(nh, realms);
75 ck_assert_uint_eq(rtnl_route_nh_get_realms(nh), realms);
76
77 /* Gateway get/set; start NULL, set v4 then replace with v6 */
78 ck_assert_ptr_eq(rtnl_route_nh_get_gateway(nh), NULL);
79 ck_assert_int_eq(nl_addr_parse("192.0.2.1", AF_INET, &gw4), 0);
80 rtnl_route_nh_set_gateway(nh, gw4);
81 ck_assert_ptr_nonnull(rtnl_route_nh_get_gateway(nh));
82 ck_assert_int_eq(nl_addr_get_family(rtnl_route_nh_get_gateway(nh)),
83 AF_INET);
84 ck_assert_int_eq(nl_addr_parse("2001:db8::1", AF_INET6, &gw6), 0);
85 rtnl_route_nh_set_gateway(nh, gw6);
86 ck_assert_int_eq(nl_addr_shared(gw4), 0);
87 ck_assert_int_eq(nl_addr_get_family(rtnl_route_nh_get_gateway(nh)),
88 AF_INET6);
89 rtnl_route_nh_set_gateway(nh, NULL);
90 ck_assert_ptr_eq(rtnl_route_nh_get_gateway(nh), NULL);
91
92 /* newdst set/get */
93 ck_assert_ptr_eq(rtnl_route_nh_get_newdst(nh), NULL);
94 ck_assert_int_eq(nl_addr_parse("198.51.100.7", AF_INET, &newdst4), 0);
95 ck_assert_int_eq(rtnl_route_nh_set_newdst(nh, newdst4), 0);
96 ck_assert_ptr_nonnull(rtnl_route_nh_get_newdst(nh));
97 ck_assert_int_eq(nl_addr_get_family(rtnl_route_nh_get_newdst(nh)),
98 AF_INET);
99 ck_assert_int_eq(rtnl_route_nh_set_newdst(nh, NULL), 0);
100 ck_assert_ptr_eq(rtnl_route_nh_get_newdst(nh), NULL);
101
102 /* via set/get */
103 ck_assert_ptr_eq(rtnl_route_nh_get_via(nh), NULL);
104 ck_assert_int_eq(nl_addr_parse("2001:db8::2", AF_INET6, &via6), 0);
105 ck_assert_int_eq(rtnl_route_nh_set_via(nh, via6), 0);
106 ck_assert_ptr_nonnull(rtnl_route_nh_get_via(nh));
107 ck_assert_int_eq(nl_addr_get_family(rtnl_route_nh_get_via(nh)),
108 AF_INET6);
109 ck_assert_int_eq(rtnl_route_nh_set_via(nh, NULL), 0);
110 ck_assert_ptr_eq(rtnl_route_nh_get_via(nh), NULL);
111
112 /* clone, compare, identical */
113 clone = rtnl_route_nh_clone(nh);
114 ck_assert_ptr_nonnull(clone);
115 ck_assert_int_eq(rtnl_route_nh_compare(nh, clone, 0xFFFFFFFFu, 0), 0);
116
117 /* Only differ in flags/weight -> identical() should still be true */
118 rtnl_route_nh_set_weight(clone, 9);
119 rtnl_route_nh_set_flags(clone, RTNH_F_ONLINK);
120 ck_assert_int_ne(rtnl_route_nh_compare(nh, clone, 0xFFFFFFFFu, 0), 0);
121 ck_assert_int_ne(rtnl_route_nh_identical(nh, clone), 0);
122
123 /* MPLS encapsulation */
124 encap = rtnl_nh_encap_alloc();
125 ck_assert_ptr_nonnull(encap);
126
127 ck_assert_int_eq(rtnl_nh_get_encap_mpls_ttl(NULL), -NLE_INVAL);
128 ck_assert_int_eq(rtnl_nh_get_encap_mpls_ttl(encap), -NLE_INVAL);
129
130 /* Invalid: missing destination labels */
131 ck_assert_int_eq(rtnl_nh_encap_mpls(encap, NULL, 0), -NLE_INVAL);
132
133 /* Valid MPLS encap: push label 100 with TTL 64 */
134 ck_assert_int_eq(nl_addr_parse("100", AF_MPLS, &mpls), 0);
135 ck_assert_int_eq(rtnl_nh_encap_mpls(encap, mpls, 64), 0);
136
137 /* Attach encap to nexthop and retrieve it back */
138 ck_assert_int_eq(rtnl_route_nh_set_encap(nh, encap), 0);
139 got = rtnl_route_nh_get_encap(nh);
140 ck_assert_ptr_eq(got, encap);
141
142 /* Access MPLS encap details through the new getters */
143 ck_assert_ptr_nonnull(rtnl_nh_get_encap_mpls_dst(got));
144 ck_assert_int_eq(rtnl_nh_get_encap_mpls_ttl(got), 64);
145
146 /* Exercise rtnl_nh_encap_clone() directly */
147 encap_clone = rtnl_nh_encap_clone(encap);
148 ck_assert_ptr_nonnull(encap_clone);
149 ck_assert_ptr_nonnull(rtnl_nh_get_encap_mpls_dst(encap_clone));
150 ck_assert_int_eq(
151 nl_addr_cmp(rtnl_nh_get_encap_mpls_dst(encap_clone), mpls), 0);
152 ck_assert_uint_eq(rtnl_nh_get_encap_mpls_ttl(encap_clone), 64);
153 /* Free the cloned encap explicitly */
154 rtnl_nh_encap_free(encap_clone);
155 encap_clone = NULL;
156
157 /* Exercise nexthop clone with encap: encap should be deep-cloned */
158 clone_with_encap = rtnl_route_nh_clone(nh);
159 ck_assert_ptr_nonnull(clone_with_encap);
160 encap_clone = rtnl_route_nh_get_encap(clone_with_encap);
161 ck_assert_ptr_nonnull(encap_clone);
162 /* The encap on the clone must not be the same pointer */
163 ck_assert_ptr_ne(encap_clone, encap);
164 ck_assert_int_eq(
165 nl_addr_cmp(rtnl_nh_get_encap_mpls_dst(encap_clone), mpls), 0);
166 ck_assert_uint_eq(rtnl_nh_get_encap_mpls_ttl(encap_clone), 64);
167
168 /* Clear encap and verify it is removed */
169 ck_assert_int_eq(rtnl_route_nh_set_encap(nh, NULL), 0);
170 ck_assert_ptr_eq(rtnl_route_nh_get_encap(nh), NULL);
171 }
172 END_TEST
173
174 /*****************************************************************************/
175 /* Kernel round-trip tests */
176
177 /*
178 * Helper: retrieve a configured route object by its prefix (exact match).
179 * This searches the kernel's route tables for a route whose destination
180 * prefix matches the nl_addr 'dst' (including prefix length), and returns
181 * it via 'out'.
182 */
183 static int nltst_route_get_by_dst(struct nl_sock *sk, struct nl_addr *dst,
184 struct rtnl_route **out)
185 {
186 _nl_auto_nl_cache struct nl_cache *cache = NULL;
187 _nl_auto_rtnl_route struct rtnl_route *filter = NULL;
188 struct nl_object *obj;
189 int err;
190
191 if (!dst || !out)
192 return -NLE_INVAL;
193
194 err = rtnl_route_alloc_cache(sk, nl_addr_get_family(dst), 0, &cache);
195 if (err < 0)
196 return err;
197
198 filter = rtnl_route_alloc();
199 if (!filter)
200 return -NLE_NOMEM;
201
202 err = rtnl_route_set_dst(filter, dst);
203 if (err < 0)
204 return err;
205
206 obj = nl_cache_find(cache, (struct nl_object *)filter);
207 if (!obj)
208 return -NLE_OBJ_NOTFOUND;
209
210 *out = (struct rtnl_route *)obj;
211 return 0;
212 }
213
214 START_TEST(test_kernel_route_roundtrip_single_v4)
215 {
216 const char *IFNAME_DUMMY = "rnh-dummy0";
217 _nltst_auto_delete_link const char *auto_del_dummy = NULL;
218 _nl_auto_nl_socket struct nl_sock *sk = NULL;
219 _nl_auto_rtnl_route struct rtnl_route *route = NULL;
220 _nl_auto_rtnl_route struct rtnl_route *got = NULL;
221 _nl_auto_nl_addr struct nl_addr *dst = NULL;
222 _nl_auto_nl_addr struct nl_addr *gw = NULL;
223 struct rtnl_nexthop *nh, *knh;
224 struct nl_addr *kgw;
225 int ifindex_dummy;
226 int r;
227
228 if (_nltst_skip_no_netns())
229 return;
230
231 sk = _nltst_socket(NETLINK_ROUTE);
232
233 auto_del_dummy = IFNAME_DUMMY;
234 _nltst_add_dummy_v4_with_addr(sk, IFNAME_DUMMY, &ifindex_dummy,
235 "192.0.2.2", 24);
236
237 /* Build a simple IPv4 route via gateway on dummy */
238 route = rtnl_route_alloc();
239 ck_assert_ptr_nonnull(route);
240 ck_assert_int_eq(nl_addr_parse("198.51.100.0/24", AF_INET, &dst), 0);
241 ck_assert_int_eq(rtnl_route_set_family(route, AF_INET), 0);
242 ck_assert_int_eq(rtnl_route_set_dst(route, dst), 0);
243
244 nh = rtnl_route_nh_alloc();
245 ck_assert_ptr_nonnull(nh);
246 rtnl_route_nh_set_ifindex(nh, ifindex_dummy);
247 ck_assert_int_eq(nl_addr_parse("192.0.2.1", AF_INET, &gw), 0);
248 rtnl_route_nh_set_realms(nh, 0xdeadbeef);
249 rtnl_route_nh_set_gateway(nh, gw);
250 rtnl_route_nh_set_weight(nh, 1);
251 rtnl_route_add_nexthop(route, nh);
252
253 r = rtnl_route_add(sk, route, NLM_F_CREATE);
254 ck_assert_int_eq(r, 0);
255
256 /* Retrieve the route back by its prefix and validate nexthop attributes */
257 ck_assert_int_eq(nltst_route_get_by_dst(sk, dst, &got), 0);
258 ck_assert_ptr_nonnull(got);
259 ck_assert_int_eq(nl_addr_cmp(rtnl_route_get_dst(got), dst), 0);
260 ck_assert_int_eq(rtnl_route_get_nnexthops(got), 1);
261
262 knh = rtnl_route_nexthop_n(got, 0);
263 kgw = rtnl_route_nh_get_gateway(knh);
264 ck_assert_int_eq(rtnl_route_nh_get_ifindex(knh), ifindex_dummy);
265 ck_assert_ptr_nonnull(kgw);
266 ck_assert_int_eq(nl_addr_get_family(kgw), AF_INET);
267 ck_assert_int_eq(nl_addr_cmp(kgw, gw), 0);
268
269 /* Single-nexthop route weight is not propagated to kernel - thus check for 0 */
270 ck_assert_uint_eq(rtnl_route_nh_get_weight(knh), 0);
271 ck_assert_uint_eq(rtnl_route_nh_get_flags(knh), 0U);
272 ck_assert_uint_eq(rtnl_route_nh_get_realms(knh), 0xdeadbeef);
273 ck_assert_ptr_eq(rtnl_route_nh_get_newdst(knh), NULL);
274 ck_assert_ptr_eq(rtnl_route_nh_get_via(knh), NULL);
275 /* No encap present */
276 ck_assert_ptr_eq(rtnl_route_nh_get_encap(knh), NULL);
277 }
278 END_TEST
279
280 static void nltst_assert_multipath_v4(struct rtnl_route *route,
281 int ifindex_dummy, struct nl_addr *gw1,
282 unsigned int w1, struct nl_addr *gw2,
283 unsigned int w2, uint32_t realms)
284 {
285 int seen_gw1 = 0, seen_gw2 = 0;
286 struct nl_list_head *list = rtnl_route_get_nexthops(route);
287 struct rtnl_nexthop *knh;
288 size_t cnt = 0;
289
290 nl_list_for_each_entry(knh, list, rtnh_list) {
291 struct nl_addr *kgw = rtnl_route_nh_get_gateway(knh);
292
293 ck_assert_int_eq(rtnl_route_nh_get_ifindex(knh), ifindex_dummy);
294 ck_assert_ptr_nonnull(kgw);
295 ck_assert_int_eq(nl_addr_get_family(kgw), AF_INET);
296
297 if (nl_addr_cmp(kgw, gw1) == 0) {
298 seen_gw1 = 1;
299 ck_assert_uint_eq(rtnl_route_nh_get_weight(knh), w1);
300 }
301 if (nl_addr_cmp(kgw, gw2) == 0) {
302 seen_gw2 = 1;
303 ck_assert_uint_eq(rtnl_route_nh_get_weight(knh), w2);
304 }
305
306 ck_assert_uint_eq(rtnl_route_nh_get_flags(knh), 0U);
307 ck_assert_uint_eq(rtnl_route_nh_get_realms(knh), realms);
308 ck_assert_ptr_eq(rtnl_route_nh_get_newdst(knh), NULL);
309 ck_assert_ptr_eq(rtnl_route_nh_get_via(knh), NULL);
310 /* No encap present */
311 ck_assert_ptr_eq(rtnl_route_nh_get_encap(knh), NULL);
312
313 cnt++;
314 }
315
316 ck_assert_uint_eq(cnt, 2);
317 ck_assert_int_ne(seen_gw1, 0);
318 ck_assert_int_ne(seen_gw2, 0);
319 }
320
321 START_TEST(test_kernel_route_roundtrip_multipath_v4)
322 {
323 const char *IFNAME_DUMMY = "rnh-dummy1";
324 _nltst_auto_delete_link const char *auto_del_dummy = NULL;
325 _nl_auto_nl_socket struct nl_sock *sk = NULL;
326 _nl_auto_rtnl_route struct rtnl_route *route = NULL;
327 _nl_auto_rtnl_route struct rtnl_route *got = NULL;
328 _nl_auto_nl_addr struct nl_addr *dst = NULL;
329 _nl_auto_nl_addr struct nl_addr *gw1 = NULL;
330 _nl_auto_nl_addr struct nl_addr *gw2 = NULL;
331 struct rtnl_nexthop *nh1 = NULL;
332 struct rtnl_nexthop *nh2 = NULL;
333 int ifindex_dummy;
334
335 if (_nltst_skip_no_netns())
336 return;
337
338 sk = _nltst_socket(NETLINK_ROUTE);
339
340 auto_del_dummy = IFNAME_DUMMY;
341 _nltst_add_dummy_v4_with_addr(sk, IFNAME_DUMMY, &ifindex_dummy,
342 "192.0.2.2", 24);
343
344 /* Build IPv4 ECMP route with 2 nexthops differing by gateway */
345 route = rtnl_route_alloc();
346 ck_assert_ptr_nonnull(route);
347 ck_assert_int_eq(nl_addr_parse("198.51.101.0/24", AF_INET, &dst), 0);
348 ck_assert_int_eq(rtnl_route_set_family(route, AF_INET), 0);
349 ck_assert_int_eq(rtnl_route_set_dst(route, dst), 0);
350
351 nh1 = rtnl_route_nh_alloc();
352 ck_assert_ptr_nonnull(nh1);
353 rtnl_route_nh_set_ifindex(nh1, ifindex_dummy);
354 ck_assert_int_eq(nl_addr_parse("192.0.2.1", AF_INET, &gw1), 0);
355 rtnl_route_nh_set_gateway(nh1, gw1);
356 rtnl_route_nh_set_weight(nh1, 1);
357 rtnl_route_nh_set_realms(nh1, 0xdeadbeef);
358 rtnl_route_add_nexthop(route, nh1);
359
360 nh2 = rtnl_route_nh_alloc();
361 ck_assert_ptr_nonnull(nh2);
362 rtnl_route_nh_set_ifindex(nh2, ifindex_dummy);
363 ck_assert_int_eq(nl_addr_parse("192.0.2.3", AF_INET, &gw2), 0);
364 rtnl_route_nh_set_gateway(nh2, gw2);
365 rtnl_route_nh_set_weight(nh2, 2);
366 rtnl_route_nh_set_realms(nh2, 0xdeadbeef);
367 rtnl_route_add_nexthop(route, nh2);
368
369 ck_assert_int_eq(rtnl_route_add(sk, route, NLM_F_CREATE), 0);
370
371 /* Retrieve the route back by its prefix and validate multipath nexthops */
372 ck_assert_int_eq(nltst_route_get_by_dst(sk, dst, &got), 0);
373 ck_assert_ptr_nonnull(got);
374 ck_assert_int_eq(nl_addr_cmp(rtnl_route_get_dst(got), dst), 0);
375 ck_assert_int_eq(rtnl_route_get_nnexthops(got), 2);
376
377 nltst_assert_multipath_v4(got, ifindex_dummy, gw1, 1, gw2, 2,
378 0xdeadbeef);
379 }
380 END_TEST
381
382 static void nltst_assert_single_v4_mpls(struct rtnl_route *route,
383 int ifindex_dummy, struct nl_addr *gw,
384 struct nl_addr *labels,
385 unsigned int ttl)
386 {
387 struct rtnl_nexthop *knh = rtnl_route_nexthop_n(route, 0);
388 struct nl_addr *kgw = rtnl_route_nh_get_gateway(knh);
389 struct rtnl_nh_encap *encap = rtnl_route_nh_get_encap(knh);
390 struct nl_addr *klabels;
391
392 ck_assert_ptr_nonnull(encap);
393 ck_assert_int_eq(rtnl_route_nh_get_ifindex(knh), ifindex_dummy);
394 ck_assert_ptr_nonnull(kgw);
395 ck_assert_int_eq(nl_addr_get_family(kgw), AF_INET);
396 ck_assert_int_eq(nl_addr_cmp(kgw, gw), 0);
397
398 klabels = rtnl_nh_get_encap_mpls_dst(encap);
399 ck_assert_ptr_nonnull(klabels);
400 ck_assert_int_eq(nl_addr_get_family(klabels), AF_MPLS);
401 ck_assert_int_eq(nl_addr_cmp(klabels, labels), 0);
402
403 ck_assert_int_eq(rtnl_nh_get_encap_mpls_ttl(encap), ttl);
404 }
405
406 START_TEST(test_kernel_route_roundtrip_nh_mpls_encap_v4)
407 {
408 const char *IFNAME_DUMMY = "rnh-dummy2";
409 _nltst_auto_delete_link const char *auto_del_dummy = NULL;
410 _nl_auto_nl_socket struct nl_sock *sk = NULL;
411 _nl_auto_rtnl_route struct rtnl_route *route = NULL;
412 _nl_auto_rtnl_route struct rtnl_route *got = NULL;
413 _nl_auto_nl_addr struct nl_addr *dst = NULL;
414 _nl_auto_nl_addr struct nl_addr *gw = NULL;
415 _nl_auto_nl_addr struct nl_addr *labels = NULL;
416 struct rtnl_nh_encap *encap2;
417 struct rtnl_nexthop *nh = NULL;
418 int ifindex_dummy;
419
420 if (_nltst_skip_no_netns())
421 return;
422
423 sk = _nltst_socket(NETLINK_ROUTE);
424
425 auto_del_dummy = IFNAME_DUMMY;
426 _nltst_add_dummy_v4_with_addr(sk, IFNAME_DUMMY, &ifindex_dummy,
427 "192.0.2.2", 24);
428
429 /* Build a simple IPv4 route via gateway on dummy with MPLS encap */
430 route = rtnl_route_alloc();
431 ck_assert_ptr_nonnull(route);
432 ck_assert_int_eq(nl_addr_parse("198.51.102.0/24", AF_INET, &dst), 0);
433 ck_assert_int_eq(rtnl_route_set_family(route, AF_INET), 0);
434 ck_assert_int_eq(rtnl_route_set_dst(route, dst), 0);
435
436 nh = rtnl_route_nh_alloc();
437 ck_assert_ptr_nonnull(nh);
438 rtnl_route_nh_set_ifindex(nh, ifindex_dummy);
439 ck_assert_int_eq(nl_addr_parse("192.0.2.1", AF_INET, &gw), 0);
440 rtnl_route_nh_set_gateway(nh, gw);
441
442 /* Push label 100 with TTL 64 */
443 encap2 = rtnl_nh_encap_alloc();
444 ck_assert_ptr_nonnull(encap2);
445 ck_assert_int_eq(nl_addr_parse("100", AF_MPLS, &labels), 0);
446 ck_assert_int_eq(rtnl_nh_encap_mpls(encap2, labels, 64), 0);
447 ck_assert_int_eq(rtnl_route_nh_set_encap(nh, encap2), 0);
448 rtnl_route_add_nexthop(route, nh);
449
450 ck_assert_int_eq(rtnl_route_add(sk, route, NLM_F_CREATE), 0);
451
452 /* Retrieve the route back by its prefix and validate MPLS encap on nexthop */
453 ck_assert_int_eq(nltst_route_get_by_dst(sk, dst, &got), 0);
454 ck_assert_ptr_nonnull(got);
455 ck_assert_int_eq(nl_addr_cmp(rtnl_route_get_dst(got), dst), 0);
456 ck_assert_int_eq(rtnl_route_get_nnexthops(got), 1);
457 nltst_assert_single_v4_mpls(got, ifindex_dummy, gw, labels, 64u);
458 }
459 END_TEST
460
461 Suite *make_nl_route_nexthop_suite(void)
462 {
463 Suite *suite = suite_create("route-nexthop");
464 TCase *tc_api = tcase_create("Userspace-API");
465 TCase *tc_kernel = tcase_create("Kernel");
466
467 /* Userspace only tests */
468 tcase_add_test(tc_api, test_route_nexthop_api_set_get_all);
469 suite_add_tcase(suite, tc_api);
470
471 /* Kernel round-trip – needs private netns */
472 tcase_add_checked_fixture(tc_kernel, nltst_netns_fixture_setup,
473 nltst_netns_fixture_teardown);
474 tcase_add_test(tc_kernel, test_kernel_route_roundtrip_single_v4);
475 tcase_add_test(tc_kernel, test_kernel_route_roundtrip_multipath_v4);
476 /* Nexthop encapsulation roundtrip tests */
477 tcase_add_test(tc_kernel, test_kernel_route_roundtrip_nh_mpls_encap_v4);
478 suite_add_tcase(suite, tc_kernel);
479
480 return suite;
481 }