1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * Author: Justin Iurman (justin.iurman@uliege.be)
4  *
5  * IOAM tester for IPv6, see ioam6.sh for details on each test case.
6  */
7 #include <arpa/inet.h>
8 #include <errno.h>
9 #include <limits.h>
10 #include <linux/const.h>
11 #include <linux/if_ether.h>
12 #include <linux/ioam6.h>
13 #include <linux/ipv6.h>
14 #include <stdlib.h>
15 #include <string.h>
16 #include <unistd.h>
17 
18 struct ioam_config {
19 	__u32 id;
20 	__u64 wide;
21 	__u16 ingr_id;
22 	__u16 egr_id;
23 	__u32 ingr_wide;
24 	__u32 egr_wide;
25 	__u32 ns_data;
26 	__u64 ns_wide;
27 	__u32 sc_id;
28 	__u8 hlim;
29 	char *sc_data;
30 };
31 
32 /*
33  * Be careful if you modify structs below - everything MUST be kept synchronized
34  * with configurations inside ioam6.sh and always reflect the same.
35  */
36 
37 static struct ioam_config node1 = {
38 	.id = 1,
39 	.wide = 11111111,
40 	.ingr_id = 0xffff, /* default value */
41 	.egr_id = 101,
42 	.ingr_wide = 0xffffffff, /* default value */
43 	.egr_wide = 101101,
44 	.ns_data = 0xdeadbee0,
45 	.ns_wide = 0xcafec0caf00dc0de,
46 	.sc_id = 777,
47 	.sc_data = "something that will be 4n-aligned",
48 	.hlim = 64,
49 };
50 
51 static struct ioam_config node2 = {
52 	.id = 2,
53 	.wide = 22222222,
54 	.ingr_id = 201,
55 	.egr_id = 202,
56 	.ingr_wide = 201201,
57 	.egr_wide = 202202,
58 	.ns_data = 0xdeadbee1,
59 	.ns_wide = 0xcafec0caf11dc0de,
60 	.sc_id = 666,
61 	.sc_data = "Hello there -Obi",
62 	.hlim = 63,
63 };
64 
65 static struct ioam_config node3 = {
66 	.id = 3,
67 	.wide = 33333333,
68 	.ingr_id = 301,
69 	.egr_id = 0xffff, /* default value */
70 	.ingr_wide = 301301,
71 	.egr_wide = 0xffffffff, /* default value */
72 	.ns_data = 0xdeadbee2,
73 	.ns_wide = 0xcafec0caf22dc0de,
74 	.sc_id = 0xffffff, /* default value */
75 	.sc_data = NULL,
76 	.hlim = 62,
77 };
78 
79 enum {
80 	/**********
81 	 * OUTPUT *
82 	 **********/
83 	TEST_OUT_UNDEF_NS,
84 	TEST_OUT_NO_ROOM,
85 	TEST_OUT_BIT0,
86 	TEST_OUT_BIT1,
87 	TEST_OUT_BIT2,
88 	TEST_OUT_BIT3,
89 	TEST_OUT_BIT4,
90 	TEST_OUT_BIT5,
91 	TEST_OUT_BIT6,
92 	TEST_OUT_BIT7,
93 	TEST_OUT_BIT8,
94 	TEST_OUT_BIT9,
95 	TEST_OUT_BIT10,
96 	TEST_OUT_BIT11,
97 	TEST_OUT_BIT22,
98 	TEST_OUT_FULL_SUPP_TRACE,
99 
100 	/*********
101 	 * INPUT *
102 	 *********/
103 	TEST_IN_UNDEF_NS,
104 	TEST_IN_NO_ROOM,
105 	TEST_IN_OFLAG,
106 	TEST_IN_BIT0,
107 	TEST_IN_BIT1,
108 	TEST_IN_BIT2,
109 	TEST_IN_BIT3,
110 	TEST_IN_BIT4,
111 	TEST_IN_BIT5,
112 	TEST_IN_BIT6,
113 	TEST_IN_BIT7,
114 	TEST_IN_BIT8,
115 	TEST_IN_BIT9,
116 	TEST_IN_BIT10,
117 	TEST_IN_BIT11,
118 	TEST_IN_BIT22,
119 	TEST_IN_FULL_SUPP_TRACE,
120 
121 	/**********
122 	 * GLOBAL *
123 	 **********/
124 	TEST_FWD_FULL_SUPP_TRACE,
125 
126 	__TEST_MAX,
127 };
128 
check_ioam_header(int tid,struct ioam6_trace_hdr * ioam6h,__u32 trace_type,__u16 ioam_ns)129 static int check_ioam_header(int tid, struct ioam6_trace_hdr *ioam6h,
130 			     __u32 trace_type, __u16 ioam_ns)
131 {
132 	if (__be16_to_cpu(ioam6h->namespace_id) != ioam_ns ||
133 	    __be32_to_cpu(ioam6h->type_be32) != (trace_type << 8))
134 		return 1;
135 
136 	switch (tid) {
137 	case TEST_OUT_UNDEF_NS:
138 	case TEST_IN_UNDEF_NS:
139 		return ioam6h->overflow ||
140 		       ioam6h->nodelen != 1 ||
141 		       ioam6h->remlen != 1;
142 
143 	case TEST_OUT_NO_ROOM:
144 	case TEST_IN_NO_ROOM:
145 	case TEST_IN_OFLAG:
146 		return !ioam6h->overflow ||
147 		       ioam6h->nodelen != 2 ||
148 		       ioam6h->remlen != 1;
149 
150 	case TEST_OUT_BIT0:
151 	case TEST_IN_BIT0:
152 	case TEST_OUT_BIT1:
153 	case TEST_IN_BIT1:
154 	case TEST_OUT_BIT2:
155 	case TEST_IN_BIT2:
156 	case TEST_OUT_BIT3:
157 	case TEST_IN_BIT3:
158 	case TEST_OUT_BIT4:
159 	case TEST_IN_BIT4:
160 	case TEST_OUT_BIT5:
161 	case TEST_IN_BIT5:
162 	case TEST_OUT_BIT6:
163 	case TEST_IN_BIT6:
164 	case TEST_OUT_BIT7:
165 	case TEST_IN_BIT7:
166 	case TEST_OUT_BIT11:
167 	case TEST_IN_BIT11:
168 		return ioam6h->overflow ||
169 		       ioam6h->nodelen != 1 ||
170 		       ioam6h->remlen;
171 
172 	case TEST_OUT_BIT8:
173 	case TEST_IN_BIT8:
174 	case TEST_OUT_BIT9:
175 	case TEST_IN_BIT9:
176 	case TEST_OUT_BIT10:
177 	case TEST_IN_BIT10:
178 		return ioam6h->overflow ||
179 		       ioam6h->nodelen != 2 ||
180 		       ioam6h->remlen;
181 
182 	case TEST_OUT_BIT22:
183 	case TEST_IN_BIT22:
184 		return ioam6h->overflow ||
185 		       ioam6h->nodelen ||
186 		       ioam6h->remlen;
187 
188 	case TEST_OUT_FULL_SUPP_TRACE:
189 	case TEST_IN_FULL_SUPP_TRACE:
190 	case TEST_FWD_FULL_SUPP_TRACE:
191 		return ioam6h->overflow ||
192 		       ioam6h->nodelen != 15 ||
193 		       ioam6h->remlen;
194 
195 	default:
196 		break;
197 	}
198 
199 	return 1;
200 }
201 
check_ioam6_data(__u8 ** p,struct ioam6_trace_hdr * ioam6h,const struct ioam_config cnf)202 static int check_ioam6_data(__u8 **p, struct ioam6_trace_hdr *ioam6h,
203 			    const struct ioam_config cnf)
204 {
205 	unsigned int len;
206 	__u8 aligned;
207 	__u64 raw64;
208 	__u32 raw32;
209 
210 	if (ioam6h->type.bit0) {
211 		raw32 = __be32_to_cpu(*((__u32 *)*p));
212 		if (cnf.hlim != (raw32 >> 24) || cnf.id != (raw32 & 0xffffff))
213 			return 1;
214 		*p += sizeof(__u32);
215 	}
216 
217 	if (ioam6h->type.bit1) {
218 		raw32 = __be32_to_cpu(*((__u32 *)*p));
219 		if (cnf.ingr_id != (raw32 >> 16) ||
220 		    cnf.egr_id != (raw32 & 0xffff))
221 			return 1;
222 		*p += sizeof(__u32);
223 	}
224 
225 	if (ioam6h->type.bit2)
226 		*p += sizeof(__u32);
227 
228 	if (ioam6h->type.bit3)
229 		*p += sizeof(__u32);
230 
231 	if (ioam6h->type.bit4) {
232 		if (__be32_to_cpu(*((__u32 *)*p)) != 0xffffffff)
233 			return 1;
234 		*p += sizeof(__u32);
235 	}
236 
237 	if (ioam6h->type.bit5) {
238 		if (__be32_to_cpu(*((__u32 *)*p)) != cnf.ns_data)
239 			return 1;
240 		*p += sizeof(__u32);
241 	}
242 
243 	if (ioam6h->type.bit6)
244 		*p += sizeof(__u32);
245 
246 	if (ioam6h->type.bit7) {
247 		if (__be32_to_cpu(*((__u32 *)*p)) != 0xffffffff)
248 			return 1;
249 		*p += sizeof(__u32);
250 	}
251 
252 	if (ioam6h->type.bit8) {
253 		raw64 = __be64_to_cpu(*((__u64 *)*p));
254 		if (cnf.hlim != (raw64 >> 56) ||
255 		    cnf.wide != (raw64 & 0xffffffffffffff))
256 			return 1;
257 		*p += sizeof(__u64);
258 	}
259 
260 	if (ioam6h->type.bit9) {
261 		if (__be32_to_cpu(*((__u32 *)*p)) != cnf.ingr_wide)
262 			return 1;
263 		*p += sizeof(__u32);
264 
265 		if (__be32_to_cpu(*((__u32 *)*p)) != cnf.egr_wide)
266 			return 1;
267 		*p += sizeof(__u32);
268 	}
269 
270 	if (ioam6h->type.bit10) {
271 		if (__be64_to_cpu(*((__u64 *)*p)) != cnf.ns_wide)
272 			return 1;
273 		*p += sizeof(__u64);
274 	}
275 
276 	if (ioam6h->type.bit11) {
277 		if (__be32_to_cpu(*((__u32 *)*p)) != 0xffffffff)
278 			return 1;
279 		*p += sizeof(__u32);
280 	}
281 
282 	if (ioam6h->type.bit12) {
283 		if (__be32_to_cpu(*((__u32 *)*p)) != 0xffffffff)
284 			return 1;
285 		*p += sizeof(__u32);
286 	}
287 
288 	if (ioam6h->type.bit13) {
289 		if (__be32_to_cpu(*((__u32 *)*p)) != 0xffffffff)
290 			return 1;
291 		*p += sizeof(__u32);
292 	}
293 
294 	if (ioam6h->type.bit14) {
295 		if (__be32_to_cpu(*((__u32 *)*p)) != 0xffffffff)
296 			return 1;
297 		*p += sizeof(__u32);
298 	}
299 
300 	if (ioam6h->type.bit15) {
301 		if (__be32_to_cpu(*((__u32 *)*p)) != 0xffffffff)
302 			return 1;
303 		*p += sizeof(__u32);
304 	}
305 
306 	if (ioam6h->type.bit16) {
307 		if (__be32_to_cpu(*((__u32 *)*p)) != 0xffffffff)
308 			return 1;
309 		*p += sizeof(__u32);
310 	}
311 
312 	if (ioam6h->type.bit17) {
313 		if (__be32_to_cpu(*((__u32 *)*p)) != 0xffffffff)
314 			return 1;
315 		*p += sizeof(__u32);
316 	}
317 
318 	if (ioam6h->type.bit18) {
319 		if (__be32_to_cpu(*((__u32 *)*p)) != 0xffffffff)
320 			return 1;
321 		*p += sizeof(__u32);
322 	}
323 
324 	if (ioam6h->type.bit19) {
325 		if (__be32_to_cpu(*((__u32 *)*p)) != 0xffffffff)
326 			return 1;
327 		*p += sizeof(__u32);
328 	}
329 
330 	if (ioam6h->type.bit20) {
331 		if (__be32_to_cpu(*((__u32 *)*p)) != 0xffffffff)
332 			return 1;
333 		*p += sizeof(__u32);
334 	}
335 
336 	if (ioam6h->type.bit21) {
337 		if (__be32_to_cpu(*((__u32 *)*p)) != 0xffffffff)
338 			return 1;
339 		*p += sizeof(__u32);
340 	}
341 
342 	if (ioam6h->type.bit22) {
343 		len = cnf.sc_data ? strlen(cnf.sc_data) : 0;
344 		aligned = cnf.sc_data ? __ALIGN_KERNEL(len, 4) : 0;
345 
346 		raw32 = __be32_to_cpu(*((__u32 *)*p));
347 		if (aligned != (raw32 >> 24) * 4 ||
348 		    cnf.sc_id != (raw32 & 0xffffff))
349 			return 1;
350 		*p += sizeof(__u32);
351 
352 		if (cnf.sc_data) {
353 			if (strncmp((char *)*p, cnf.sc_data, len))
354 				return 1;
355 
356 			*p += len;
357 			aligned -= len;
358 
359 			while (aligned--) {
360 				if (**p != '\0')
361 					return 1;
362 				*p += sizeof(__u8);
363 			}
364 		}
365 	}
366 
367 	return 0;
368 }
369 
check_ioam_header_and_data(int tid,struct ioam6_trace_hdr * ioam6h,__u32 trace_type,__u16 ioam_ns)370 static int check_ioam_header_and_data(int tid, struct ioam6_trace_hdr *ioam6h,
371 				      __u32 trace_type, __u16 ioam_ns)
372 {
373 	__u8 *p;
374 
375 	if (check_ioam_header(tid, ioam6h, trace_type, ioam_ns))
376 		return 1;
377 
378 	p = ioam6h->data + ioam6h->remlen * 4;
379 
380 	switch (tid) {
381 	case TEST_OUT_BIT0:
382 	case TEST_OUT_BIT1:
383 	case TEST_OUT_BIT2:
384 	case TEST_OUT_BIT3:
385 	case TEST_OUT_BIT4:
386 	case TEST_OUT_BIT5:
387 	case TEST_OUT_BIT6:
388 	case TEST_OUT_BIT7:
389 	case TEST_OUT_BIT8:
390 	case TEST_OUT_BIT9:
391 	case TEST_OUT_BIT10:
392 	case TEST_OUT_BIT11:
393 	case TEST_OUT_BIT22:
394 	case TEST_OUT_FULL_SUPP_TRACE:
395 		return check_ioam6_data(&p, ioam6h, node1);
396 
397 	case TEST_IN_BIT0:
398 	case TEST_IN_BIT1:
399 	case TEST_IN_BIT2:
400 	case TEST_IN_BIT3:
401 	case TEST_IN_BIT4:
402 	case TEST_IN_BIT5:
403 	case TEST_IN_BIT6:
404 	case TEST_IN_BIT7:
405 	case TEST_IN_BIT8:
406 	case TEST_IN_BIT9:
407 	case TEST_IN_BIT10:
408 	case TEST_IN_BIT11:
409 	case TEST_IN_BIT22:
410 	case TEST_IN_FULL_SUPP_TRACE:
411 	{
412 		__u32 tmp32 = node2.egr_wide;
413 		__u16 tmp16 = node2.egr_id;
414 		int res;
415 
416 		node2.egr_id = 0xffff;
417 		node2.egr_wide = 0xffffffff;
418 
419 		res = check_ioam6_data(&p, ioam6h, node2);
420 
421 		node2.egr_id = tmp16;
422 		node2.egr_wide = tmp32;
423 
424 		return res;
425 	}
426 
427 	case TEST_FWD_FULL_SUPP_TRACE:
428 		if (check_ioam6_data(&p, ioam6h, node3))
429 			return 1;
430 		if (check_ioam6_data(&p, ioam6h, node2))
431 			return 1;
432 		return check_ioam6_data(&p, ioam6h, node1);
433 
434 	default:
435 		break;
436 	}
437 
438 	return 1;
439 }
440 
str2id(const char * tname)441 static int str2id(const char *tname)
442 {
443 	if (!strcmp("out_undef_ns", tname))
444 		return TEST_OUT_UNDEF_NS;
445 	if (!strcmp("out_no_room", tname))
446 		return TEST_OUT_NO_ROOM;
447 	if (!strcmp("out_bit0", tname))
448 		return TEST_OUT_BIT0;
449 	if (!strcmp("out_bit1", tname))
450 		return TEST_OUT_BIT1;
451 	if (!strcmp("out_bit2", tname))
452 		return TEST_OUT_BIT2;
453 	if (!strcmp("out_bit3", tname))
454 		return TEST_OUT_BIT3;
455 	if (!strcmp("out_bit4", tname))
456 		return TEST_OUT_BIT4;
457 	if (!strcmp("out_bit5", tname))
458 		return TEST_OUT_BIT5;
459 	if (!strcmp("out_bit6", tname))
460 		return TEST_OUT_BIT6;
461 	if (!strcmp("out_bit7", tname))
462 		return TEST_OUT_BIT7;
463 	if (!strcmp("out_bit8", tname))
464 		return TEST_OUT_BIT8;
465 	if (!strcmp("out_bit9", tname))
466 		return TEST_OUT_BIT9;
467 	if (!strcmp("out_bit10", tname))
468 		return TEST_OUT_BIT10;
469 	if (!strcmp("out_bit11", tname))
470 		return TEST_OUT_BIT11;
471 	if (!strcmp("out_bit22", tname))
472 		return TEST_OUT_BIT22;
473 	if (!strcmp("out_full_supp_trace", tname))
474 		return TEST_OUT_FULL_SUPP_TRACE;
475 	if (!strcmp("in_undef_ns", tname))
476 		return TEST_IN_UNDEF_NS;
477 	if (!strcmp("in_no_room", tname))
478 		return TEST_IN_NO_ROOM;
479 	if (!strcmp("in_oflag", tname))
480 		return TEST_IN_OFLAG;
481 	if (!strcmp("in_bit0", tname))
482 		return TEST_IN_BIT0;
483 	if (!strcmp("in_bit1", tname))
484 		return TEST_IN_BIT1;
485 	if (!strcmp("in_bit2", tname))
486 		return TEST_IN_BIT2;
487 	if (!strcmp("in_bit3", tname))
488 		return TEST_IN_BIT3;
489 	if (!strcmp("in_bit4", tname))
490 		return TEST_IN_BIT4;
491 	if (!strcmp("in_bit5", tname))
492 		return TEST_IN_BIT5;
493 	if (!strcmp("in_bit6", tname))
494 		return TEST_IN_BIT6;
495 	if (!strcmp("in_bit7", tname))
496 		return TEST_IN_BIT7;
497 	if (!strcmp("in_bit8", tname))
498 		return TEST_IN_BIT8;
499 	if (!strcmp("in_bit9", tname))
500 		return TEST_IN_BIT9;
501 	if (!strcmp("in_bit10", tname))
502 		return TEST_IN_BIT10;
503 	if (!strcmp("in_bit11", tname))
504 		return TEST_IN_BIT11;
505 	if (!strcmp("in_bit22", tname))
506 		return TEST_IN_BIT22;
507 	if (!strcmp("in_full_supp_trace", tname))
508 		return TEST_IN_FULL_SUPP_TRACE;
509 	if (!strcmp("fwd_full_supp_trace", tname))
510 		return TEST_FWD_FULL_SUPP_TRACE;
511 
512 	return -1;
513 }
514 
ipv6_addr_equal(const struct in6_addr * a1,const struct in6_addr * a2)515 static int ipv6_addr_equal(const struct in6_addr *a1, const struct in6_addr *a2)
516 {
517 	return ((a1->s6_addr32[0] ^ a2->s6_addr32[0]) |
518 		(a1->s6_addr32[1] ^ a2->s6_addr32[1]) |
519 		(a1->s6_addr32[2] ^ a2->s6_addr32[2]) |
520 		(a1->s6_addr32[3] ^ a2->s6_addr32[3])) == 0;
521 }
522 
get_u32(__u32 * val,const char * arg,int base)523 static int get_u32(__u32 *val, const char *arg, int base)
524 {
525 	unsigned long res;
526 	char *ptr;
527 
528 	if (!arg || !*arg)
529 		return -1;
530 	res = strtoul(arg, &ptr, base);
531 
532 	if (!ptr || ptr == arg || *ptr)
533 		return -1;
534 
535 	if (res == ULONG_MAX && errno == ERANGE)
536 		return -1;
537 
538 	if (res > 0xFFFFFFFFUL)
539 		return -1;
540 
541 	*val = res;
542 	return 0;
543 }
544 
get_u16(__u16 * val,const char * arg,int base)545 static int get_u16(__u16 *val, const char *arg, int base)
546 {
547 	unsigned long res;
548 	char *ptr;
549 
550 	if (!arg || !*arg)
551 		return -1;
552 	res = strtoul(arg, &ptr, base);
553 
554 	if (!ptr || ptr == arg || *ptr)
555 		return -1;
556 
557 	if (res == ULONG_MAX && errno == ERANGE)
558 		return -1;
559 
560 	if (res > 0xFFFFUL)
561 		return -1;
562 
563 	*val = res;
564 	return 0;
565 }
566 
567 static int (*func[__TEST_MAX])(int, struct ioam6_trace_hdr *, __u32, __u16) = {
568 	[TEST_OUT_UNDEF_NS]		= check_ioam_header,
569 	[TEST_OUT_NO_ROOM]		= check_ioam_header,
570 	[TEST_OUT_BIT0]		= check_ioam_header_and_data,
571 	[TEST_OUT_BIT1]		= check_ioam_header_and_data,
572 	[TEST_OUT_BIT2]		= check_ioam_header_and_data,
573 	[TEST_OUT_BIT3]		= check_ioam_header_and_data,
574 	[TEST_OUT_BIT4]		= check_ioam_header_and_data,
575 	[TEST_OUT_BIT5]		= check_ioam_header_and_data,
576 	[TEST_OUT_BIT6]		= check_ioam_header_and_data,
577 	[TEST_OUT_BIT7]		= check_ioam_header_and_data,
578 	[TEST_OUT_BIT8]		= check_ioam_header_and_data,
579 	[TEST_OUT_BIT9]		= check_ioam_header_and_data,
580 	[TEST_OUT_BIT10]		= check_ioam_header_and_data,
581 	[TEST_OUT_BIT11]		= check_ioam_header_and_data,
582 	[TEST_OUT_BIT22]		= check_ioam_header_and_data,
583 	[TEST_OUT_FULL_SUPP_TRACE]	= check_ioam_header_and_data,
584 	[TEST_IN_UNDEF_NS]		= check_ioam_header,
585 	[TEST_IN_NO_ROOM]		= check_ioam_header,
586 	[TEST_IN_OFLAG]		= check_ioam_header,
587 	[TEST_IN_BIT0]			= check_ioam_header_and_data,
588 	[TEST_IN_BIT1]			= check_ioam_header_and_data,
589 	[TEST_IN_BIT2]			= check_ioam_header_and_data,
590 	[TEST_IN_BIT3]			= check_ioam_header_and_data,
591 	[TEST_IN_BIT4]			= check_ioam_header_and_data,
592 	[TEST_IN_BIT5]			= check_ioam_header_and_data,
593 	[TEST_IN_BIT6]			= check_ioam_header_and_data,
594 	[TEST_IN_BIT7]			= check_ioam_header_and_data,
595 	[TEST_IN_BIT8]			= check_ioam_header_and_data,
596 	[TEST_IN_BIT9]			= check_ioam_header_and_data,
597 	[TEST_IN_BIT10]		= check_ioam_header_and_data,
598 	[TEST_IN_BIT11]		= check_ioam_header_and_data,
599 	[TEST_IN_BIT22]		= check_ioam_header_and_data,
600 	[TEST_IN_FULL_SUPP_TRACE]	= check_ioam_header_and_data,
601 	[TEST_FWD_FULL_SUPP_TRACE]	= check_ioam_header_and_data,
602 };
603 
main(int argc,char ** argv)604 int main(int argc, char **argv)
605 {
606 	int fd, size, hoplen, tid, ret = 1;
607 	struct in6_addr src, dst;
608 	struct ioam6_hdr *opt;
609 	struct ipv6hdr *ip6h;
610 	__u8 buffer[400], *p;
611 	__u16 ioam_ns;
612 	__u32 tr_type;
613 
614 	if (argc != 7)
615 		goto out;
616 
617 	tid = str2id(argv[2]);
618 	if (tid < 0 || !func[tid])
619 		goto out;
620 
621 	if (inet_pton(AF_INET6, argv[3], &src) != 1 ||
622 	    inet_pton(AF_INET6, argv[4], &dst) != 1)
623 		goto out;
624 
625 	if (get_u32(&tr_type, argv[5], 16) ||
626 	    get_u16(&ioam_ns, argv[6], 0))
627 		goto out;
628 
629 	fd = socket(AF_PACKET, SOCK_DGRAM, __cpu_to_be16(ETH_P_IPV6));
630 	if (!fd)
631 		goto out;
632 
633 	if (setsockopt(fd, SOL_SOCKET, SO_BINDTODEVICE,
634 		       argv[1], strlen(argv[1])))
635 		goto close;
636 
637 recv:
638 	size = recv(fd, buffer, sizeof(buffer), 0);
639 	if (size <= 0)
640 		goto close;
641 
642 	ip6h = (struct ipv6hdr *)buffer;
643 
644 	if (!ipv6_addr_equal(&ip6h->saddr, &src) ||
645 	    !ipv6_addr_equal(&ip6h->daddr, &dst))
646 		goto recv;
647 
648 	if (ip6h->nexthdr != IPPROTO_HOPOPTS)
649 		goto close;
650 
651 	p = buffer + sizeof(*ip6h);
652 	hoplen = (p[1] + 1) << 3;
653 	p += sizeof(struct ipv6_hopopt_hdr);
654 
655 	while (hoplen > 0) {
656 		opt = (struct ioam6_hdr *)p;
657 
658 		if (opt->opt_type == IPV6_TLV_IOAM &&
659 		    opt->type == IOAM6_TYPE_PREALLOC) {
660 			p += sizeof(*opt);
661 			ret = func[tid](tid, (struct ioam6_trace_hdr *)p,
662 					   tr_type, ioam_ns);
663 			break;
664 		}
665 
666 		p += opt->opt_len + 2;
667 		hoplen -= opt->opt_len + 2;
668 	}
669 close:
670 	close(fd);
671 out:
672 	return ret;
673 }
674