]> 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
ip-route: Fix segfault with many nexthops
[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 <net/if.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 0x%X ", 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 parse_rtattr_nested(tb, SEG6_LOCAL_MAX, encap);
233
234 if (!tb[SEG6_LOCAL_ACTION])
235 return;
236
237 action = rta_getattr_u32(tb[SEG6_LOCAL_ACTION]);
238
239 print_string(PRINT_ANY, "action",
240 "action %s ", format_action_type(action));
241
242 if (tb[SEG6_LOCAL_SRH]) {
243 open_json_object("srh");
244 print_srh(fp, RTA_DATA(tb[SEG6_LOCAL_SRH]));
245 close_json_object();
246 }
247
248 if (tb[SEG6_LOCAL_TABLE])
249 print_uint(PRINT_ANY, "table",
250 "table %u ", rta_getattr_u32(tb[SEG6_LOCAL_TABLE]));
251
252 if (tb[SEG6_LOCAL_NH4]) {
253 print_string(PRINT_ANY, "nh4",
254 "nh4 %s ", rt_addr_n2a_rta(AF_INET, tb[SEG6_LOCAL_NH4]));
255 }
256
257 if (tb[SEG6_LOCAL_NH6]) {
258 print_string(PRINT_ANY, "nh6",
259 "nh6 %s ", rt_addr_n2a_rta(AF_INET6, tb[SEG6_LOCAL_NH6]));
260 }
261
262 if (tb[SEG6_LOCAL_IIF]) {
263 int iif = rta_getattr_u32(tb[SEG6_LOCAL_IIF]);
264
265 print_string(PRINT_ANY, "iif",
266 "iif %s ", ll_index_to_name(iif));
267 }
268
269 if (tb[SEG6_LOCAL_OIF]) {
270 int oif = rta_getattr_u32(tb[SEG6_LOCAL_OIF]);
271
272 print_string(PRINT_ANY, "oif",
273 "oif %s ", ll_index_to_name(oif));
274 }
275
276 if (tb[SEG6_LOCAL_BPF])
277 print_encap_bpf_prog(fp, tb[SEG6_LOCAL_BPF], "endpoint");
278 }
279
280 static void print_encap_mpls(FILE *fp, struct rtattr *encap)
281 {
282 struct rtattr *tb[MPLS_IPTUNNEL_MAX+1];
283
284 parse_rtattr_nested(tb, MPLS_IPTUNNEL_MAX, encap);
285
286 if (tb[MPLS_IPTUNNEL_DST])
287 print_string(PRINT_ANY, "dst", " %s ",
288 format_host_rta(AF_MPLS, tb[MPLS_IPTUNNEL_DST]));
289 if (tb[MPLS_IPTUNNEL_TTL])
290 print_uint(PRINT_ANY, "ttl", "ttl %u ",
291 rta_getattr_u8(tb[MPLS_IPTUNNEL_TTL]));
292 }
293
294 static void print_encap_ip(FILE *fp, struct rtattr *encap)
295 {
296 struct rtattr *tb[LWTUNNEL_IP_MAX+1];
297
298 parse_rtattr_nested(tb, LWTUNNEL_IP_MAX, encap);
299
300 if (tb[LWTUNNEL_IP_ID])
301 print_u64(PRINT_ANY, "id", "id %llu ",
302 ntohll(rta_getattr_u64(tb[LWTUNNEL_IP_ID])));
303
304 if (tb[LWTUNNEL_IP_SRC])
305 print_color_string(PRINT_ANY, COLOR_INET,
306 "src", "src %s ",
307 rt_addr_n2a_rta(AF_INET, tb[LWTUNNEL_IP_SRC]));
308
309 if (tb[LWTUNNEL_IP_DST])
310 print_color_string(PRINT_ANY, COLOR_INET,
311 "dst", "dst %s ",
312 rt_addr_n2a_rta(AF_INET, tb[LWTUNNEL_IP_DST]));
313
314 if (tb[LWTUNNEL_IP_TTL])
315 print_uint(PRINT_ANY, "ttl",
316 "ttl %u ", rta_getattr_u8(tb[LWTUNNEL_IP_TTL]));
317
318 if (tb[LWTUNNEL_IP_TOS])
319 print_uint(PRINT_ANY, "tos",
320 "tos %d ", rta_getattr_u8(tb[LWTUNNEL_IP_TOS]));
321 }
322
323 static void print_encap_ila(FILE *fp, struct rtattr *encap)
324 {
325 struct rtattr *tb[ILA_ATTR_MAX+1];
326
327 parse_rtattr_nested(tb, ILA_ATTR_MAX, encap);
328
329 if (tb[ILA_ATTR_LOCATOR]) {
330 char abuf[ADDR64_BUF_SIZE];
331
332 addr64_n2a(rta_getattr_u64(tb[ILA_ATTR_LOCATOR]),
333 abuf, sizeof(abuf));
334 print_string(PRINT_ANY, "locator",
335 " %s ", abuf);
336 }
337
338 if (tb[ILA_ATTR_CSUM_MODE])
339 print_string(PRINT_ANY, "csum_mode",
340 " csum-mode %s ",
341 ila_csum_mode2name(rta_getattr_u8(tb[ILA_ATTR_CSUM_MODE])));
342
343 if (tb[ILA_ATTR_IDENT_TYPE])
344 print_string(PRINT_ANY, "ident_type",
345 " ident-type %s ",
346 ila_ident_type2name(rta_getattr_u8(tb[ILA_ATTR_IDENT_TYPE])));
347
348 if (tb[ILA_ATTR_HOOK_TYPE])
349 print_string(PRINT_ANY, "hook_type",
350 " hook-type %s ",
351 ila_hook_type2name(rta_getattr_u8(tb[ILA_ATTR_HOOK_TYPE])));
352 }
353
354 static void print_encap_ip6(FILE *fp, struct rtattr *encap)
355 {
356 struct rtattr *tb[LWTUNNEL_IP6_MAX+1];
357
358 parse_rtattr_nested(tb, LWTUNNEL_IP6_MAX, encap);
359
360 if (tb[LWTUNNEL_IP6_ID])
361 print_u64(PRINT_ANY, "id", "id %llu ",
362 ntohll(rta_getattr_u64(tb[LWTUNNEL_IP6_ID])));
363
364 if (tb[LWTUNNEL_IP6_SRC])
365 print_color_string(PRINT_ANY, COLOR_INET6,
366 "src", "src %s ",
367 rt_addr_n2a_rta(AF_INET6, tb[LWTUNNEL_IP6_SRC]));
368
369 if (tb[LWTUNNEL_IP6_DST])
370 print_color_string(PRINT_ANY, COLOR_INET6,
371 "dst", "dst %s ",
372 rt_addr_n2a_rta(AF_INET6, tb[LWTUNNEL_IP6_DST]));
373
374 if (tb[LWTUNNEL_IP6_HOPLIMIT])
375 print_u64(PRINT_ANY, "hoplimit",
376 "hoplimit %u ",
377 rta_getattr_u8(tb[LWTUNNEL_IP6_HOPLIMIT]));
378
379 if (tb[LWTUNNEL_IP6_TC])
380 print_uint(PRINT_ANY, "tc",
381 "tc %u ", rta_getattr_u8(tb[LWTUNNEL_IP6_TC]));
382 }
383
384 static void print_encap_bpf(FILE *fp, struct rtattr *encap)
385 {
386 struct rtattr *tb[LWT_BPF_MAX+1];
387
388 parse_rtattr_nested(tb, LWT_BPF_MAX, encap);
389
390 if (tb[LWT_BPF_IN])
391 print_encap_bpf_prog(fp, tb[LWT_BPF_IN], "in");
392 if (tb[LWT_BPF_OUT])
393 print_encap_bpf_prog(fp, tb[LWT_BPF_OUT], "out");
394 if (tb[LWT_BPF_XMIT])
395 print_encap_bpf_prog(fp, tb[LWT_BPF_XMIT], "xmit");
396 if (tb[LWT_BPF_XMIT_HEADROOM])
397 print_uint(PRINT_ANY, "headroom",
398 " %u ", rta_getattr_u32(tb[LWT_BPF_XMIT_HEADROOM]));
399 }
400
401 void lwt_print_encap(FILE *fp, struct rtattr *encap_type,
402 struct rtattr *encap)
403 {
404 int et;
405
406 if (!encap_type)
407 return;
408
409 et = rta_getattr_u16(encap_type);
410
411 print_string(PRINT_ANY, "encap", " encap %s ", format_encap_type(et));
412
413 switch (et) {
414 case LWTUNNEL_ENCAP_MPLS:
415 print_encap_mpls(fp, encap);
416 break;
417 case LWTUNNEL_ENCAP_IP:
418 print_encap_ip(fp, encap);
419 break;
420 case LWTUNNEL_ENCAP_ILA:
421 print_encap_ila(fp, encap);
422 break;
423 case LWTUNNEL_ENCAP_IP6:
424 print_encap_ip6(fp, encap);
425 break;
426 case LWTUNNEL_ENCAP_BPF:
427 print_encap_bpf(fp, encap);
428 break;
429 case LWTUNNEL_ENCAP_SEG6:
430 print_encap_seg6(fp, encap);
431 break;
432 case LWTUNNEL_ENCAP_SEG6_LOCAL:
433 print_encap_seg6local(fp, encap);
434 break;
435 }
436 }
437
438 static struct ipv6_sr_hdr *parse_srh(char *segbuf, int hmac, bool encap)
439 {
440 struct ipv6_sr_hdr *srh;
441 int nsegs = 0;
442 int srhlen;
443 char *s;
444 int i;
445
446 s = segbuf;
447 for (i = 0; *s; *s++ == ',' ? i++ : *s);
448 nsegs = i + 1;
449
450 if (!encap)
451 nsegs++;
452
453 srhlen = 8 + 16*nsegs;
454
455 if (hmac)
456 srhlen += 40;
457
458 srh = malloc(srhlen);
459 memset(srh, 0, srhlen);
460
461 srh->hdrlen = (srhlen >> 3) - 1;
462 srh->type = 4;
463 srh->segments_left = nsegs - 1;
464 srh->first_segment = nsegs - 1;
465
466 if (hmac)
467 srh->flags |= SR6_FLAG1_HMAC;
468
469 i = srh->first_segment;
470 for (s = strtok(segbuf, ","); s; s = strtok(NULL, ",")) {
471 inet_prefix addr;
472
473 get_addr(&addr, s, AF_INET6);
474 memcpy(&srh->segments[i], addr.data, sizeof(struct in6_addr));
475 i--;
476 }
477
478 if (hmac) {
479 struct sr6_tlv_hmac *tlv;
480
481 tlv = (struct sr6_tlv_hmac *)((char *)srh + srhlen - 40);
482 tlv->tlvhdr.type = SR6_TLV_HMAC;
483 tlv->tlvhdr.len = 38;
484 tlv->hmackeyid = htonl(hmac);
485 }
486
487 return srh;
488 }
489
490 static int parse_encap_seg6(struct rtattr *rta, size_t len, int *argcp,
491 char ***argvp)
492 {
493 int mode_ok = 0, segs_ok = 0, hmac_ok = 0;
494 struct seg6_iptunnel_encap *tuninfo;
495 struct ipv6_sr_hdr *srh;
496 char **argv = *argvp;
497 char segbuf[1024];
498 int argc = *argcp;
499 int encap = -1;
500 __u32 hmac = 0;
501 int srhlen;
502
503 while (argc > 0) {
504 if (strcmp(*argv, "mode") == 0) {
505 NEXT_ARG();
506 if (mode_ok++)
507 duparg2("mode", *argv);
508 encap = read_seg6mode_type(*argv);
509 if (encap < 0)
510 invarg("\"mode\" value is invalid\n", *argv);
511 } else if (strcmp(*argv, "segs") == 0) {
512 NEXT_ARG();
513 if (segs_ok++)
514 duparg2("segs", *argv);
515 if (encap == -1)
516 invarg("\"segs\" provided before \"mode\"\n",
517 *argv);
518
519 strlcpy(segbuf, *argv, 1024);
520 } else if (strcmp(*argv, "hmac") == 0) {
521 NEXT_ARG();
522 if (hmac_ok++)
523 duparg2("hmac", *argv);
524 get_u32(&hmac, *argv, 0);
525 } else {
526 break;
527 }
528 argc--; argv++;
529 }
530
531 srh = parse_srh(segbuf, hmac, encap);
532 srhlen = (srh->hdrlen + 1) << 3;
533
534 tuninfo = malloc(sizeof(*tuninfo) + srhlen);
535 memset(tuninfo, 0, sizeof(*tuninfo) + srhlen);
536
537 tuninfo->mode = encap;
538
539 memcpy(tuninfo->srh, srh, srhlen);
540
541 if (rta_addattr_l(rta, len, SEG6_IPTUNNEL_SRH, tuninfo,
542 sizeof(*tuninfo) + srhlen))
543 return -1;
544
545 free(tuninfo);
546 free(srh);
547
548 *argcp = argc + 1;
549 *argvp = argv - 1;
550
551 return 0;
552 }
553
554 struct lwt_x {
555 struct rtattr *rta;
556 size_t len;
557 };
558
559 static void bpf_lwt_cb(void *lwt_ptr, int fd, const char *annotation)
560 {
561 struct lwt_x *x = lwt_ptr;
562
563 rta_addattr32(x->rta, x->len, LWT_BPF_PROG_FD, fd);
564 rta_addattr_l(x->rta, x->len, LWT_BPF_PROG_NAME, annotation,
565 strlen(annotation) + 1);
566 }
567
568 static const struct bpf_cfg_ops bpf_cb_ops = {
569 .ebpf_cb = bpf_lwt_cb,
570 };
571
572 static int lwt_parse_bpf(struct rtattr *rta, size_t len,
573 int *argcp, char ***argvp,
574 int attr, const enum bpf_prog_type bpf_type)
575 {
576 struct bpf_cfg_in cfg = {
577 .type = bpf_type,
578 .argc = *argcp,
579 .argv = *argvp,
580 };
581 struct lwt_x x = {
582 .rta = rta,
583 .len = len,
584 };
585 struct rtattr *nest;
586 int err;
587
588 nest = rta_nest(rta, len, attr);
589 err = bpf_parse_and_load_common(&cfg, &bpf_cb_ops, &x);
590 if (err < 0) {
591 fprintf(stderr, "Failed to parse eBPF program: %s\n",
592 strerror(-err));
593 return -1;
594 }
595 rta_nest_end(rta, nest);
596
597 *argcp = cfg.argc;
598 *argvp = cfg.argv;
599
600 return 0;
601 }
602
603 static int parse_encap_seg6local(struct rtattr *rta, size_t len, int *argcp,
604 char ***argvp)
605 {
606 int segs_ok = 0, hmac_ok = 0, table_ok = 0, nh4_ok = 0, nh6_ok = 0;
607 int iif_ok = 0, oif_ok = 0, action_ok = 0, srh_ok = 0, bpf_ok = 0;
608 __u32 action = 0, table, iif, oif;
609 struct ipv6_sr_hdr *srh;
610 char **argv = *argvp;
611 int argc = *argcp;
612 char segbuf[1024];
613 inet_prefix addr;
614 __u32 hmac = 0;
615 int ret = 0;
616
617 while (argc > 0) {
618 if (strcmp(*argv, "action") == 0) {
619 NEXT_ARG();
620 if (action_ok++)
621 duparg2("action", *argv);
622 action = read_action_type(*argv);
623 if (!action)
624 invarg("\"action\" value is invalid\n", *argv);
625 ret = rta_addattr32(rta, len, SEG6_LOCAL_ACTION,
626 action);
627 } else if (strcmp(*argv, "table") == 0) {
628 NEXT_ARG();
629 if (table_ok++)
630 duparg2("table", *argv);
631 get_u32(&table, *argv, 0);
632 ret = rta_addattr32(rta, len, SEG6_LOCAL_TABLE, table);
633 } else if (strcmp(*argv, "nh4") == 0) {
634 NEXT_ARG();
635 if (nh4_ok++)
636 duparg2("nh4", *argv);
637 get_addr(&addr, *argv, AF_INET);
638 ret = rta_addattr_l(rta, len, SEG6_LOCAL_NH4,
639 &addr.data, addr.bytelen);
640 } else if (strcmp(*argv, "nh6") == 0) {
641 NEXT_ARG();
642 if (nh6_ok++)
643 duparg2("nh6", *argv);
644 get_addr(&addr, *argv, AF_INET6);
645 ret = rta_addattr_l(rta, len, SEG6_LOCAL_NH6,
646 &addr.data, addr.bytelen);
647 } else if (strcmp(*argv, "iif") == 0) {
648 NEXT_ARG();
649 if (iif_ok++)
650 duparg2("iif", *argv);
651 iif = ll_name_to_index(*argv);
652 if (!iif)
653 exit(nodev(*argv));
654 ret = rta_addattr32(rta, len, SEG6_LOCAL_IIF, iif);
655 } else if (strcmp(*argv, "oif") == 0) {
656 NEXT_ARG();
657 if (oif_ok++)
658 duparg2("oif", *argv);
659 oif = ll_name_to_index(*argv);
660 if (!oif)
661 exit(nodev(*argv));
662 ret = rta_addattr32(rta, len, SEG6_LOCAL_OIF, oif);
663 } else if (strcmp(*argv, "srh") == 0) {
664 NEXT_ARG();
665 if (srh_ok++)
666 duparg2("srh", *argv);
667 if (strcmp(*argv, "segs") != 0)
668 invarg("missing \"segs\" attribute for srh\n",
669 *argv);
670 NEXT_ARG();
671 if (segs_ok++)
672 duparg2("segs", *argv);
673 strncpy(segbuf, *argv, 1024);
674 segbuf[1023] = 0;
675 if (!NEXT_ARG_OK())
676 break;
677 NEXT_ARG();
678 if (strcmp(*argv, "hmac") == 0) {
679 NEXT_ARG();
680 if (hmac_ok++)
681 duparg2("hmac", *argv);
682 get_u32(&hmac, *argv, 0);
683 } else {
684 continue;
685 }
686 } else if (strcmp(*argv, "endpoint") == 0) {
687 NEXT_ARG();
688 if (bpf_ok++)
689 duparg2("endpoint", *argv);
690
691 if (lwt_parse_bpf(rta, len, &argc, &argv, SEG6_LOCAL_BPF,
692 BPF_PROG_TYPE_LWT_SEG6LOCAL) < 0)
693 exit(-1);
694 } else {
695 break;
696 }
697 if (ret)
698 return ret;
699 argc--; argv++;
700 }
701
702 if (!action) {
703 fprintf(stderr, "Missing action type\n");
704 exit(-1);
705 }
706
707 if (srh_ok) {
708 int srhlen;
709
710 srh = parse_srh(segbuf, hmac,
711 action == SEG6_LOCAL_ACTION_END_B6_ENCAP);
712 srhlen = (srh->hdrlen + 1) << 3;
713 ret = rta_addattr_l(rta, len, SEG6_LOCAL_SRH, srh, srhlen);
714 free(srh);
715 }
716
717 *argcp = argc + 1;
718 *argvp = argv - 1;
719
720 return ret;
721 }
722
723 static int parse_encap_mpls(struct rtattr *rta, size_t len,
724 int *argcp, char ***argvp)
725 {
726 inet_prefix addr;
727 int argc = *argcp;
728 char **argv = *argvp;
729 int ttl_ok = 0;
730
731 if (get_addr(&addr, *argv, AF_MPLS)) {
732 fprintf(stderr,
733 "Error: an inet address is expected rather than \"%s\".\n",
734 *argv);
735 exit(1);
736 }
737
738 if (rta_addattr_l(rta, len, MPLS_IPTUNNEL_DST,
739 &addr.data, addr.bytelen))
740 return -1;
741
742 argc--;
743 argv++;
744
745 while (argc > 0) {
746 if (strcmp(*argv, "ttl") == 0) {
747 __u8 ttl;
748
749 NEXT_ARG();
750 if (ttl_ok++)
751 duparg2("ttl", *argv);
752 if (get_u8(&ttl, *argv, 0))
753 invarg("\"ttl\" value is invalid\n", *argv);
754 if (rta_addattr8(rta, len, MPLS_IPTUNNEL_TTL, ttl))
755 return -1;
756 } else {
757 break;
758 }
759 argc--; argv++;
760 }
761
762 /* argv is currently the first unparsed argument,
763 * but the lwt_parse_encap() caller will move to the next,
764 * so step back
765 */
766 *argcp = argc + 1;
767 *argvp = argv - 1;
768
769 return 0;
770 }
771
772 static int parse_encap_ip(struct rtattr *rta, size_t len,
773 int *argcp, char ***argvp)
774 {
775 int id_ok = 0, dst_ok = 0, tos_ok = 0, ttl_ok = 0;
776 char **argv = *argvp;
777 int argc = *argcp;
778 int ret = 0;
779
780 while (argc > 0) {
781 if (strcmp(*argv, "id") == 0) {
782 __u64 id;
783
784 NEXT_ARG();
785 if (id_ok++)
786 duparg2("id", *argv);
787 if (get_be64(&id, *argv, 0))
788 invarg("\"id\" value is invalid\n", *argv);
789 ret = rta_addattr64(rta, len, LWTUNNEL_IP_ID, id);
790 } else if (strcmp(*argv, "dst") == 0) {
791 inet_prefix addr;
792
793 NEXT_ARG();
794 if (dst_ok++)
795 duparg2("dst", *argv);
796 get_addr(&addr, *argv, AF_INET);
797 ret = rta_addattr_l(rta, len, LWTUNNEL_IP_DST,
798 &addr.data, addr.bytelen);
799 } else if (strcmp(*argv, "tos") == 0) {
800 __u32 tos;
801
802 NEXT_ARG();
803 if (tos_ok++)
804 duparg2("tos", *argv);
805 if (rtnl_dsfield_a2n(&tos, *argv))
806 invarg("\"tos\" value is invalid\n", *argv);
807 ret = rta_addattr8(rta, len, LWTUNNEL_IP_TOS, tos);
808 } else if (strcmp(*argv, "ttl") == 0) {
809 __u8 ttl;
810
811 NEXT_ARG();
812 if (ttl_ok++)
813 duparg2("ttl", *argv);
814 if (get_u8(&ttl, *argv, 0))
815 invarg("\"ttl\" value is invalid\n", *argv);
816 ret = rta_addattr8(rta, len, LWTUNNEL_IP_TTL, ttl);
817 } else {
818 break;
819 }
820 if (ret)
821 break;
822 argc--; argv++;
823 }
824
825 /* argv is currently the first unparsed argument,
826 * but the lwt_parse_encap() caller will move to the next,
827 * so step back
828 */
829 *argcp = argc + 1;
830 *argvp = argv - 1;
831
832 return ret;
833 }
834
835 static int parse_encap_ila(struct rtattr *rta, size_t len,
836 int *argcp, char ***argvp)
837 {
838 __u64 locator;
839 int argc = *argcp;
840 char **argv = *argvp;
841 int ret = 0;
842
843 if (get_addr64(&locator, *argv) < 0) {
844 fprintf(stderr, "Bad locator: %s\n", *argv);
845 exit(1);
846 }
847
848 argc--; argv++;
849
850 if (rta_addattr64(rta, 1024, ILA_ATTR_LOCATOR, locator))
851 return -1;
852
853 while (argc > 0) {
854 if (strcmp(*argv, "csum-mode") == 0) {
855 int csum_mode;
856
857 NEXT_ARG();
858
859 csum_mode = ila_csum_name2mode(*argv);
860 if (csum_mode < 0)
861 invarg("\"csum-mode\" value is invalid\n",
862 *argv);
863
864 ret = rta_addattr8(rta, 1024, ILA_ATTR_CSUM_MODE,
865 (__u8)csum_mode);
866
867 argc--; argv++;
868 } else if (strcmp(*argv, "ident-type") == 0) {
869 int ident_type;
870
871 NEXT_ARG();
872
873 ident_type = ila_ident_name2type(*argv);
874 if (ident_type < 0)
875 invarg("\"ident-type\" value is invalid\n",
876 *argv);
877
878 ret = rta_addattr8(rta, 1024, ILA_ATTR_IDENT_TYPE,
879 (__u8)ident_type);
880
881 argc--; argv++;
882 } else if (strcmp(*argv, "hook-type") == 0) {
883 int hook_type;
884
885 NEXT_ARG();
886
887 hook_type = ila_hook_name2type(*argv);
888 if (hook_type < 0)
889 invarg("\"hook-type\" value is invalid\n",
890 *argv);
891
892 ret = rta_addattr8(rta, 1024, ILA_ATTR_HOOK_TYPE,
893 (__u8)hook_type);
894
895 argc--; argv++;
896 } else {
897 break;
898 }
899 if (ret)
900 break;
901 }
902
903 /* argv is currently the first unparsed argument,
904 * but the lwt_parse_encap() caller will move to the next,
905 * so step back
906 */
907 *argcp = argc + 1;
908 *argvp = argv - 1;
909
910 return ret;
911 }
912
913 static int parse_encap_ip6(struct rtattr *rta, size_t len,
914 int *argcp, char ***argvp)
915 {
916 int id_ok = 0, dst_ok = 0, tos_ok = 0, ttl_ok = 0;
917 char **argv = *argvp;
918 int argc = *argcp;
919 int ret = 0;
920
921 while (argc > 0) {
922 if (strcmp(*argv, "id") == 0) {
923 __u64 id;
924
925 NEXT_ARG();
926 if (id_ok++)
927 duparg2("id", *argv);
928 if (get_be64(&id, *argv, 0))
929 invarg("\"id\" value is invalid\n", *argv);
930 ret = rta_addattr64(rta, len, LWTUNNEL_IP6_ID, id);
931 } else if (strcmp(*argv, "dst") == 0) {
932 inet_prefix addr;
933
934 NEXT_ARG();
935 if (dst_ok++)
936 duparg2("dst", *argv);
937 get_addr(&addr, *argv, AF_INET6);
938 ret = rta_addattr_l(rta, len, LWTUNNEL_IP6_DST,
939 &addr.data, addr.bytelen);
940 } else if (strcmp(*argv, "tc") == 0) {
941 __u32 tc;
942
943 NEXT_ARG();
944 if (tos_ok++)
945 duparg2("tc", *argv);
946 if (rtnl_dsfield_a2n(&tc, *argv))
947 invarg("\"tc\" value is invalid\n", *argv);
948 ret = rta_addattr8(rta, len, LWTUNNEL_IP6_TC, tc);
949 } else if (strcmp(*argv, "hoplimit") == 0) {
950 __u8 hoplimit;
951
952 NEXT_ARG();
953 if (ttl_ok++)
954 duparg2("hoplimit", *argv);
955 if (get_u8(&hoplimit, *argv, 0))
956 invarg("\"hoplimit\" value is invalid\n",
957 *argv);
958 ret = rta_addattr8(rta, len, LWTUNNEL_IP6_HOPLIMIT,
959 hoplimit);
960 } else {
961 break;
962 }
963 if (ret)
964 break;
965 argc--; argv++;
966 }
967
968 /* argv is currently the first unparsed argument,
969 * but the lwt_parse_encap() caller will move to the next,
970 * so step back
971 */
972 *argcp = argc + 1;
973 *argvp = argv - 1;
974
975 return ret;
976 }
977
978 static void lwt_bpf_usage(void)
979 {
980 fprintf(stderr, "Usage: ip route ... encap bpf [ in BPF ] [ out BPF ] [ xmit BPF ] [...]\n");
981 fprintf(stderr, "BPF := obj FILE [ section NAME ] [ verbose ]\n");
982 exit(-1);
983 }
984
985 static int parse_encap_bpf(struct rtattr *rta, size_t len, int *argcp,
986 char ***argvp)
987 {
988 char **argv = *argvp;
989 int argc = *argcp;
990 int headroom_set = 0;
991
992 while (argc > 0) {
993 if (strcmp(*argv, "in") == 0) {
994 NEXT_ARG();
995 if (lwt_parse_bpf(rta, len, &argc, &argv, LWT_BPF_IN,
996 BPF_PROG_TYPE_LWT_IN) < 0)
997 return -1;
998 } else if (strcmp(*argv, "out") == 0) {
999 NEXT_ARG();
1000 if (lwt_parse_bpf(rta, len, &argc, &argv, LWT_BPF_OUT,
1001 BPF_PROG_TYPE_LWT_OUT) < 0)
1002 return -1;
1003 } else if (strcmp(*argv, "xmit") == 0) {
1004 NEXT_ARG();
1005 if (lwt_parse_bpf(rta, len, &argc, &argv, LWT_BPF_XMIT,
1006 BPF_PROG_TYPE_LWT_XMIT) < 0)
1007 return -1;
1008 } else if (strcmp(*argv, "headroom") == 0) {
1009 unsigned int headroom;
1010
1011 NEXT_ARG();
1012 if (get_unsigned(&headroom, *argv, 0) || headroom == 0)
1013 invarg("headroom is invalid\n", *argv);
1014 if (!headroom_set)
1015 rta_addattr32(rta, 1024, LWT_BPF_XMIT_HEADROOM,
1016 headroom);
1017 headroom_set = 1;
1018 } else if (strcmp(*argv, "help") == 0) {
1019 lwt_bpf_usage();
1020 } else {
1021 break;
1022 }
1023 NEXT_ARG_FWD();
1024 }
1025
1026 /* argv is currently the first unparsed argument,
1027 * but the lwt_parse_encap() caller will move to the next,
1028 * so step back
1029 */
1030 *argcp = argc + 1;
1031 *argvp = argv - 1;
1032
1033 return 0;
1034 }
1035
1036 int lwt_parse_encap(struct rtattr *rta, size_t len, int *argcp, char ***argvp)
1037 {
1038 struct rtattr *nest;
1039 int argc = *argcp;
1040 char **argv = *argvp;
1041 __u16 type;
1042 int ret = 0;
1043
1044 NEXT_ARG();
1045 type = read_encap_type(*argv);
1046 if (!type)
1047 invarg("\"encap type\" value is invalid\n", *argv);
1048
1049 NEXT_ARG();
1050 if (argc <= 1) {
1051 fprintf(stderr,
1052 "Error: unexpected end of line after \"encap\"\n");
1053 exit(-1);
1054 }
1055
1056 nest = rta_nest(rta, 1024, RTA_ENCAP);
1057 switch (type) {
1058 case LWTUNNEL_ENCAP_MPLS:
1059 ret = parse_encap_mpls(rta, len, &argc, &argv);
1060 break;
1061 case LWTUNNEL_ENCAP_IP:
1062 ret = parse_encap_ip(rta, len, &argc, &argv);
1063 break;
1064 case LWTUNNEL_ENCAP_ILA:
1065 ret = parse_encap_ila(rta, len, &argc, &argv);
1066 break;
1067 case LWTUNNEL_ENCAP_IP6:
1068 ret = parse_encap_ip6(rta, len, &argc, &argv);
1069 break;
1070 case LWTUNNEL_ENCAP_BPF:
1071 if (parse_encap_bpf(rta, len, &argc, &argv) < 0)
1072 exit(-1);
1073 break;
1074 case LWTUNNEL_ENCAP_SEG6:
1075 ret = parse_encap_seg6(rta, len, &argc, &argv);
1076 break;
1077 case LWTUNNEL_ENCAP_SEG6_LOCAL:
1078 ret = parse_encap_seg6local(rta, len, &argc, &argv);
1079 break;
1080 default:
1081 fprintf(stderr, "Error: unsupported encap type\n");
1082 break;
1083 }
1084 if (ret)
1085 return ret;
1086
1087 rta_nest_end(rta, nest);
1088
1089 ret = rta_addattr16(rta, 1024, RTA_ENCAP_TYPE, type);
1090
1091 *argcp = argc;
1092 *argvp = argv;
1093
1094 return ret;
1095 }
Upstream mirror of iproute2