]> git.proxmox.com Git - mirror_frr.git/blame - sharpd/sharp_vty.c
projects / mirror_frr.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
lib: Add CSPF Path Computation algorithm
[mirror_frr.git] / sharpd / sharp_vty.c
CommitLineData
8a71d93d
DS		 1/*
2 * SHARP - vty code
3 * Copyright (C) Cumulus Networks, Inc.
4 * Donald Sharp
5 *
6 * This file is part of FRR.
7 *
8 * FRR is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by the
10 * Free Software Foundation; either version 2, or (at your option) any
11 * later version.
12 *
13 * FRR is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License along
19 * with this program; see the file COPYING; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
21 */
22#include <zebra.h>
23
24#include "vty.h"
25#include "command.h"
26#include "prefix.h"
27#include "nexthop.h"
28#include "log.h"
ab18a495
DS		 29#include "vrf.h"
30#include "zclient.h"
694b242f 31#include "nexthop_group.h"
1888e243 32#include "link_state.h"
8a71d93d 33
547dc642 34#include "sharpd/sharp_globals.h"
8a71d93d 35#include "sharpd/sharp_zebra.h"
86da53ab 36#include "sharpd/sharp_nht.h"
8a71d93d 37#include "sharpd/sharp_vty.h"
2e4c2296 38#ifndef VTYSH_EXTRACT_PL
8a71d93d 39#include "sharpd/sharp_vty_clippy.c"
2e4c2296 40#endif
8a71d93d 41
ade3eebc
HS		 42DEFINE_MTYPE_STATIC(SHARPD, SRV6_LOCATOR, "SRv6 Locator");
43
921af54d
DS		 44DEFPY(watch_redistribute, watch_redistribute_cmd,
45 "sharp watch [vrf NAME$vrf_name] redistribute " FRR_REDIST_STR_SHARPD,
46 "Sharp routing Protocol\n"
47 "Watch for changes\n"
48 "The vrf we would like to watch if non-default\n"
49 "The NAME of the vrf\n"
50 "Redistribute into Sharp\n"
51 FRR_REDIST_HELP_STR_SHARPD)
52{
53 struct vrf *vrf;
54 int source;
55
56 if (!vrf_name)
57 vrf_name = VRF_DEFAULT_NAME;
58 vrf = vrf_lookup_by_name(vrf_name);
59 if (!vrf) {
60 vty_out(vty, "The vrf NAME specified: %s does not exist\n",
61 vrf_name);
62 return CMD_WARNING;
63 }
64
65 source = proto_redistnum(AFI_IP, argv[argc-1]->text);
66 sharp_redistribute_vrf(vrf, source);
67
68 return CMD_SUCCESS;
69}
70
0ae8130d 71DEFPY(watch_nexthop_v6, watch_nexthop_v6_cmd,
e429a2a0 72 "sharp watch [vrf NAME$vrf_name] <nexthop$n X:X::X:X$nhop|import$import X:X::X:X/M$inhop> [connected$connected]",
0ae8130d
DS		 73 "Sharp routing Protocol\n"
74 "Watch for changes\n"
a3b6aa82
DS		 75 "The vrf we would like to watch if non-default\n"
76 "The NAME of the vrf\n"
0ae8130d 77 "Watch for nexthop changes\n"
a60ffbc9 78 "The v6 nexthop to signal for watching\n"
1be0815d
DS		 79 "Watch for import check changes\n"
80 "The v6 prefix to signal for watching\n"
a60ffbc9 81 "Should the route be connected\n")
0ae8130d 82{
a3b6aa82 83 struct vrf *vrf;
0ae8130d 84 struct prefix p;
80d5ff33
DS		 85 bool type_import;
86
e429a2a0
IR		 87 if (!vrf_name)
88 vrf_name = VRF_DEFAULT_NAME;
89 vrf = vrf_lookup_by_name(vrf_name);
a3b6aa82
DS		 90 if (!vrf) {
91 vty_out(vty, "The vrf NAME specified: %s does not exist\n",
e429a2a0 92 vrf_name);
a3b6aa82
DS		 93 return CMD_WARNING;
94 }
80d5ff33 95
0ae8130d
DS		 96 memset(&p, 0, sizeof(p));
97
1be0815d
DS		 98 if (n) {
99 type_import = false;
13ccce6e 100 p.prefixlen = IPV6_MAX_BITLEN;
8643c2e5 101 memcpy(&p.u.prefix6, &nhop, IPV6_MAX_BYTELEN);
1be0815d
DS		 102 p.family = AF_INET6;
103 } else {
104 type_import = true;
105 p = *(const struct prefix *)inhop;
106 }
0ae8130d 107
86da53ab 108 sharp_nh_tracker_get(&p);
a3b6aa82 109 sharp_zebra_nexthop_watch(&p, vrf->vrf_id, type_import,
91529dc8 110 true, !!connected);
0ae8130d
DS		 111
112 return CMD_SUCCESS;
113}
114
115DEFPY(watch_nexthop_v4, watch_nexthop_v4_cmd,
e429a2a0 116 "sharp watch [vrf NAME$vrf_name] <nexthop$n A.B.C.D$nhop|import$import A.B.C.D/M$inhop> [connected$connected]",
0ae8130d
DS		 117 "Sharp routing Protocol\n"
118 "Watch for changes\n"
a3b6aa82
DS		 119 "The vrf we would like to watch if non-default\n"
120 "The NAME of the vrf\n"
0ae8130d 121 "Watch for nexthop changes\n"
1be0815d 122 "The v4 address to signal for watching\n"
80d5ff33 123 "Watch for import check changes\n"
1be0815d 124 "The v4 prefix for import check to watch\n"
a60ffbc9 125 "Should the route be connected\n")
0ae8130d 126{
a3b6aa82 127 struct vrf *vrf;
0ae8130d 128 struct prefix p;
80d5ff33 129 bool type_import;
0ae8130d 130
e429a2a0
IR		 131 if (!vrf_name)
132 vrf_name = VRF_DEFAULT_NAME;
133 vrf = vrf_lookup_by_name(vrf_name);
a3b6aa82
DS		 134 if (!vrf) {
135 vty_out(vty, "The vrf NAME specified: %s does not exist\n",
e429a2a0 136 vrf_name);
a3b6aa82
DS		 137 return CMD_WARNING;
138 }
139
0ae8130d
DS		 140 memset(&p, 0, sizeof(p));
141
1be0815d 142 if (n) {
80d5ff33 143 type_import = false;
12256b84 144 p.prefixlen = IPV4_MAX_BITLEN;
1be0815d
DS		 145 p.u.prefix4 = nhop;
146 p.family = AF_INET;
147 }
148 else {
80d5ff33 149 type_import = true;
1be0815d
DS		 150 p = *(const struct prefix *)inhop;
151 }
0ae8130d 152
86da53ab 153 sharp_nh_tracker_get(&p);
a3b6aa82 154 sharp_zebra_nexthop_watch(&p, vrf->vrf_id, type_import,
91529dc8 155 true, !!connected);
0ae8130d
DS		 156
157 return CMD_SUCCESS;
158}
159
86da53ab
DS		 160DEFPY(sharp_nht_data_dump,
161 sharp_nht_data_dump_cmd,
162 "sharp data nexthop",
163 "Sharp routing Protocol\n"
bcc519dc
DS		 164 "Data about what is going on\n"
165 "Nexthop information\n")
86da53ab
DS		 166{
167 sharp_nh_tracker_dump(vty);
168
169 return CMD_SUCCESS;
170}
171
f59e6418
DS		 172DEFPY (install_routes_data_dump,
173 install_routes_data_dump_cmd,
174 "sharp data route",
175 "Sharp routing Protocol\n"
176 "Data about what is going on\n"
177 "Route Install/Removal Information\n")
178{
f59e6418
DS		 179 struct timeval r;
180
181 timersub(&sg.r.t_end, &sg.r.t_start, &r);
2dbe669b
DA		 182 vty_out(vty, "Prefix: %pFX Total: %u %u %u Time: %jd.%ld\n",
183 &sg.r.orig_prefix, sg.r.total_routes, sg.r.installed_routes,
184 sg.r.removed_routes, (intmax_t)r.tv_sec, (long)r.tv_usec);
f59e6418
DS		 185
186 return CMD_SUCCESS;
187}
188
8a71d93d
DS		 189DEFPY (install_routes,
190 install_routes_cmd,
1df3b1dc
MS		 191 "sharp install routes [vrf NAME$vrf_name]\
192 <A.B.C.D$start4|X:X::X:X$start6>\
193 <nexthop <A.B.C.D$nexthop4|X:X::X:X$nexthop6>|\
1cb131ee 194 nexthop-group NHGNAME$nexthop_group>\
1df3b1dc 195 [backup$backup <A.B.C.D$backup_nexthop4|X:X::X:X$backup_nexthop6>] \
cfa2a35d 196 (1-1000000)$routes [instance (0-255)$instance] [repeat (2-1000)$rpt] [opaque WORD]",
75239f4f 197 "Sharp routing Protocol\n"
8a71d93d
DS		 198 "install some routes\n"
199 "Routes to install\n"
4a7d4737
DS		 200 "The vrf we would like to install into if non-default\n"
201 "The NAME of the vrf\n"
dbc1bf46
DS		 202 "v4 Address to start /32 generation at\n"
203 "v6 Address to start /32 generation at\n"
ba041bea
DS		 204 "Nexthop to use(Can be an IPv4 or IPv6 address)\n"
205 "V4 Nexthop address to use\n"
206 "V6 Nexthop address to use\n"
d4101c0a
DS		 207 "Nexthop-Group to use\n"
208 "The Name of the nexthop-group\n"
1df3b1dc
MS		 209 "Backup nexthop to use(Can be an IPv4 or IPv6 address)\n"
210 "Backup V4 Nexthop address to use\n"
211 "Backup V6 Nexthop address to use\n"
ae252c02
DS		 212 "How many to create\n"
213 "Instance to use\n"
b939f6ff
DS		 214 "Instance\n"
215 "Should we repeat this command\n"
cfa2a35d
DS		 216 "How many times to repeat this command\n"
217 "What opaque data to send down\n"
218 "The opaque data\n")
8a71d93d 219{
4a7d4737 220 struct vrf *vrf;
547dc642
DS		 221 struct prefix prefix;
222 uint32_t rts;
569e87c0 223 uint32_t nhgid = 0;
547dc642
DS		 224
225 sg.r.total_routes = routes;
226 sg.r.installed_routes = 0;
8a71d93d 227
b939f6ff 228 if (rpt >= 2)
547dc642 229 sg.r.repeat = rpt * 2;
b939f6ff 230 else
547dc642 231 sg.r.repeat = 0;
b939f6ff
DS		 232
233 memset(&prefix, 0, sizeof(prefix));
547dc642
DS		 234 memset(&sg.r.orig_prefix, 0, sizeof(sg.r.orig_prefix));
235 memset(&sg.r.nhop, 0, sizeof(sg.r.nhop));
236 memset(&sg.r.nhop_group, 0, sizeof(sg.r.nhop_group));
1df3b1dc
MS		 237 memset(&sg.r.backup_nhop, 0, sizeof(sg.r.nhop));
238 memset(&sg.r.backup_nhop_group, 0, sizeof(sg.r.nhop_group));
8a71d93d 239
3a6290bd 240 if (start4.s_addr != INADDR_ANY) {
dbc1bf46 241 prefix.family = AF_INET;
12256b84 242 prefix.prefixlen = IPV4_MAX_BITLEN;
dbc1bf46
DS		 243 prefix.u.prefix4 = start4;
244 } else {
245 prefix.family = AF_INET6;
13ccce6e 246 prefix.prefixlen = IPV6_MAX_BITLEN;
dbc1bf46
DS		 247 prefix.u.prefix6 = start6;
248 }
547dc642 249 sg.r.orig_prefix = prefix;
8a71d93d 250
e429a2a0
IR		 251 if (!vrf_name)
252 vrf_name = VRF_DEFAULT_NAME;
a3b6aa82 253
e429a2a0 254 vrf = vrf_lookup_by_name(vrf_name);
4a7d4737
DS		 255 if (!vrf) {
256 vty_out(vty, "The vrf NAME specified: %s does not exist\n",
e429a2a0 257 vrf_name);
4a7d4737
DS		 258 return CMD_WARNING;
259 }
260
1df3b1dc
MS		 261 /* Explicit backup not available with named nexthop-group */
262 if (backup && nexthop_group) {
263 vty_out(vty, "%% Invalid: cannot specify both nexthop-group and backup\n");
264 return CMD_WARNING;
265 }
266
d4101c0a
DS		 267 if (nexthop_group) {
268 struct nexthop_group_cmd *nhgc = nhgc_find(nexthop_group);
269 if (!nhgc) {
270 vty_out(vty,
271 "Specified Nexthop Group: %s does not exist\n",
272 nexthop_group);
273 return CMD_WARNING;
274 }
275
569e87c0
DS		 276 nhgid = sharp_nhgroup_get_id(nexthop_group);
277 sg.r.nhgid = nhgid;
547dc642 278 sg.r.nhop_group.nexthop = nhgc->nhg.nexthop;
1df3b1dc
MS		 279
280 /* Use group's backup nexthop info if present */
281 if (nhgc->backup_list_name[0]) {
282 struct nexthop_group_cmd *bnhgc =
283 nhgc_find(nhgc->backup_list_name);
284
285 if (!bnhgc) {
286 vty_out(vty, "%% Backup group %s not found for group %s\n",
287 nhgc->backup_list_name,
288 nhgc->name);
289 return CMD_WARNING;
290 }
291
292 sg.r.backup_nhop.vrf_id = vrf->vrf_id;
293 sg.r.backup_nhop_group.nexthop = bnhgc->nhg.nexthop;
294 }
ba041bea 295 } else {
d4101c0a 296 if (nexthop4.s_addr != INADDR_ANY) {
547dc642
DS		 297 sg.r.nhop.gate.ipv4 = nexthop4;
298 sg.r.nhop.type = NEXTHOP_TYPE_IPV4;
d4101c0a 299 } else {
547dc642
DS		 300 sg.r.nhop.gate.ipv6 = nexthop6;
301 sg.r.nhop.type = NEXTHOP_TYPE_IPV6;
d4101c0a
DS		 302 }
303
4a7d4737 304 sg.r.nhop.vrf_id = vrf->vrf_id;
547dc642 305 sg.r.nhop_group.nexthop = &sg.r.nhop;
ba041bea 306 }
8a71d93d 307
1df3b1dc
MS		 308 /* Use single backup nexthop if specified */
309 if (backup) {
310 /* Set flag and index in primary nexthop */
311 SET_FLAG(sg.r.nhop.flags, NEXTHOP_FLAG_HAS_BACKUP);
474aebd9
MS		 312 sg.r.nhop.backup_num = 1;
313 sg.r.nhop.backup_idx[0] = 0;
1df3b1dc
MS		 314
315 if (backup_nexthop4.s_addr != INADDR_ANY) {
316 sg.r.backup_nhop.gate.ipv4 = backup_nexthop4;
317 sg.r.backup_nhop.type = NEXTHOP_TYPE_IPV4;
318 } else {
319 sg.r.backup_nhop.gate.ipv6 = backup_nexthop6;
320 sg.r.backup_nhop.type = NEXTHOP_TYPE_IPV6;
321 }
322
323 sg.r.backup_nhop.vrf_id = vrf->vrf_id;
324 sg.r.backup_nhop_group.nexthop = &sg.r.backup_nhop;
325 }
326
cfa2a35d
DS		 327 if (opaque)
328 strlcpy(sg.r.opaque, opaque, ZAPI_MESSAGE_OPAQUE_LENGTH);
329 else
330 sg.r.opaque[0] = '\0';
331
547dc642 332 sg.r.inst = instance;
4a7d4737 333 sg.r.vrf_id = vrf->vrf_id;
b939f6ff 334 rts = routes;
ff9aca4f
SW		 335 sharp_install_routes_helper(&prefix, sg.r.vrf_id, sg.r.inst, nhgid,
336 &sg.r.nhop_group, &sg.r.backup_nhop_group,
1cb131ee
HS		 337 rts, 0, sg.r.opaque);
338
339 return CMD_SUCCESS;
340}
341
342DEFPY (install_seg6_routes,
343 install_seg6_routes_cmd,
344 "sharp install seg6-routes [vrf NAME$vrf_name]\
345 <A.B.C.D$start4|X:X::X:X$start6>\
346 nexthop-seg6 X:X::X:X$seg6_nh6 encap X:X::X:X$seg6_seg\
347 (1-1000000)$routes [repeat (2-1000)$rpt]",
348 "Sharp routing Protocol\n"
349 "install some routes\n"
350 "Routes to install\n"
351 "The vrf we would like to install into if non-default\n"
352 "The NAME of the vrf\n"
353 "v4 Address to start /32 generation at\n"
354 "v6 Address to start /32 generation at\n"
355 "Nexthop-seg6 to use\n"
356 "V6 Nexthop address to use\n"
357 "Encap mode\n"
358 "Segment List to use\n"
359 "How many to create\n"
360 "Should we repeat this command\n"
361 "How many times to repeat this command\n")
362{
363 struct vrf *vrf;
364 struct prefix prefix;
365 uint32_t route_flags = 0;
366
367 sg.r.total_routes = routes;
368 sg.r.installed_routes = 0;
369
370 if (rpt >= 2)
371 sg.r.repeat = rpt * 2;
372 else
373 sg.r.repeat = 0;
374
375 memset(&prefix, 0, sizeof(prefix));
376 memset(&sg.r.orig_prefix, 0, sizeof(sg.r.orig_prefix));
377 memset(&sg.r.nhop, 0, sizeof(sg.r.nhop));
378 memset(&sg.r.nhop_group, 0, sizeof(sg.r.nhop_group));
379 memset(&sg.r.backup_nhop, 0, sizeof(sg.r.nhop));
380 memset(&sg.r.backup_nhop_group, 0, sizeof(sg.r.nhop_group));
381 sg.r.opaque[0] = '\0';
382 sg.r.inst = 0;
383
384 if (start4.s_addr != INADDR_ANY) {
385 prefix.family = AF_INET;
12256b84 386 prefix.prefixlen = IPV4_MAX_BITLEN;
1cb131ee
HS		 387 prefix.u.prefix4 = start4;
388 } else {
389 prefix.family = AF_INET6;
13ccce6e 390 prefix.prefixlen = IPV6_MAX_BITLEN;
1cb131ee
HS		 391 prefix.u.prefix6 = start6;
392 }
393 sg.r.orig_prefix = prefix;
394
395 if (!vrf_name)
396 vrf_name = VRF_DEFAULT_NAME;
397
398 vrf = vrf_lookup_by_name(vrf_name);
399 if (!vrf) {
400 vty_out(vty, "The vrf NAME specified: %s does not exist\n",
401 vrf_name);
402 return CMD_WARNING;
403 }
404
405 sg.r.nhop.type = NEXTHOP_TYPE_IPV6;
406 sg.r.nhop.gate.ipv6 = seg6_nh6;
407 sg.r.nhop.vrf_id = vrf->vrf_id;
408 sg.r.nhop_group.nexthop = &sg.r.nhop;
eab0f8f0 409 nexthop_add_srv6_seg6(&sg.r.nhop, &seg6_seg);
1cb131ee
HS		 410
411 sg.r.vrf_id = vrf->vrf_id;
412 sharp_install_routes_helper(&prefix, sg.r.vrf_id, sg.r.inst, 0,
413 &sg.r.nhop_group, &sg.r.backup_nhop_group,
414 routes, route_flags, sg.r.opaque);
415
416 return CMD_SUCCESS;
417}
418
419DEFPY (install_seg6local_routes,
420 install_seg6local_routes_cmd,
421 "sharp install seg6local-routes [vrf NAME$vrf_name]\
422 X:X::X:X$start6\
423 nexthop-seg6local NAME$seg6l_oif\
424 <End$seg6l_end|\
425 End_X$seg6l_endx X:X::X:X$seg6l_endx_nh6|\
426 End_T$seg6l_endt (1-4294967295)$seg6l_endt_table|\
427 End_DX4$seg6l_enddx4 A.B.C.D$seg6l_enddx4_nh4|\
428 End_DT6$seg6l_enddt6 (1-4294967295)$seg6l_enddt6_table>\
429 (1-1000000)$routes [repeat (2-1000)$rpt]",
430 "Sharp routing Protocol\n"
431 "install some routes\n"
432 "Routes to install\n"
433 "The vrf we would like to install into if non-default\n"
434 "The NAME of the vrf\n"
435 "v6 Address to start /32 generation at\n"
436 "Nexthop-seg6local to use\n"
437 "Output device to use\n"
438 "SRv6 End function to use\n"
439 "SRv6 End.X function to use\n"
440 "V6 Nexthop address to use\n"
441 "SRv6 End.T function to use\n"
442 "Redirect table id to use\n"
443 "SRv6 End.DX4 function to use\n"
444 "V4 Nexthop address to use\n"
445 "SRv6 End.DT6 function to use\n"
446 "Redirect table id to use\n"
447 "How many to create\n"
448 "Should we repeat this command\n"
449 "How many times to repeat this command\n")
450{
451 struct vrf *vrf;
452 uint32_t route_flags = 0;
453 struct seg6local_context ctx = {};
454 enum seg6local_action_t action;
455
456 sg.r.total_routes = routes;
457 sg.r.installed_routes = 0;
458
459 if (rpt >= 2)
460 sg.r.repeat = rpt * 2;
461 else
462 sg.r.repeat = 0;
463
464 memset(&sg.r.orig_prefix, 0, sizeof(sg.r.orig_prefix));
465 memset(&sg.r.nhop, 0, sizeof(sg.r.nhop));
466 memset(&sg.r.nhop_group, 0, sizeof(sg.r.nhop_group));
467 memset(&sg.r.backup_nhop, 0, sizeof(sg.r.nhop));
468 memset(&sg.r.backup_nhop_group, 0, sizeof(sg.r.nhop_group));
469 sg.r.opaque[0] = '\0';
470 sg.r.inst = 0;
471 sg.r.orig_prefix.family = AF_INET6;
472 sg.r.orig_prefix.prefixlen = 128;
473 sg.r.orig_prefix.u.prefix6 = start6;
474
475 if (!vrf_name)
476 vrf_name = VRF_DEFAULT_NAME;
477
478 vrf = vrf_lookup_by_name(vrf_name);
479 if (!vrf) {
480 vty_out(vty, "The vrf NAME specified: %s does not exist\n",
481 vrf_name);
482 return CMD_WARNING;
483 }
484
485 if (seg6l_enddx4) {
486 action = ZEBRA_SEG6_LOCAL_ACTION_END_DX4;
487 ctx.nh4 = seg6l_enddx4_nh4;
488 } else if (seg6l_endx) {
489 action = ZEBRA_SEG6_LOCAL_ACTION_END_X;
490 ctx.nh6 = seg6l_endx_nh6;
491 } else if (seg6l_endt) {
492 action = ZEBRA_SEG6_LOCAL_ACTION_END_T;
493 ctx.table = seg6l_endt_table;
494 } else if (seg6l_enddt6) {
495 action = ZEBRA_SEG6_LOCAL_ACTION_END_DT6;
496 ctx.table = seg6l_enddt6_table;
497 } else {
498 action = ZEBRA_SEG6_LOCAL_ACTION_END;
499 }
500
501 sg.r.nhop.type = NEXTHOP_TYPE_IFINDEX;
502 sg.r.nhop.ifindex = ifname2ifindex(seg6l_oif, vrf->vrf_id);
503 sg.r.nhop.vrf_id = vrf->vrf_id;
504 sg.r.nhop_group.nexthop = &sg.r.nhop;
eab0f8f0 505 nexthop_add_srv6_seg6local(&sg.r.nhop, action, &ctx);
1cb131ee
HS		 506
507 sg.r.vrf_id = vrf->vrf_id;
2ba6be5b
HS		 508 sharp_install_routes_helper(&sg.r.orig_prefix, sg.r.vrf_id, sg.r.inst,
509 0, &sg.r.nhop_group,
510 &sg.r.backup_nhop_group, routes,
511 route_flags, sg.r.opaque);
8a71d93d
DS		 512
513 return CMD_SUCCESS;
514}
515
42567e00 516DEFPY(vrf_label, vrf_label_cmd,
e429a2a0 517 "sharp label <ip$ipv4|ipv6$ipv6> vrf NAME$vrf_name label (0-100000)$label",
75239f4f 518 "Sharp Routing Protocol\n"
ab18a495 519 "Give a vrf a label\n"
7d061b3c
DS		 520 "Pop and forward for IPv4\n"
521 "Pop and forward for IPv6\n"
ab18a495 522 VRF_CMD_HELP_STR
42567e00 523 "The label to use, 0 specifies remove the label installed from previous\n"
ab18a495
DS		 524 "Specified range to use\n")
525{
526 struct vrf *vrf;
7d061b3c 527 afi_t afi = (ipv4) ? AFI_IP : AFI_IP6;
ab18a495 528
e429a2a0 529 if (strcmp(vrf_name, "default") == 0)
ab18a495
DS		 530 vrf = vrf_lookup_by_id(VRF_DEFAULT);
531 else
e429a2a0 532 vrf = vrf_lookup_by_name(vrf_name);
ab18a495
DS		 533
534 if (!vrf) {
535 vty_out(vty, "Unable to find vrf you silly head");
536 return CMD_WARNING_CONFIG_FAILED;
537 }
538
42567e00
DS		 539 if (label == 0)
540 label = MPLS_LABEL_NONE;
541
7d061b3c 542 vrf_label_add(vrf->vrf_id, afi, label);
ab18a495
DS		 543 return CMD_SUCCESS;
544}
545
8a71d93d
DS		 546DEFPY (remove_routes,
547 remove_routes_cmd,
e429a2a0 548 "sharp remove routes [vrf NAME$vrf_name] <A.B.C.D$start4|X:X::X:X$start6> (1-1000000)$routes [instance (0-255)$instance]",
75239f4f 549 "Sharp Routing Protocol\n"
8a71d93d
DS		 550 "Remove some routes\n"
551 "Routes to remove\n"
4a7d4737
DS		 552 "The vrf we would like to remove from if non-default\n"
553 "The NAME of the vrf\n"
e310fc19
DS		 554 "v4 Starting spot\n"
555 "v6 Starting spot\n"
556 "Routes to uninstall\n"
ae252c02
DS		 557 "instance to use\n"
558 "Value of instance\n")
8a71d93d 559{
4a7d4737 560 struct vrf *vrf;
547dc642
DS		 561 struct prefix prefix;
562
563 sg.r.total_routes = routes;
564 sg.r.removed_routes = 0;
565 uint32_t rts;
8a71d93d 566
b939f6ff 567 memset(&prefix, 0, sizeof(prefix));
8a71d93d 568
3a6290bd 569 if (start4.s_addr != INADDR_ANY) {
dbc1bf46 570 prefix.family = AF_INET;
12256b84 571 prefix.prefixlen = IPV4_MAX_BITLEN;
dbc1bf46
DS		 572 prefix.u.prefix4 = start4;
573 } else {
574 prefix.family = AF_INET6;
13ccce6e 575 prefix.prefixlen = IPV6_MAX_BITLEN;
dbc1bf46
DS		 576 prefix.u.prefix6 = start6;
577 }
8a71d93d 578
e429a2a0 579 vrf = vrf_lookup_by_name(vrf_name ? vrf_name : VRF_DEFAULT_NAME);
4a7d4737
DS		 580 if (!vrf) {
581 vty_out(vty, "The vrf NAME specified: %s does not exist\n",
e429a2a0 582 vrf_name ? vrf_name : VRF_DEFAULT_NAME);
4a7d4737
DS		 583 return CMD_WARNING;
584 }
585
547dc642 586 sg.r.inst = instance;
4a7d4737 587 sg.r.vrf_id = vrf->vrf_id;
b939f6ff 588 rts = routes;
0cf08685
DS		 589 sharp_remove_routes_helper(&prefix, sg.r.vrf_id,
590 sg.r.inst, rts);
8a71d93d
DS		 591
592 return CMD_SUCCESS;
593}
594
aaf8c96f
DS		 595DEFUN_NOSH (show_debugging_sharpd,
596 show_debugging_sharpd_cmd,
597 "show debugging [sharp]",
598 SHOW_STR
599 DEBUG_STR
600 "Sharp Information\n")
601{
c9e5adba 602 vty_out(vty, "Sharp debugging status:\n");
aaf8c96f
DS		 603
604 return CMD_SUCCESS;
605}
606
faa75dfa
MS		 607DEFPY (sharp_lsp_prefix_v4, sharp_lsp_prefix_v4_cmd,
608 "sharp lsp [update]$update (0-100000)$inlabel\
c9e5adba
MS		 609 nexthop-group NHGNAME$nhgname\
610 [prefix A.B.C.D/M$pfx\
4b0f6237 611 " FRR_IP_REDIST_STR_ZEBRA "$type_str [instance (0-255)$instance]]",
faa75dfa
MS		 612 "Sharp Routing Protocol\n"
613 "Add an LSP\n"
614 "Update an LSP\n"
615 "The ingress label to use\n"
616 "Use nexthops from a nexthop-group\n"
617 "The nexthop-group name\n"
618 "Label a prefix\n"
619 "The v4 prefix to label\n"
620 FRR_IP_REDIST_HELP_STR_ZEBRA
621 "Instance to use\n"
622 "Instance\n")
c9e5adba
MS		 623{
624 struct nexthop_group_cmd *nhgc = NULL;
665edffd
MS		 625 struct nexthop_group_cmd *backup_nhgc = NULL;
626 struct nexthop_group *backup_nhg = NULL;
c9e5adba
MS		 627 struct prefix p = {};
628 int type = 0;
faa75dfa
MS		 629 bool update_p;
630
631 update_p = (update != NULL);
c9e5adba
MS		 632
633 /* We're offered a v4 prefix */
634 if (pfx->family > 0 && type_str) {
635 p.family = pfx->family;
636 p.prefixlen = pfx->prefixlen;
637 p.u.prefix4 = pfx->prefix;
638
639 type = proto_redistnum(AFI_IP, type_str);
640 if (type < 0) {
641 vty_out(vty, "%% Unknown route type '%s'\n", type_str);
642 return CMD_WARNING;
643 }
644 } else if (pfx->family > 0 || type_str) {
645 vty_out(vty, "%% Must supply both prefix and type\n");
646 return CMD_WARNING;
647 }
648
649 nhgc = nhgc_find(nhgname);
650 if (!nhgc) {
651 vty_out(vty, "%% Nexthop-group '%s' does not exist\n",
652 nhgname);
653 return CMD_WARNING;
654 }
655
656 if (nhgc->nhg.nexthop == NULL) {
657 vty_out(vty, "%% Nexthop-group '%s' is empty\n", nhgname);
658 return CMD_WARNING;
659 }
660
665edffd
MS		 661 /* Use group's backup nexthop info if present */
662 if (nhgc->backup_list_name[0]) {
663 backup_nhgc = nhgc_find(nhgc->backup_list_name);
664
665 if (!backup_nhgc) {
666 vty_out(vty,
667 "%% Backup group %s not found for group %s\n",
668 nhgc->backup_list_name,
669 nhgname);
670 return CMD_WARNING;
671 }
672 backup_nhg = &(backup_nhgc->nhg);
673 }
674
faa75dfa
MS		 675 if (sharp_install_lsps_helper(true /*install*/, update_p,
676 pfx->family > 0 ? &p : NULL,
c9e5adba 677 type, instance, inlabel,
665edffd 678 &(nhgc->nhg), backup_nhg) == 0)
c9e5adba
MS		 679 return CMD_SUCCESS;
680 else {
681 vty_out(vty, "%% LSP install failed!\n");
682 return CMD_WARNING;
683 }
684}
685
686DEFPY(sharp_remove_lsp_prefix_v4, sharp_remove_lsp_prefix_v4_cmd,
687 "sharp remove lsp \
688 (0-100000)$inlabel\
665edffd 689 [nexthop-group NHGNAME$nhgname] \
c9e5adba 690 [prefix A.B.C.D/M$pfx\
20c9e649 691 " FRR_IP_REDIST_STR_ZEBRA "$type_str [instance (0-255)$instance]]",
c9e5adba
MS		 692 "Sharp Routing Protocol\n"
693 "Remove data\n"
694 "Remove an LSP\n"
695 "The ingress label\n"
696 "Use nexthops from a nexthop-group\n"
697 "The nexthop-group name\n"
698 "Specify a v4 prefix\n"
699 "The v4 prefix to label\n"
20c9e649 700 FRR_IP_REDIST_HELP_STR_ZEBRA
c9e5adba
MS		 701 "Routing instance\n"
702 "Instance to use\n")
703{
704 struct nexthop_group_cmd *nhgc = NULL;
705 struct prefix p = {};
706 int type = 0;
665edffd 707 struct nexthop_group *nhg = NULL;
c9e5adba
MS		 708
709 /* We're offered a v4 prefix */
710 if (pfx->family > 0 && type_str) {
711 p.family = pfx->family;
712 p.prefixlen = pfx->prefixlen;
713 p.u.prefix4 = pfx->prefix;
714
715 type = proto_redistnum(AFI_IP, type_str);
716 if (type < 0) {
717 vty_out(vty, "%% Unknown route type '%s'\n", type_str);
718 return CMD_WARNING;
719 }
720 } else if (pfx->family > 0 || type_str) {
721 vty_out(vty, "%% Must supply both prefix and type\n");
722 return CMD_WARNING;
723 }
724
665edffd
MS		 725 if (nhgname) {
726 nhgc = nhgc_find(nhgname);
727 if (!nhgc) {
728 vty_out(vty, "%% Nexthop-group '%s' does not exist\n",
729 nhgname);
730 return CMD_WARNING;
731 }
c9e5adba 732
665edffd
MS		 733 if (nhgc->nhg.nexthop == NULL) {
734 vty_out(vty, "%% Nexthop-group '%s' is empty\n",
735 nhgname);
736 return CMD_WARNING;
737 }
738 nhg = &(nhgc->nhg);
c9e5adba
MS		 739 }
740
faa75dfa
MS		 741 if (sharp_install_lsps_helper(false /*!install*/, false,
742 pfx->family > 0 ? &p : NULL,
665edffd 743 type, instance, inlabel, nhg, NULL) == 0)
c9e5adba
MS		 744 return CMD_SUCCESS;
745 else {
746 vty_out(vty, "%% LSP remove failed!\n");
747 return CMD_WARNING;
748 }
749}
750
aef4a13f
DL		 751DEFPY (logpump,
752 logpump_cmd,
753 "sharp logpump duration (1-60) frequency (1-1000000) burst (1-1000)",
754 "Sharp Routing Protocol\n"
755 "Generate bulk log messages for testing\n"
756 "Duration of run (s)\n"
757 "Duration of run (s)\n"
758 "Frequency of bursts (s^-1)\n"
759 "Frequency of bursts (s^-1)\n"
760 "Number of log messages per each burst\n"
761 "Number of log messages per each burst\n")
762{
763 sharp_logpump_run(vty, duration, frequency, burst);
764 return CMD_SUCCESS;
765}
766
2be4d61a
MS		 767DEFPY (create_session,
768 create_session_cmd,
769 "sharp create session (1-1024)",
770 "Sharp Routing Protocol\n"
771 "Create data\n"
772 "Create a test session\n"
773 "Session ID\n")
774{
775 if (sharp_zclient_create(session) != 0) {
776 vty_out(vty, "%% Client session error\n");
777 return CMD_WARNING;
778 }
779
780 return CMD_SUCCESS;
781}
782
783DEFPY (remove_session,
784 remove_session_cmd,
785 "sharp remove session (1-1024)",
786 "Sharp Routing Protocol\n"
787 "Remove data\n"
788 "Remove a test session\n"
789 "Session ID\n")
790{
791 sharp_zclient_delete(session);
792 return CMD_SUCCESS;
793}
794
2ac6c90d
MS		 795DEFPY (send_opaque,
796 send_opaque_cmd,
797 "sharp send opaque type (1-255) (1-1000)$count",
478ff17b 798 SHARP_STR
2ac6c90d
MS		 799 "Send messages for testing\n"
800 "Send opaque messages\n"
801 "Type code to send\n"
802 "Type code to send\n"
803 "Number of messages to send\n")
804{
c8b27f2a
MS		 805 sharp_opaque_send(type, 0, 0, 0, count);
806 return CMD_SUCCESS;
807}
808
809DEFPY (send_opaque_unicast,
810 send_opaque_unicast_cmd,
811 "sharp send opaque unicast type (1-255) \
812 " FRR_IP_REDIST_STR_ZEBRA "$proto_str \
813 [{instance (0-1000) | session (1-1000)}] (1-1000)$count",
814 SHARP_STR
815 "Send messages for testing\n"
816 "Send opaque messages\n"
817 "Send unicast messages\n"
818 "Type code to send\n"
819 "Type code to send\n"
820 FRR_IP_REDIST_HELP_STR_ZEBRA
821 "Daemon instance\n"
822 "Daemon instance\n"
823 "Session ID\n"
824 "Session ID\n"
825 "Number of messages to send\n")
826{
827 uint32_t proto;
828
829 proto = proto_redistnum(AFI_IP, proto_str);
830
831 sharp_opaque_send(type, proto, instance, session, count);
832
2ac6c90d
MS		 833 return CMD_SUCCESS;
834}
835
939b2339
MS		 836DEFPY (send_opaque_reg,
837 send_opaque_reg_cmd,
838 "sharp send opaque <reg$reg | unreg> \
839 " FRR_IP_REDIST_STR_ZEBRA "$proto_str \
840 [{instance (0-1000) | session (1-1000)}] type (1-1000)",
478ff17b 841 SHARP_STR
939b2339
MS		 842 "Send messages for testing\n"
843 "Send opaque messages\n"
844 "Send opaque registration\n"
845 "Send opaque unregistration\n"
846 FRR_IP_REDIST_HELP_STR_ZEBRA
847 "Daemon instance\n"
848 "Daemon instance\n"
849 "Session ID\n"
850 "Session ID\n"
851 "Opaque sub-type code\n"
852 "Opaque sub-type code\n")
853{
854 int proto;
855
856 proto = proto_redistnum(AFI_IP, proto_str);
857
858 sharp_opaque_reg_send((reg != NULL), proto, instance, session, type);
859 return CMD_SUCCESS;
860}
861
da187b77
JU		 862DEFPY (neigh_discover,
863 neigh_discover_cmd,
864 "sharp neigh discover [vrf NAME$vrf_name] <A.B.C.D$dst4|X:X::X:X$dst6> IFNAME$ifname",
865 SHARP_STR
866 "Discover neighbours\n"
867 "Send an ARP/NDP request\n"
868 VRF_CMD_HELP_STR
869 "v4 Destination address\n"
870 "v6 Destination address\n"
871 "Interface name\n")
872{
873 struct vrf *vrf;
874 struct interface *ifp;
875 struct prefix prefix;
876
877 memset(&prefix, 0, sizeof(prefix));
878
3a6290bd 879 if (dst4.s_addr != INADDR_ANY) {
da187b77 880 prefix.family = AF_INET;
12256b84 881 prefix.prefixlen = IPV4_MAX_BITLEN;
da187b77
JU		 882 prefix.u.prefix4 = dst4;
883 } else {
884 prefix.family = AF_INET6;
885 prefix.prefixlen = 128;
886 prefix.u.prefix6 = dst6;
887 }
888
889 vrf = vrf_lookup_by_name(vrf_name ? vrf_name : VRF_DEFAULT_NAME);
890 if (!vrf) {
891 vty_out(vty, "The vrf NAME specified: %s does not exist\n",
892 vrf_name ? vrf_name : VRF_DEFAULT_NAME);
893 return CMD_WARNING;
894 }
895
896 ifp = if_lookup_by_name_vrf(ifname, vrf);
897 if (ifp == NULL) {
898 vty_out(vty, "%% Can't find interface %s\n", ifname);
899 return CMD_WARNING;
900 }
901
902 sharp_zebra_send_arp(ifp, &prefix);
903
904 return CMD_SUCCESS;
905}
906
1888e243
OD		 907DEFPY (import_te,
908 import_te_cmd,
909 "sharp import-te",
910 SHARP_STR
911 "Import Traffic Engineering\n")
912{
913 sg.ted = ls_ted_new(1, "Sharp", 0);
914 sharp_zebra_register_te();
915
916 return CMD_SUCCESS;
917}
918
ade3eebc
HS		 919DEFPY (sharp_srv6_manager_get_locator_chunk,
920 sharp_srv6_manager_get_locator_chunk_cmd,
921 "sharp srv6-manager get-locator-chunk NAME$locator_name",
922 SHARP_STR
923 "Segment-Routing IPv6\n"
924 "Get SRv6 locator-chunk\n"
925 "SRv6 Locator name\n")
926{
927 int ret;
928 struct listnode *node;
929 struct sharp_srv6_locator *loc;
930 struct sharp_srv6_locator *loc_found = NULL;
931
932 for (ALL_LIST_ELEMENTS_RO(sg.srv6_locators, node, loc)) {
933 if (strcmp(loc->name, locator_name))
934 continue;
935 loc_found = loc;
936 break;
937 }
938 if (!loc_found) {
939 loc = XCALLOC(MTYPE_SRV6_LOCATOR,
940 sizeof(struct sharp_srv6_locator));
941 loc->chunks = list_new();
942 snprintf(loc->name, SRV6_LOCNAME_SIZE, "%s", locator_name);
943 listnode_add(sg.srv6_locators, loc);
944 }
945
946 ret = sharp_zebra_srv6_manager_get_locator_chunk(locator_name);
947 if (ret < 0)
948 return CMD_WARNING_CONFIG_FAILED;
949
950 return CMD_SUCCESS;
951}
952
1888e243
OD		 953DEFUN (show_sharp_ted,
954 show_sharp_ted_cmd,
955 "show sharp ted [<vertex [A.B.C.D]|edge [A.B.C.D]|subnet [A.B.C.D/M]>] [verbose|json]",
956 SHOW_STR
957 SHARP_STR
958 "Traffic Engineering Database\n"
959 "MPLS-TE Vertex\n"
960 "MPLS-TE router ID (as an IP address)\n"
961 "MPLS-TE Edge\n"
962 "MPLS-TE Edge ID (as an IP address)\n"
963 "MPLS-TE Subnet\n"
964 "MPLS-TE Subnet ID (as an IP prefix)\n"
965 "Verbose output\n"
966 JSON_STR)
967{
968 int idx = 0;
969 struct in_addr ip_addr;
970 struct prefix pref;
971 struct ls_vertex *vertex;
972 struct ls_edge *edge;
973 struct ls_subnet *subnet;
974 uint64_t key;
975 bool verbose = false;
976 bool uj = use_json(argc, argv);
977 json_object *json = NULL;
978
979 if (sg.ted == NULL) {
980 vty_out(vty, "MPLS-TE import is not enabled\n");
981 return CMD_WARNING;
982 }
983
984 if (uj)
985 json = json_object_new_object();
986
987 if (argv[argc - 1]->arg && strmatch(argv[argc - 1]->text, "verbose"))
988 verbose = true;
989
990 if (argv_find(argv, argc, "vertex", &idx)) {
991 /* Show Vertex */
992 if (argv_find(argv, argc, "A.B.C.D", &idx)) {
993 if (!inet_aton(argv[idx + 1]->arg, &ip_addr)) {
994 vty_out(vty,
995 "Specified Router ID %s is invalid\n",
996 argv[idx + 1]->arg);
997 return CMD_WARNING_CONFIG_FAILED;
998 }
999 /* Get the Vertex from the Link State Database */
1000 key = ((uint64_t)ip_addr.s_addr) & 0xffffffff;
1001 vertex = ls_find_vertex_by_key(sg.ted, key);
1002 if (!vertex) {
1003 vty_out(vty, "No vertex found for ID %pI4\n",
1004 &ip_addr);
1005 return CMD_WARNING;
1006 }
1007 } else
1008 vertex = NULL;
1009
1010 if (vertex)
1011 ls_show_vertex(vertex, vty, json, verbose);
1012 else
1013 ls_show_vertices(sg.ted, vty, json, verbose);
1014
1015 } else if (argv_find(argv, argc, "edge", &idx)) {
1016 /* Show Edge */
1017 if (argv_find(argv, argc, "A.B.C.D", &idx)) {
1018 if (!inet_aton(argv[idx]->arg, &ip_addr)) {
1019 vty_out(vty,
1020 "Specified Edge ID %s is invalid\n",
1021 argv[idx]->arg);
1022 return CMD_WARNING_CONFIG_FAILED;
1023 }
1024 /* Get the Edge from the Link State Database */
1025 key = ((uint64_t)ip_addr.s_addr) & 0xffffffff;
1026 edge = ls_find_edge_by_key(sg.ted, key);
1027 if (!edge) {
1028 vty_out(vty, "No edge found for ID %pI4\n",
1029 &ip_addr);
1030 return CMD_WARNING;
1031 }
1032 } else
1033 edge = NULL;
1034
1035 if (edge)
1036 ls_show_edge(edge, vty, json, verbose);
1037 else
1038 ls_show_edges(sg.ted, vty, json, verbose);
1039
1040 } else if (argv_find(argv, argc, "subnet", &idx)) {
1041 /* Show Subnet */
1042 if (argv_find(argv, argc, "A.B.C.D/M", &idx)) {
1043 if (!str2prefix(argv[idx]->arg, &pref)) {
1044 vty_out(vty, "Invalid prefix format %s\n",
1045 argv[idx]->arg);
1046 return CMD_WARNING_CONFIG_FAILED;
1047 }
1048 /* Get the Subnet from the Link State Database */
1049 subnet = ls_find_subnet(sg.ted, pref);
1050 if (!subnet) {
1051 vty_out(vty, "No subnet found for ID %pFX\n",
1052 &pref);
1053 return CMD_WARNING;
1054 }
1055 } else
1056 subnet = NULL;
1057
1058 if (subnet)
1059 ls_show_subnet(subnet, vty, json, verbose);
1060 else
1061 ls_show_subnets(sg.ted, vty, json, verbose);
1062
1063 } else {
1064 /* Show the complete TED */
1065 ls_show_ted(sg.ted, vty, json, verbose);
1066 }
1067
c48349e3 1068 if (uj)
7297350e 1069 vty_json(vty, json);
ade3eebc
HS		 1070
1071 return CMD_SUCCESS;
1072}
1073
1074DEFPY (sharp_srv6_manager_release_locator_chunk,
1075 sharp_srv6_manager_release_locator_chunk_cmd,
1076 "sharp srv6-manager release-locator-chunk NAME$locator_name",
1077 SHARP_STR
1078 "Segment-Routing IPv6\n"
1079 "Release SRv6 locator-chunk\n"
1080 "SRv6 Locator name\n")
1081{
1082 int ret;
1083 struct listnode *loc_node;
1084 struct sharp_srv6_locator *loc;
1085
1086 for (ALL_LIST_ELEMENTS_RO(sg.srv6_locators, loc_node, loc)) {
1087 if (!strcmp(loc->name, locator_name)) {
1088 list_delete_all_node(loc->chunks);
1089 list_delete(&loc->chunks);
1090 listnode_delete(sg.srv6_locators, loc);
1091 break;
1092 }
1093 }
1094
1095 ret = sharp_zebra_srv6_manager_release_locator_chunk(locator_name);
1096 if (ret < 0)
1097 return CMD_WARNING_CONFIG_FAILED;
1098
1099 return CMD_SUCCESS;
1100}
1101
1102DEFPY (show_sharp_segment_routing_srv6,
1103 show_sharp_segment_routing_srv6_cmd,
a2df1e4f 1104 "show sharp segment-routing srv6 [json]",
ade3eebc
HS		 1105 SHOW_STR
1106 SHARP_STR
1107 "Segment-Routing\n"
a2df1e4f
HS		 1108 "Segment-Routing IPv6\n"
1109 JSON_STR)
ade3eebc
HS		 1110{
1111 char str[256];
1112 struct listnode *loc_node;
1113 struct listnode *chunk_node;
1114 struct sharp_srv6_locator *loc;
1115 struct prefix_ipv6 *chunk;
a2df1e4f 1116 bool uj = use_json(argc, argv);
ade3eebc
HS		 1117 json_object *jo_locs = NULL;
1118 json_object *jo_loc = NULL;
1119 json_object *jo_chunks = NULL;
1120
a2df1e4f
HS		 1121 if (uj) {
1122 jo_locs = json_object_new_array();
1123 for (ALL_LIST_ELEMENTS_RO(sg.srv6_locators, loc_node, loc)) {
1124 jo_loc = json_object_new_object();
1125 json_object_array_add(jo_locs, jo_loc);
1126 json_object_string_add(jo_loc, "name", loc->name);
1127 jo_chunks = json_object_new_array();
1128 json_object_object_add(jo_loc, "chunks", jo_chunks);
1129 for (ALL_LIST_ELEMENTS_RO(loc->chunks, chunk_node,
1130 chunk)) {
1131 prefix2str(chunk, str, sizeof(str));
1132 json_array_string_add(jo_chunks, str);
1133 }
1134 }
1135
7297350e 1136 vty_json(vty, jo_locs);
a2df1e4f
HS		 1137 } else {
1138 for (ALL_LIST_ELEMENTS_RO(sg.srv6_locators, loc_node, loc)) {
1139 vty_out(vty, "Locator %s has %d prefix chunks\n",
1140 loc->name, listcount(loc->chunks));
1141 for (ALL_LIST_ELEMENTS_RO(loc->chunks, chunk_node,
1142 chunk)) {
1143 prefix2str(chunk, str, sizeof(str));
1144 vty_out(vty, " %s\n", str);
1145 }
1146 vty_out(vty, "\n");
ade3eebc
HS		 1147 }
1148 }
1149
1888e243
OD		 1150 return CMD_SUCCESS;
1151}
1152
8a71d93d
DS		 1153void sharp_vty_init(void)
1154{
f59e6418 1155 install_element(ENABLE_NODE, &install_routes_data_dump_cmd);
8a71d93d 1156 install_element(ENABLE_NODE, &install_routes_cmd);
1cb131ee
HS		 1157 install_element(ENABLE_NODE, &install_seg6_routes_cmd);
1158 install_element(ENABLE_NODE, &install_seg6local_routes_cmd);
8a71d93d 1159 install_element(ENABLE_NODE, &remove_routes_cmd);
ab18a495 1160 install_element(ENABLE_NODE, &vrf_label_cmd);
86da53ab 1161 install_element(ENABLE_NODE, &sharp_nht_data_dump_cmd);
921af54d 1162 install_element(ENABLE_NODE, &watch_redistribute_cmd);
0ae8130d
DS		 1163 install_element(ENABLE_NODE, &watch_nexthop_v6_cmd);
1164 install_element(ENABLE_NODE, &watch_nexthop_v4_cmd);
c9e5adba
MS		 1165 install_element(ENABLE_NODE, &sharp_lsp_prefix_v4_cmd);
1166 install_element(ENABLE_NODE, &sharp_remove_lsp_prefix_v4_cmd);
aef4a13f 1167 install_element(ENABLE_NODE, &logpump_cmd);
2be4d61a
MS		 1168 install_element(ENABLE_NODE, &create_session_cmd);
1169 install_element(ENABLE_NODE, &remove_session_cmd);
2ac6c90d 1170 install_element(ENABLE_NODE, &send_opaque_cmd);
c8b27f2a 1171 install_element(ENABLE_NODE, &send_opaque_unicast_cmd);
939b2339 1172 install_element(ENABLE_NODE, &send_opaque_reg_cmd);
da187b77 1173 install_element(ENABLE_NODE, &neigh_discover_cmd);
1888e243 1174 install_element(ENABLE_NODE, &import_te_cmd);
aaf8c96f 1175
dd73744d 1176 install_element(ENABLE_NODE, &show_debugging_sharpd_cmd);
1888e243 1177 install_element(ENABLE_NODE, &show_sharp_ted_cmd);
aaf8c96f 1178
ade3eebc 1179 install_element(ENABLE_NODE, &sharp_srv6_manager_get_locator_chunk_cmd);
4df9d859
HS		 1180 install_element(ENABLE_NODE,
1181 &sharp_srv6_manager_release_locator_chunk_cmd);
ade3eebc
HS		 1182 install_element(ENABLE_NODE, &show_sharp_segment_routing_srv6_cmd);
1183
8a71d93d
DS		 1184 return;
1185}
FRRouting mirror