]> git.proxmox.com Git - mirror_iproute2.git/blob - ip/iproute_lwtunnel.c
projects / mirror_iproute2.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
add support for table name in SRv6 End.DT* behaviors
[mirror_iproute2.git] / ip / iproute_lwtunnel.c
1 /*
2 * iproute_lwtunnel.c
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation; either version
7 * 2 of the License, or (at your option) any later version.
8 *
9 * Authors: Roopa Prabhu, <roopa@cumulusnetworks.com>
10 * Thomas Graf <tgraf@suug.ch>
11 *
12 */
13
14 #include <stdio.h>
15 #include <stdlib.h>
16 #include <unistd.h>
17 #include <fcntl.h>
18 #include <string.h>
19 #include <linux/ila.h>
20 #include <linux/lwtunnel.h>
21 #include <linux/mpls_iptunnel.h>
22 #include <errno.h>
23
24 #include "rt_names.h"
25 #include "bpf_util.h"
26 #include "utils.h"
27 #include "ip_common.h"
28 #include "ila_common.h"
29
30 #include <linux/seg6.h>
31 #include <linux/seg6_iptunnel.h>
32 #include <linux/seg6_hmac.h>
33 #include <linux/seg6_local.h>
34 #include <linux/if_tunnel.h>
35
36 static const char *format_encap_type(int type)
37 {
38 switch (type) {
39 case LWTUNNEL_ENCAP_MPLS:
40 return "mpls";
41 case LWTUNNEL_ENCAP_IP:
42 return "ip";
43 case LWTUNNEL_ENCAP_IP6:
44 return "ip6";
45 case LWTUNNEL_ENCAP_ILA:
46 return "ila";
47 case LWTUNNEL_ENCAP_BPF:
48 return "bpf";
49 case LWTUNNEL_ENCAP_SEG6:
50 return "seg6";
51 case LWTUNNEL_ENCAP_SEG6_LOCAL:
52 return "seg6local";
53 default:
54 return "unknown";
55 }
56 }
57
58 static void encap_type_usage(void)
59 {
60 int i;
61
62 fprintf(stderr, "Usage: ip route ... encap TYPE [ OPTIONS ] [...]\n");
63
64 for (i = 1; i <= LWTUNNEL_ENCAP_MAX; i++)
65 fprintf(stderr, "%s %s\n", format_encap_type(i),
66 i == 1 ? "TYPE := " : " ");
67
68 exit(-1);
69 }
70
71 static int read_encap_type(const char *name)
72 {
73 if (strcmp(name, "mpls") == 0)
74 return LWTUNNEL_ENCAP_MPLS;
75 else if (strcmp(name, "ip") == 0)
76 return LWTUNNEL_ENCAP_IP;
77 else if (strcmp(name, "ip6") == 0)
78 return LWTUNNEL_ENCAP_IP6;
79 else if (strcmp(name, "ila") == 0)
80 return LWTUNNEL_ENCAP_ILA;
81 else if (strcmp(name, "bpf") == 0)
82 return LWTUNNEL_ENCAP_BPF;
83 else if (strcmp(name, "seg6") == 0)
84 return LWTUNNEL_ENCAP_SEG6;
85 else if (strcmp(name, "seg6local") == 0)
86 return LWTUNNEL_ENCAP_SEG6_LOCAL;
87 else if (strcmp(name, "help") == 0)
88 encap_type_usage();
89
90 return LWTUNNEL_ENCAP_NONE;
91 }
92
93 static void print_srh(FILE *fp, struct ipv6_sr_hdr *srh)
94 {
95 int i;
96
97 if (is_json_context())
98 open_json_array(PRINT_JSON, "segs");
99 else
100 fprintf(fp, "segs %d [ ", srh->first_segment + 1);
101
102 for (i = srh->first_segment; i >= 0; i--)
103 print_color_string(PRINT_ANY, COLOR_INET6,
104 NULL, "%s ",
105 rt_addr_n2a(AF_INET6, 16, &srh->segments[i]));
106
107 if (is_json_context())
108 close_json_array(PRINT_JSON, NULL);
109 else
110 fprintf(fp, "] ");
111
112 if (sr_has_hmac(srh)) {
113 unsigned int offset = ((srh->hdrlen + 1) << 3) - 40;
114 struct sr6_tlv_hmac *tlv;
115
116 tlv = (struct sr6_tlv_hmac *)((char *)srh + offset);
117 print_0xhex(PRINT_ANY, "hmac",
118 "hmac %llX ", ntohl(tlv->hmackeyid));
119 }
120 }
121
122 static const char *seg6_mode_types[] = {
123 [SEG6_IPTUN_MODE_INLINE] = "inline",
124 [SEG6_IPTUN_MODE_ENCAP] = "encap",
125 [SEG6_IPTUN_MODE_L2ENCAP] = "l2encap",
126 };
127
128 static const char *format_seg6mode_type(int mode)
129 {
130 if (mode < 0 || mode > ARRAY_SIZE(seg6_mode_types))
131 return "<unknown>";
132
133 return seg6_mode_types[mode];
134 }
135
136 static int read_seg6mode_type(const char *mode)
137 {
138 int i;
139
140 for (i = 0; i < ARRAY_SIZE(seg6_mode_types); i++) {
141 if (strcmp(mode, seg6_mode_types[i]) == 0)
142 return i;
143 }
144
145 return -1;
146 }
147
148 static void print_encap_seg6(FILE *fp, struct rtattr *encap)
149 {
150 struct rtattr *tb[SEG6_IPTUNNEL_MAX+1];
151 struct seg6_iptunnel_encap *tuninfo;
152
153 parse_rtattr_nested(tb, SEG6_IPTUNNEL_MAX, encap);
154
155 if (!tb[SEG6_IPTUNNEL_SRH])
156 return;
157
158 tuninfo = RTA_DATA(tb[SEG6_IPTUNNEL_SRH]);
159 print_string(PRINT_ANY, "mode",
160 "mode %s ", format_seg6mode_type(tuninfo->mode));
161
162 print_srh(fp, tuninfo->srh);
163 }
164
165 static const char *seg6_action_names[SEG6_LOCAL_ACTION_MAX + 1] = {
166 [SEG6_LOCAL_ACTION_END] = "End",
167 [SEG6_LOCAL_ACTION_END_X] = "End.X",
168 [SEG6_LOCAL_ACTION_END_T] = "End.T",
169 [SEG6_LOCAL_ACTION_END_DX2] = "End.DX2",
170 [SEG6_LOCAL_ACTION_END_DX6] = "End.DX6",
171 [SEG6_LOCAL_ACTION_END_DX4] = "End.DX4",
172 [SEG6_LOCAL_ACTION_END_DT6] = "End.DT6",
173 [SEG6_LOCAL_ACTION_END_DT4] = "End.DT4",
174 [SEG6_LOCAL_ACTION_END_B6] = "End.B6",
175 [SEG6_LOCAL_ACTION_END_B6_ENCAP] = "End.B6.Encaps",
176 [SEG6_LOCAL_ACTION_END_BM] = "End.BM",
177 [SEG6_LOCAL_ACTION_END_S] = "End.S",
178 [SEG6_LOCAL_ACTION_END_AS] = "End.AS",
179 [SEG6_LOCAL_ACTION_END_AM] = "End.AM",
180 [SEG6_LOCAL_ACTION_END_BPF] = "End.BPF",
181 };
182
183 static const char *format_action_type(int action)
184 {
185 if (action < 0 || action > SEG6_LOCAL_ACTION_MAX)
186 return "<invalid>";
187
188 return seg6_action_names[action] ?: "<unknown>";
189 }
190
191 static int read_action_type(const char *name)
192 {
193 int i;
194
195 for (i = 0; i < SEG6_LOCAL_ACTION_MAX + 1; i++) {
196 if (!seg6_action_names[i])
197 continue;
198
199 if (strcmp(seg6_action_names[i], name) == 0)
200 return i;
201 }
202
203 return SEG6_LOCAL_ACTION_UNSPEC;
204 }
205
206 static void print_encap_bpf_prog(FILE *fp, struct rtattr *encap,
207 const char *str)
208 {
209 struct rtattr *tb[LWT_BPF_PROG_MAX+1];
210 const char *progname = NULL;
211
212 parse_rtattr_nested(tb, LWT_BPF_PROG_MAX, encap);
213
214 if (tb[LWT_BPF_PROG_NAME])
215 progname = rta_getattr_str(tb[LWT_BPF_PROG_NAME]);
216
217 if (is_json_context())
218 print_string(PRINT_JSON, str, NULL,
219 progname ? : "<unknown>");
220 else {
221 fprintf(fp, "%s ", str);
222 if (progname)
223 fprintf(fp, "%s ", progname);
224 }
225 }
226
227 static void print_encap_seg6local(FILE *fp, struct rtattr *encap)
228 {
229 struct rtattr *tb[SEG6_LOCAL_MAX + 1];
230 int action;
231
232 SPRINT_BUF(b1);
233
234 parse_rtattr_nested(tb, SEG6_LOCAL_MAX, encap);
235
236 if (!tb[SEG6_LOCAL_ACTION])
237 return;
238
239 action = rta_getattr_u32(tb[SEG6_LOCAL_ACTION]);
240
241 print_string(PRINT_ANY, "action",
242 "action %s ", format_action_type(action));
243
244 if (tb[SEG6_LOCAL_SRH]) {
245 open_json_object("srh");
246 print_srh(fp, RTA_DATA(tb[SEG6_LOCAL_SRH]));
247 close_json_object();
248 }
249
250 if (tb[SEG6_LOCAL_TABLE])
251 print_string(PRINT_ANY, "table", "table %s ",
252 rtnl_rttable_n2a(rta_getattr_u32(tb[SEG6_LOCAL_TABLE]),
253 b1, sizeof(b1)));
254
255 if (tb[SEG6_LOCAL_NH4]) {
256 print_string(PRINT_ANY, "nh4",
257 "nh4 %s ", rt_addr_n2a_rta(AF_INET, tb[SEG6_LOCAL_NH4]));
258 }
259
260 if (tb[SEG6_LOCAL_NH6]) {
261 print_string(PRINT_ANY, "nh6",
262 "nh6 %s ", rt_addr_n2a_rta(AF_INET6, tb[SEG6_LOCAL_NH6]));
263 }
264
265 if (tb[SEG6_LOCAL_IIF]) {
266 int iif = rta_getattr_u32(tb[SEG6_LOCAL_IIF]);
267
268 print_string(PRINT_ANY, "iif",
269 "iif %s ", ll_index_to_name(iif));
270 }
271
272 if (tb[SEG6_LOCAL_OIF]) {
273 int oif = rta_getattr_u32(tb[SEG6_LOCAL_OIF]);
274
275 print_string(PRINT_ANY, "oif",
276 "oif %s ", ll_index_to_name(oif));
277 }
278
279 if (tb[SEG6_LOCAL_BPF])
280 print_encap_bpf_prog(fp, tb[SEG6_LOCAL_BPF], "endpoint");
281 }
282
283 static void print_encap_mpls(FILE *fp, struct rtattr *encap)
284 {
285 struct rtattr *tb[MPLS_IPTUNNEL_MAX+1];
286
287 parse_rtattr_nested(tb, MPLS_IPTUNNEL_MAX, encap);
288
289 if (tb[MPLS_IPTUNNEL_DST])
290 print_string(PRINT_ANY, "dst", " %s ",
291 format_host_rta(AF_MPLS, tb[MPLS_IPTUNNEL_DST]));
292 if (tb[MPLS_IPTUNNEL_TTL])
293 print_uint(PRINT_ANY, "ttl", "ttl %u ",
294 rta_getattr_u8(tb[MPLS_IPTUNNEL_TTL]));
295 }
296
297 static void print_encap_ip(FILE *fp, struct rtattr *encap)
298 {
299 struct rtattr *tb[LWTUNNEL_IP_MAX+1];
300 __u16 flags;
301
302 parse_rtattr_nested(tb, LWTUNNEL_IP_MAX, encap);
303
304 if (tb[LWTUNNEL_IP_ID])
305 print_u64(PRINT_ANY, "id", "id %llu ",
306 ntohll(rta_getattr_u64(tb[LWTUNNEL_IP_ID])));
307
308 if (tb[LWTUNNEL_IP_SRC])
309 print_color_string(PRINT_ANY, COLOR_INET,
310 "src", "src %s ",
311 rt_addr_n2a_rta(AF_INET, tb[LWTUNNEL_IP_SRC]));
312
313 if (tb[LWTUNNEL_IP_DST])
314 print_color_string(PRINT_ANY, COLOR_INET,
315 "dst", "dst %s ",
316 rt_addr_n2a_rta(AF_INET, tb[LWTUNNEL_IP_DST]));
317
318 if (tb[LWTUNNEL_IP_TTL])
319 print_uint(PRINT_ANY, "ttl",
320 "ttl %u ", rta_getattr_u8(tb[LWTUNNEL_IP_TTL]));
321
322 if (tb[LWTUNNEL_IP_TOS])
323 print_uint(PRINT_ANY, "tos",
324 "tos %d ", rta_getattr_u8(tb[LWTUNNEL_IP_TOS]));
325
326 if (tb[LWTUNNEL_IP_FLAGS]) {
327 flags = rta_getattr_u16(tb[LWTUNNEL_IP_FLAGS]);
328 if (flags & TUNNEL_KEY)
329 print_bool(PRINT_ANY, "key", "key ", true);
330 if (flags & TUNNEL_CSUM)
331 print_bool(PRINT_ANY, "csum", "csum ", true);
332 if (flags & TUNNEL_SEQ)
333 print_bool(PRINT_ANY, "seq", "seq ", true);
334 }
335 }
336
337 static void print_encap_ila(FILE *fp, struct rtattr *encap)
338 {
339 struct rtattr *tb[ILA_ATTR_MAX+1];
340
341 parse_rtattr_nested(tb, ILA_ATTR_MAX, encap);
342
343 if (tb[ILA_ATTR_LOCATOR]) {
344 char abuf[ADDR64_BUF_SIZE];
345
346 addr64_n2a(rta_getattr_u64(tb[ILA_ATTR_LOCATOR]),
347 abuf, sizeof(abuf));
348 print_string(PRINT_ANY, "locator",
349 " %s ", abuf);
350 }
351
352 if (tb[ILA_ATTR_CSUM_MODE])
353 print_string(PRINT_ANY, "csum_mode",
354 " csum-mode %s ",
355 ila_csum_mode2name(rta_getattr_u8(tb[ILA_ATTR_CSUM_MODE])));
356
357 if (tb[ILA_ATTR_IDENT_TYPE])
358 print_string(PRINT_ANY, "ident_type",
359 " ident-type %s ",
360 ila_ident_type2name(rta_getattr_u8(tb[ILA_ATTR_IDENT_TYPE])));
361
362 if (tb[ILA_ATTR_HOOK_TYPE])
363 print_string(PRINT_ANY, "hook_type",
364 " hook-type %s ",
365 ila_hook_type2name(rta_getattr_u8(tb[ILA_ATTR_HOOK_TYPE])));
366 }
367
368 static void print_encap_ip6(FILE *fp, struct rtattr *encap)
369 {
370 struct rtattr *tb[LWTUNNEL_IP6_MAX+1];
371 __u16 flags;
372
373 parse_rtattr_nested(tb, LWTUNNEL_IP6_MAX, encap);
374
375 if (tb[LWTUNNEL_IP6_ID])
376 print_u64(PRINT_ANY, "id", "id %llu ",
377 ntohll(rta_getattr_u64(tb[LWTUNNEL_IP6_ID])));
378
379 if (tb[LWTUNNEL_IP6_SRC])
380 print_color_string(PRINT_ANY, COLOR_INET6,
381 "src", "src %s ",
382 rt_addr_n2a_rta(AF_INET6, tb[LWTUNNEL_IP6_SRC]));
383
384 if (tb[LWTUNNEL_IP6_DST])
385 print_color_string(PRINT_ANY, COLOR_INET6,
386 "dst", "dst %s ",
387 rt_addr_n2a_rta(AF_INET6, tb[LWTUNNEL_IP6_DST]));
388
389 if (tb[LWTUNNEL_IP6_HOPLIMIT])
390 print_u64(PRINT_ANY, "hoplimit",
391 "hoplimit %u ",
392 rta_getattr_u8(tb[LWTUNNEL_IP6_HOPLIMIT]));
393
394 if (tb[LWTUNNEL_IP6_TC])
395 print_uint(PRINT_ANY, "tc",
396 "tc %u ", rta_getattr_u8(tb[LWTUNNEL_IP6_TC]));
397
398 if (tb[LWTUNNEL_IP6_FLAGS]) {
399 flags = rta_getattr_u16(tb[LWTUNNEL_IP6_FLAGS]);
400 if (flags & TUNNEL_KEY)
401 print_bool(PRINT_ANY, "key", "key ", true);
402 if (flags & TUNNEL_CSUM)
403 print_bool(PRINT_ANY, "csum", "csum ", true);
404 if (flags & TUNNEL_SEQ)
405 print_bool(PRINT_ANY, "seq", "seq ", true);
406 }
407 }
408
409 static void print_encap_bpf(FILE *fp, struct rtattr *encap)
410 {
411 struct rtattr *tb[LWT_BPF_MAX+1];
412
413 parse_rtattr_nested(tb, LWT_BPF_MAX, encap);
414
415 if (tb[LWT_BPF_IN])
416 print_encap_bpf_prog(fp, tb[LWT_BPF_IN], "in");
417 if (tb[LWT_BPF_OUT])
418 print_encap_bpf_prog(fp, tb[LWT_BPF_OUT], "out");
419 if (tb[LWT_BPF_XMIT])
420 print_encap_bpf_prog(fp, tb[LWT_BPF_XMIT], "xmit");
421 if (tb[LWT_BPF_XMIT_HEADROOM])
422 print_uint(PRINT_ANY, "headroom",
423 " %u ", rta_getattr_u32(tb[LWT_BPF_XMIT_HEADROOM]));
424 }
425
426 void lwt_print_encap(FILE *fp, struct rtattr *encap_type,
427 struct rtattr *encap)
428 {
429 int et;
430
431 if (!encap_type)
432 return;
433
434 et = rta_getattr_u16(encap_type);
435
436 print_string(PRINT_ANY, "encap", " encap %s ", format_encap_type(et));
437
438 switch (et) {
439 case LWTUNNEL_ENCAP_MPLS:
440 print_encap_mpls(fp, encap);
441 break;
442 case LWTUNNEL_ENCAP_IP:
443 print_encap_ip(fp, encap);
444 break;
445 case LWTUNNEL_ENCAP_ILA:
446 print_encap_ila(fp, encap);
447 break;
448 case LWTUNNEL_ENCAP_IP6:
449 print_encap_ip6(fp, encap);
450 break;
451 case LWTUNNEL_ENCAP_BPF:
452 print_encap_bpf(fp, encap);
453 break;
454 case LWTUNNEL_ENCAP_SEG6:
455 print_encap_seg6(fp, encap);
456 break;
457 case LWTUNNEL_ENCAP_SEG6_LOCAL:
458 print_encap_seg6local(fp, encap);
459 break;
460 }
461 }
462
463 static struct ipv6_sr_hdr *parse_srh(char *segbuf, int hmac, bool encap)
464 {
465 struct ipv6_sr_hdr *srh;
466 int nsegs = 0;
467 int srhlen;
468 char *s;
469 int i;
470
471 s = segbuf;
472 for (i = 0; *s; *s++ == ',' ? i++ : *s);
473 nsegs = i + 1;
474
475 if (!encap)
476 nsegs++;
477
478 srhlen = 8 + 16*nsegs;
479
480 if (hmac)
481 srhlen += 40;
482
483 srh = malloc(srhlen);
484 memset(srh, 0, srhlen);
485
486 srh->hdrlen = (srhlen >> 3) - 1;
487 srh->type = 4;
488 srh->segments_left = nsegs - 1;
489 srh->first_segment = nsegs - 1;
490
491 if (hmac)
492 srh->flags |= SR6_FLAG1_HMAC;
493
494 i = srh->first_segment;
495 for (s = strtok(segbuf, ","); s; s = strtok(NULL, ",")) {
496 inet_prefix addr;
497
498 get_addr(&addr, s, AF_INET6);
499 memcpy(&srh->segments[i], addr.data, sizeof(struct in6_addr));
500 i--;
501 }
502
503 if (hmac) {
504 struct sr6_tlv_hmac *tlv;
505
506 tlv = (struct sr6_tlv_hmac *)((char *)srh + srhlen - 40);
507 tlv->tlvhdr.type = SR6_TLV_HMAC;
508 tlv->tlvhdr.len = 38;
509 tlv->hmackeyid = htonl(hmac);
510 }
511
512 return srh;
513 }
514
515 static int parse_encap_seg6(struct rtattr *rta, size_t len, int *argcp,
516 char ***argvp)
517 {
518 int mode_ok = 0, segs_ok = 0, hmac_ok = 0;
519 struct seg6_iptunnel_encap *tuninfo;
520 struct ipv6_sr_hdr *srh;
521 char **argv = *argvp;
522 char segbuf[1024] = "";
523 int argc = *argcp;
524 int encap = -1;
525 __u32 hmac = 0;
526 int ret = 0;
527 int srhlen;
528
529 while (argc > 0) {
530 if (strcmp(*argv, "mode") == 0) {
531 NEXT_ARG();
532 if (mode_ok++)
533 duparg2("mode", *argv);
534 encap = read_seg6mode_type(*argv);
535 if (encap < 0)
536 invarg("\"mode\" value is invalid\n", *argv);
537 } else if (strcmp(*argv, "segs") == 0) {
538 NEXT_ARG();
539 if (segs_ok++)
540 duparg2("segs", *argv);
541 if (encap == -1)
542 invarg("\"segs\" provided before \"mode\"\n",
543 *argv);
544
545 strlcpy(segbuf, *argv, 1024);
546 } else if (strcmp(*argv, "hmac") == 0) {
547 NEXT_ARG();
548 if (hmac_ok++)
549 duparg2("hmac", *argv);
550 get_u32(&hmac, *argv, 0);
551 } else {
552 break;
553 }
554 argc--; argv++;
555 }
556
557 srh = parse_srh(segbuf, hmac, encap);
558 srhlen = (srh->hdrlen + 1) << 3;
559
560 tuninfo = malloc(sizeof(*tuninfo) + srhlen);
561 memset(tuninfo, 0, sizeof(*tuninfo) + srhlen);
562
563 tuninfo->mode = encap;
564
565 memcpy(tuninfo->srh, srh, srhlen);
566
567 if (rta_addattr_l(rta, len, SEG6_IPTUNNEL_SRH, tuninfo,
568 sizeof(*tuninfo) + srhlen)) {
569 ret = -1;
570 goto out;
571 }
572
573 *argcp = argc + 1;
574 *argvp = argv - 1;
575
576 out:
577 free(tuninfo);
578 free(srh);
579
580 return ret;
581 }
582
583 struct lwt_x {
584 struct rtattr *rta;
585 size_t len;
586 };
587
588 static void bpf_lwt_cb(void *lwt_ptr, int fd, const char *annotation)
589 {
590 struct lwt_x *x = lwt_ptr;
591
592 rta_addattr32(x->rta, x->len, LWT_BPF_PROG_FD, fd);
593 rta_addattr_l(x->rta, x->len, LWT_BPF_PROG_NAME, annotation,
594 strlen(annotation) + 1);
595 }
596
597 static const struct bpf_cfg_ops bpf_cb_ops = {
598 .ebpf_cb = bpf_lwt_cb,
599 };
600
601 static int lwt_parse_bpf(struct rtattr *rta, size_t len,
602 int *argcp, char ***argvp,
603 int attr, const enum bpf_prog_type bpf_type)
604 {
605 struct bpf_cfg_in cfg = {
606 .type = bpf_type,
607 .argc = *argcp,
608 .argv = *argvp,
609 };
610 struct lwt_x x = {
611 .rta = rta,
612 .len = len,
613 };
614 struct rtattr *nest;
615 int err;
616
617 nest = rta_nest(rta, len, attr);
618 err = bpf_parse_and_load_common(&cfg, &bpf_cb_ops, &x);
619 if (err < 0) {
620 fprintf(stderr, "Failed to parse eBPF program: %s\n",
621 strerror(-err));
622 return -1;
623 }
624 rta_nest_end(rta, nest);
625
626 *argcp = cfg.argc;
627 *argvp = cfg.argv;
628
629 return 0;
630 }
631
632 static int parse_encap_seg6local(struct rtattr *rta, size_t len, int *argcp,
633 char ***argvp)
634 {
635 int segs_ok = 0, hmac_ok = 0, table_ok = 0, nh4_ok = 0, nh6_ok = 0;
636 int iif_ok = 0, oif_ok = 0, action_ok = 0, srh_ok = 0, bpf_ok = 0;
637 __u32 action = 0, table, iif, oif;
638 struct ipv6_sr_hdr *srh;
639 char **argv = *argvp;
640 int argc = *argcp;
641 char segbuf[1024];
642 inet_prefix addr;
643 __u32 hmac = 0;
644 int ret = 0;
645
646 while (argc > 0) {
647 if (strcmp(*argv, "action") == 0) {
648 NEXT_ARG();
649 if (action_ok++)
650 duparg2("action", *argv);
651 action = read_action_type(*argv);
652 if (!action)
653 invarg("\"action\" value is invalid\n", *argv);
654 ret = rta_addattr32(rta, len, SEG6_LOCAL_ACTION,
655 action);
656 } else if (strcmp(*argv, "table") == 0) {
657 NEXT_ARG();
658 if (table_ok++)
659 duparg2("table", *argv);
660 rtnl_rttable_a2n(&table, *argv);
661 ret = rta_addattr32(rta, len, SEG6_LOCAL_TABLE, table);
662 } else if (strcmp(*argv, "nh4") == 0) {
663 NEXT_ARG();
664 if (nh4_ok++)
665 duparg2("nh4", *argv);
666 get_addr(&addr, *argv, AF_INET);
667 ret = rta_addattr_l(rta, len, SEG6_LOCAL_NH4,
668 &addr.data, addr.bytelen);
669 } else if (strcmp(*argv, "nh6") == 0) {
670 NEXT_ARG();
671 if (nh6_ok++)
672 duparg2("nh6", *argv);
673 get_addr(&addr, *argv, AF_INET6);
674 ret = rta_addattr_l(rta, len, SEG6_LOCAL_NH6,
675 &addr.data, addr.bytelen);
676 } else if (strcmp(*argv, "iif") == 0) {
677 NEXT_ARG();
678 if (iif_ok++)
679 duparg2("iif", *argv);
680 iif = ll_name_to_index(*argv);
681 if (!iif)
682 exit(nodev(*argv));
683 ret = rta_addattr32(rta, len, SEG6_LOCAL_IIF, iif);
684 } else if (strcmp(*argv, "oif") == 0) {
685 NEXT_ARG();
686 if (oif_ok++)
687 duparg2("oif", *argv);
688 oif = ll_name_to_index(*argv);
689 if (!oif)
690 exit(nodev(*argv));
691 ret = rta_addattr32(rta, len, SEG6_LOCAL_OIF, oif);
692 } else if (strcmp(*argv, "srh") == 0) {
693 NEXT_ARG();
694 if (srh_ok++)
695 duparg2("srh", *argv);
696 if (strcmp(*argv, "segs") != 0)
697 invarg("missing \"segs\" attribute for srh\n",
698 *argv);
699 NEXT_ARG();
700 if (segs_ok++)
701 duparg2("segs", *argv);
702 strncpy(segbuf, *argv, 1024);
703 segbuf[1023] = 0;
704 if (!NEXT_ARG_OK())
705 break;
706 NEXT_ARG();
707 if (strcmp(*argv, "hmac") == 0) {
708 NEXT_ARG();
709 if (hmac_ok++)
710 duparg2("hmac", *argv);
711 get_u32(&hmac, *argv, 0);
712 } else {
713 continue;
714 }
715 } else if (strcmp(*argv, "endpoint") == 0) {
716 NEXT_ARG();
717 if (bpf_ok++)
718 duparg2("endpoint", *argv);
719
720 if (lwt_parse_bpf(rta, len, &argc, &argv, SEG6_LOCAL_BPF,
721 BPF_PROG_TYPE_LWT_SEG6LOCAL) < 0)
722 exit(-1);
723 } else {
724 break;
725 }
726 if (ret)
727 return ret;
728 argc--; argv++;
729 }
730
731 if (!action) {
732 fprintf(stderr, "Missing action type\n");
733 exit(-1);
734 }
735
736 if (srh_ok) {
737 int srhlen;
738
739 srh = parse_srh(segbuf, hmac,
740 action == SEG6_LOCAL_ACTION_END_B6_ENCAP);
741 srhlen = (srh->hdrlen + 1) << 3;
742 ret = rta_addattr_l(rta, len, SEG6_LOCAL_SRH, srh, srhlen);
743 free(srh);
744 }
745
746 *argcp = argc + 1;
747 *argvp = argv - 1;
748
749 return ret;
750 }
751
752 static int parse_encap_mpls(struct rtattr *rta, size_t len,
753 int *argcp, char ***argvp)
754 {
755 inet_prefix addr;
756 int argc = *argcp;
757 char **argv = *argvp;
758 int ttl_ok = 0;
759
760 if (get_addr(&addr, *argv, AF_MPLS)) {
761 fprintf(stderr,
762 "Error: an inet address is expected rather than \"%s\".\n",
763 *argv);
764 exit(1);
765 }
766
767 if (rta_addattr_l(rta, len, MPLS_IPTUNNEL_DST,
768 &addr.data, addr.bytelen))
769 return -1;
770
771 argc--;
772 argv++;
773
774 while (argc > 0) {
775 if (strcmp(*argv, "ttl") == 0) {
776 __u8 ttl;
777
778 NEXT_ARG();
779 if (ttl_ok++)
780 duparg2("ttl", *argv);
781 if (get_u8(&ttl, *argv, 0))
782 invarg("\"ttl\" value is invalid\n", *argv);
783 if (rta_addattr8(rta, len, MPLS_IPTUNNEL_TTL, ttl))
784 return -1;
785 } else {
786 break;
787 }
788 argc--; argv++;
789 }
790
791 /* argv is currently the first unparsed argument,
792 * but the lwt_parse_encap() caller will move to the next,
793 * so step back
794 */
795 *argcp = argc + 1;
796 *argvp = argv - 1;
797
798 return 0;
799 }
800
801 static int parse_encap_ip(struct rtattr *rta, size_t len,
802 int *argcp, char ***argvp)
803 {
804 int id_ok = 0, dst_ok = 0, src_ok = 0, tos_ok = 0, ttl_ok = 0;
805 int key_ok = 0, csum_ok = 0, seq_ok = 0;
806 char **argv = *argvp;
807 int argc = *argcp;
808 int ret = 0;
809 __u16 flags = 0;
810
811 while (argc > 0) {
812 if (strcmp(*argv, "id") == 0) {
813 __u64 id;
814
815 NEXT_ARG();
816 if (id_ok++)
817 duparg2("id", *argv);
818 if (get_be64(&id, *argv, 0))
819 invarg("\"id\" value is invalid\n", *argv);
820 ret = rta_addattr64(rta, len, LWTUNNEL_IP_ID, id);
821 } else if (strcmp(*argv, "dst") == 0) {
822 inet_prefix addr;
823
824 NEXT_ARG();
825 if (dst_ok++)
826 duparg2("dst", *argv);
827 get_addr(&addr, *argv, AF_INET);
828 ret = rta_addattr_l(rta, len, LWTUNNEL_IP_DST,
829 &addr.data, addr.bytelen);
830 } else if (strcmp(*argv, "src") == 0) {
831 inet_prefix addr;
832
833 NEXT_ARG();
834 if (src_ok++)
835 duparg2("src", *argv);
836 get_addr(&addr, *argv, AF_INET);
837 ret = rta_addattr_l(rta, len, LWTUNNEL_IP_SRC,
838 &addr.data, addr.bytelen);
839 } else if (strcmp(*argv, "tos") == 0) {
840 __u32 tos;
841
842 NEXT_ARG();
843 if (tos_ok++)
844 duparg2("tos", *argv);
845 if (rtnl_dsfield_a2n(&tos, *argv))
846 invarg("\"tos\" value is invalid\n", *argv);
847 ret = rta_addattr8(rta, len, LWTUNNEL_IP_TOS, tos);
848 } else if (strcmp(*argv, "ttl") == 0) {
849 __u8 ttl;
850
851 NEXT_ARG();
852 if (ttl_ok++)
853 duparg2("ttl", *argv);
854 if (get_u8(&ttl, *argv, 0))
855 invarg("\"ttl\" value is invalid\n", *argv);
856 ret = rta_addattr8(rta, len, LWTUNNEL_IP_TTL, ttl);
857 } else if (strcmp(*argv, "key") == 0) {
858 if (key_ok++)
859 duparg2("key", *argv);
860 flags |= TUNNEL_KEY;
861 } else if (strcmp(*argv, "csum") == 0) {
862 if (csum_ok++)
863 duparg2("csum", *argv);
864 flags |= TUNNEL_CSUM;
865 } else if (strcmp(*argv, "seq") == 0) {
866 if (seq_ok++)
867 duparg2("seq", *argv);
868 flags |= TUNNEL_SEQ;
869 } else {
870 break;
871 }
872 if (ret)
873 break;
874 argc--; argv++;
875 }
876
877 if (flags)
878 ret = rta_addattr16(rta, len, LWTUNNEL_IP_FLAGS, flags);
879
880 /* argv is currently the first unparsed argument,
881 * but the lwt_parse_encap() caller will move to the next,
882 * so step back
883 */
884 *argcp = argc + 1;
885 *argvp = argv - 1;
886
887 return ret;
888 }
889
890 static int parse_encap_ila(struct rtattr *rta, size_t len,
891 int *argcp, char ***argvp)
892 {
893 __u64 locator;
894 int argc = *argcp;
895 char **argv = *argvp;
896 int ret = 0;
897
898 if (get_addr64(&locator, *argv) < 0) {
899 fprintf(stderr, "Bad locator: %s\n", *argv);
900 exit(1);
901 }
902
903 argc--; argv++;
904
905 if (rta_addattr64(rta, len, ILA_ATTR_LOCATOR, locator))
906 return -1;
907
908 while (argc > 0) {
909 if (strcmp(*argv, "csum-mode") == 0) {
910 int csum_mode;
911
912 NEXT_ARG();
913
914 csum_mode = ila_csum_name2mode(*argv);
915 if (csum_mode < 0)
916 invarg("\"csum-mode\" value is invalid\n",
917 *argv);
918
919 ret = rta_addattr8(rta, len, ILA_ATTR_CSUM_MODE,
920 (__u8)csum_mode);
921
922 argc--; argv++;
923 } else if (strcmp(*argv, "ident-type") == 0) {
924 int ident_type;
925
926 NEXT_ARG();
927
928 ident_type = ila_ident_name2type(*argv);
929 if (ident_type < 0)
930 invarg("\"ident-type\" value is invalid\n",
931 *argv);
932
933 ret = rta_addattr8(rta, len, ILA_ATTR_IDENT_TYPE,
934 (__u8)ident_type);
935
936 argc--; argv++;
937 } else if (strcmp(*argv, "hook-type") == 0) {
938 int hook_type;
939
940 NEXT_ARG();
941
942 hook_type = ila_hook_name2type(*argv);
943 if (hook_type < 0)
944 invarg("\"hook-type\" value is invalid\n",
945 *argv);
946
947 ret = rta_addattr8(rta, len, ILA_ATTR_HOOK_TYPE,
948 (__u8)hook_type);
949
950 argc--; argv++;
951 } else {
952 break;
953 }
954 if (ret)
955 break;
956 }
957
958 /* argv is currently the first unparsed argument,
959 * but the lwt_parse_encap() caller will move to the next,
960 * so step back
961 */
962 *argcp = argc + 1;
963 *argvp = argv - 1;
964
965 return ret;
966 }
967
968 static int parse_encap_ip6(struct rtattr *rta, size_t len,
969 int *argcp, char ***argvp)
970 {
971 int id_ok = 0, dst_ok = 0, src_ok = 0, tos_ok = 0, ttl_ok = 0;
972 int key_ok = 0, csum_ok = 0, seq_ok = 0;
973 char **argv = *argvp;
974 int argc = *argcp;
975 int ret = 0;
976 __u16 flags = 0;
977
978 while (argc > 0) {
979 if (strcmp(*argv, "id") == 0) {
980 __u64 id;
981
982 NEXT_ARG();
983 if (id_ok++)
984 duparg2("id", *argv);
985 if (get_be64(&id, *argv, 0))
986 invarg("\"id\" value is invalid\n", *argv);
987 ret = rta_addattr64(rta, len, LWTUNNEL_IP6_ID, id);
988 } else if (strcmp(*argv, "dst") == 0) {
989 inet_prefix addr;
990
991 NEXT_ARG();
992 if (dst_ok++)
993 duparg2("dst", *argv);
994 get_addr(&addr, *argv, AF_INET6);
995 ret = rta_addattr_l(rta, len, LWTUNNEL_IP6_DST,
996 &addr.data, addr.bytelen);
997 } else if (strcmp(*argv, "src") == 0) {
998 inet_prefix addr;
999
1000 NEXT_ARG();
1001 if (src_ok++)
1002 duparg2("src", *argv);
1003 get_addr(&addr, *argv, AF_INET6);
1004 ret = rta_addattr_l(rta, len, LWTUNNEL_IP6_SRC,
1005 &addr.data, addr.bytelen);
1006 } else if (strcmp(*argv, "tc") == 0) {
1007 __u32 tc;
1008
1009 NEXT_ARG();
1010 if (tos_ok++)
1011 duparg2("tc", *argv);
1012 if (rtnl_dsfield_a2n(&tc, *argv))
1013 invarg("\"tc\" value is invalid\n", *argv);
1014 ret = rta_addattr8(rta, len, LWTUNNEL_IP6_TC, tc);
1015 } else if (strcmp(*argv, "hoplimit") == 0) {
1016 __u8 hoplimit;
1017
1018 NEXT_ARG();
1019 if (ttl_ok++)
1020 duparg2("hoplimit", *argv);
1021 if (get_u8(&hoplimit, *argv, 0))
1022 invarg("\"hoplimit\" value is invalid\n",
1023 *argv);
1024 ret = rta_addattr8(rta, len, LWTUNNEL_IP6_HOPLIMIT,
1025 hoplimit);
1026 } else if (strcmp(*argv, "key") == 0) {
1027 if (key_ok++)
1028 duparg2("key", *argv);
1029 flags |= TUNNEL_KEY;
1030 } else if (strcmp(*argv, "csum") == 0) {
1031 if (csum_ok++)
1032 duparg2("csum", *argv);
1033 flags |= TUNNEL_CSUM;
1034 } else if (strcmp(*argv, "seq") == 0) {
1035 if (seq_ok++)
1036 duparg2("seq", *argv);
1037 flags |= TUNNEL_SEQ;
1038 } else {
1039 break;
1040 }
1041 if (ret)
1042 break;
1043 argc--; argv++;
1044 }
1045
1046 if (flags)
1047 ret = rta_addattr16(rta, len, LWTUNNEL_IP6_FLAGS, flags);
1048
1049 /* argv is currently the first unparsed argument,
1050 * but the lwt_parse_encap() caller will move to the next,
1051 * so step back
1052 */
1053 *argcp = argc + 1;
1054 *argvp = argv - 1;
1055
1056 return ret;
1057 }
1058
1059 static void lwt_bpf_usage(void)
1060 {
1061 fprintf(stderr, "Usage: ip route ... encap bpf [ in BPF ] [ out BPF ] [ xmit BPF ] [...]\n");
1062 fprintf(stderr, "BPF := obj FILE [ section NAME ] [ verbose ]\n");
1063 exit(-1);
1064 }
1065
1066 static int parse_encap_bpf(struct rtattr *rta, size_t len, int *argcp,
1067 char ***argvp)
1068 {
1069 char **argv = *argvp;
1070 int argc = *argcp;
1071 int headroom_set = 0;
1072
1073 while (argc > 0) {
1074 if (strcmp(*argv, "in") == 0) {
1075 NEXT_ARG();
1076 if (lwt_parse_bpf(rta, len, &argc, &argv, LWT_BPF_IN,
1077 BPF_PROG_TYPE_LWT_IN) < 0)
1078 return -1;
1079 } else if (strcmp(*argv, "out") == 0) {
1080 NEXT_ARG();
1081 if (lwt_parse_bpf(rta, len, &argc, &argv, LWT_BPF_OUT,
1082 BPF_PROG_TYPE_LWT_OUT) < 0)
1083 return -1;
1084 } else if (strcmp(*argv, "xmit") == 0) {
1085 NEXT_ARG();
1086 if (lwt_parse_bpf(rta, len, &argc, &argv, LWT_BPF_XMIT,
1087 BPF_PROG_TYPE_LWT_XMIT) < 0)
1088 return -1;
1089 } else if (strcmp(*argv, "headroom") == 0) {
1090 unsigned int headroom;
1091
1092 NEXT_ARG();
1093 if (get_unsigned(&headroom, *argv, 0) || headroom == 0)
1094 invarg("headroom is invalid\n", *argv);
1095 if (!headroom_set)
1096 rta_addattr32(rta, len, LWT_BPF_XMIT_HEADROOM,
1097 headroom);
1098 headroom_set = 1;
1099 } else if (strcmp(*argv, "help") == 0) {
1100 lwt_bpf_usage();
1101 } else {
1102 break;
1103 }
1104 NEXT_ARG_FWD();
1105 }
1106
1107 /* argv is currently the first unparsed argument,
1108 * but the lwt_parse_encap() caller will move to the next,
1109 * so step back
1110 */
1111 *argcp = argc + 1;
1112 *argvp = argv - 1;
1113
1114 return 0;
1115 }
1116
1117 int lwt_parse_encap(struct rtattr *rta, size_t len, int *argcp, char ***argvp,
1118 int encap_attr, int encap_type_attr)
1119 {
1120 struct rtattr *nest;
1121 int argc = *argcp;
1122 char **argv = *argvp;
1123 __u16 type;
1124 int ret = 0;
1125
1126 NEXT_ARG();
1127 type = read_encap_type(*argv);
1128 if (!type)
1129 invarg("\"encap type\" value is invalid\n", *argv);
1130
1131 NEXT_ARG();
1132 if (argc <= 1) {
1133 fprintf(stderr,
1134 "Error: unexpected end of line after \"encap\"\n");
1135 exit(-1);
1136 }
1137
1138 nest = rta_nest(rta, len, encap_attr);
1139 switch (type) {
1140 case LWTUNNEL_ENCAP_MPLS:
1141 ret = parse_encap_mpls(rta, len, &argc, &argv);
1142 break;
1143 case LWTUNNEL_ENCAP_IP:
1144 ret = parse_encap_ip(rta, len, &argc, &argv);
1145 break;
1146 case LWTUNNEL_ENCAP_ILA:
1147 ret = parse_encap_ila(rta, len, &argc, &argv);
1148 break;
1149 case LWTUNNEL_ENCAP_IP6:
1150 ret = parse_encap_ip6(rta, len, &argc, &argv);
1151 break;
1152 case LWTUNNEL_ENCAP_BPF:
1153 if (parse_encap_bpf(rta, len, &argc, &argv) < 0)
1154 exit(-1);
1155 break;
1156 case LWTUNNEL_ENCAP_SEG6:
1157 ret = parse_encap_seg6(rta, len, &argc, &argv);
1158 break;
1159 case LWTUNNEL_ENCAP_SEG6_LOCAL:
1160 ret = parse_encap_seg6local(rta, len, &argc, &argv);
1161 break;
1162 default:
1163 fprintf(stderr, "Error: unsupported encap type\n");
1164 break;
1165 }
1166 if (ret)
1167 return ret;
1168
1169 rta_nest_end(rta, nest);
1170
1171 ret = rta_addattr16(rta, len, encap_type_attr, type);
1172
1173 *argcp = argc;
1174 *argvp = argv;
1175
1176 return ret;
1177 }
Upstream mirror of iproute2