sharpd/sharp_vty.c

   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"
  29 #include "vrf.h"
  30 #include "zclient.h"
  31 #include "nexthop_group.h"
  32
  33 #include "sharpd/sharp_globals.h"
  34 #include "sharpd/sharp_zebra.h"
  35 #include "sharpd/sharp_nht.h"
  36 #include "sharpd/sharp_vty.h"
  37 #ifndef VTYSH_EXTRACT_PL
  38 #include "sharpd/sharp_vty_clippy.c"
  39 #endif
  40
  41 DEFPY(watch_nexthop_v6, watch_nexthop_v6_cmd,
  42       "sharp watch <nexthop$n|import$import> X:X::X:X$nhop [connected$connected]",
  43       "Sharp routing Protocol\n"
  44       "Watch for changes\n"
  45       "Watch for nexthop changes\n"
  46       "Watch for import check changes\n"
  47       "The v6 nexthop to signal for watching\n"
  48       "Should the route be connected\n")
  49 {
  50         struct prefix p;
  51         bool type_import;
  52
  53
  54         if (n)
  55                 type_import = false;
  56         else
  57                 type_import = true;
  58
  59         memset(&p, 0, sizeof(p));
  60
  61         p.prefixlen = 128;
  62         memcpy(&p.u.prefix6, &nhop, 16);
  63         p.family = AF_INET6;
  64
  65         sharp_nh_tracker_get(&p);
  66         sharp_zebra_nexthop_watch(&p, type_import, true, !!connected);
  67
  68         return CMD_SUCCESS;
  69 }
  70
  71 DEFPY(watch_nexthop_v4, watch_nexthop_v4_cmd,
  72       "sharp watch <nexthop$n|import$import> A.B.C.D$nhop [connected$connected]",
  73       "Sharp routing Protocol\n"
  74       "Watch for changes\n"
  75       "Watch for nexthop changes\n"
  76       "Watch for import check changes\n"
  77       "The v4 nexthop to signal for watching\n"
  78       "Should the route be connected\n")
  79 {
  80         struct prefix p;
  81         bool type_import;
  82
  83         memset(&p, 0, sizeof(p));
  84
  85         if (n)
  86                 type_import = false;
  87         else
  88                 type_import = true;
  89
  90         p.prefixlen = 32;
  91         p.u.prefix4 = nhop;
  92         p.family = AF_INET;
  93
  94         sharp_nh_tracker_get(&p);
  95         sharp_zebra_nexthop_watch(&p, type_import, true, !!connected);
  96
  97         return CMD_SUCCESS;
  98 }
  99
 100 DEFPY(sharp_nht_data_dump,
 101       sharp_nht_data_dump_cmd,
 102       "sharp data nexthop",
 103       "Sharp routing Protocol\n"
 104       "Nexthop information\n"
 105       "Data Dump\n")
 106 {
 107         sharp_nh_tracker_dump(vty);
 108
 109         return CMD_SUCCESS;
 110 }
 111
 112 DEFPY (install_routes_data_dump,
 113        install_routes_data_dump_cmd,
 114        "sharp data route",
 115        "Sharp routing Protocol\n"
 116        "Data about what is going on\n"
 117        "Route Install/Removal Information\n")
 118 {
 119         char buf[PREFIX_STRLEN];
 120         struct timeval r;
 121
 122         timersub(&sg.r.t_end, &sg.r.t_start, &r);
 123         vty_out(vty, "Prefix: %s Total: %u %u %u Time: %ld.%ld\n",
 124                 prefix2str(&sg.r.orig_prefix, buf, sizeof(buf)),
 125                 sg.r.total_routes,
 126                 sg.r.installed_routes,
 127                 sg.r.removed_routes,
 128                 r.tv_sec, r.tv_usec);
 129
 130         return CMD_SUCCESS;
 131 }
 132
 133 DEFPY (install_routes,
 134        install_routes_cmd,
 135        "sharp install routes <A.B.C.D$start4|X:X::X:X$start6> <nexthop <A.B.C.D$nexthop4|X:X::X:X$nexthop6>|nexthop-group NAME$nexthop_group> (1-1000000)$routes [instance (0-255)$instance] [repeat (2-1000)$rpt]",
 136        "Sharp routing Protocol\n"
 137        "install some routes\n"
 138        "Routes to install\n"
 139        "v4 Address to start /32 generation at\n"
 140        "v6 Address to start /32 generation at\n"
 141        "Nexthop to use(Can be an IPv4 or IPv6 address)\n"
 142        "V4 Nexthop address to use\n"
 143        "V6 Nexthop address to use\n"
 144        "Nexthop-Group to use\n"
 145        "The Name of the nexthop-group\n"
 146        "How many to create\n"
 147        "Instance to use\n"
 148        "Instance\n"
 149        "Should we repeat this command\n"
 150        "How many times to repeat this command\n")
 151 {
 152         struct prefix prefix;
 153         uint32_t rts;
 154
 155         sg.r.total_routes = routes;
 156         sg.r.installed_routes = 0;
 157
 158         if (rpt >= 2)
 159                 sg.r.repeat = rpt * 2;
 160         else
 161                 sg.r.repeat = 0;
 162
 163         memset(&prefix, 0, sizeof(prefix));
 164         memset(&sg.r.orig_prefix, 0, sizeof(sg.r.orig_prefix));
 165         memset(&sg.r.nhop, 0, sizeof(sg.r.nhop));
 166         memset(&sg.r.nhop_group, 0, sizeof(sg.r.nhop_group));
 167
 168         if (start4.s_addr != 0) {
 169                 prefix.family = AF_INET;
 170                 prefix.prefixlen = 32;
 171                 prefix.u.prefix4 = start4;
 172         } else {
 173                 prefix.family = AF_INET6;
 174                 prefix.prefixlen = 128;
 175                 prefix.u.prefix6 = start6;
 176         }
 177         sg.r.orig_prefix = prefix;
 178
 179         if (nexthop_group) {
 180                 struct nexthop_group_cmd *nhgc = nhgc_find(nexthop_group);
 181                 if (!nhgc) {
 182                         vty_out(vty,
 183                                 "Specified Nexthop Group: %s does not exist\n",
 184                                 nexthop_group);
 185                         return CMD_WARNING;
 186                 }
 187
 188                 sg.r.nhop_group.nexthop = nhgc->nhg.nexthop;
 189         } else {
 190                 if (nexthop4.s_addr != INADDR_ANY) {
 191                         sg.r.nhop.gate.ipv4 = nexthop4;
 192                         sg.r.nhop.type = NEXTHOP_TYPE_IPV4;
 193                 } else {
 194                         sg.r.nhop.gate.ipv6 = nexthop6;
 195                         sg.r.nhop.type = NEXTHOP_TYPE_IPV6;
 196                 }
 197
 198                 sg.r.nhop.vrf_id = VRF_DEFAULT;
 199                 sg.r.nhop_group.nexthop = &sg.r.nhop;
 200         }
 201
 202         sg.r.inst = instance;
 203         sg.r.vrf_id = VRF_DEFAULT;
 204         rts = routes;
 205         sharp_install_routes_helper(&prefix, sg.r.vrf_id,
 206                                     sg.r.inst, &sg.r.nhop_group, rts);
 207
 208         return CMD_SUCCESS;
 209 }
 210
 211 DEFPY(vrf_label, vrf_label_cmd,
 212       "sharp label <ip$ipv4|ipv6$ipv6> vrf NAME$name label (0-100000)$label",
 213       "Sharp Routing Protocol\n"
 214       "Give a vrf a label\n"
 215       "Pop and forward for IPv4\n"
 216       "Pop and forward for IPv6\n"
 217       VRF_CMD_HELP_STR
 218       "The label to use, 0 specifies remove the label installed from previous\n"
 219       "Specified range to use\n")
 220 {
 221         struct vrf *vrf;
 222         afi_t afi = (ipv4) ? AFI_IP : AFI_IP6;
 223
 224         if (strcmp(name, "default") == 0)
 225                 vrf = vrf_lookup_by_id(VRF_DEFAULT);
 226         else
 227                 vrf = vrf_lookup_by_name(name);
 228
 229         if (!vrf) {
 230                 vty_out(vty, "Unable to find vrf you silly head");
 231                 return CMD_WARNING_CONFIG_FAILED;
 232         }
 233
 234         if (label == 0)
 235                 label = MPLS_LABEL_NONE;
 236
 237         vrf_label_add(vrf->vrf_id, afi, label);
 238         return CMD_SUCCESS;
 239 }
 240
 241 DEFPY (remove_routes,
 242        remove_routes_cmd,
 243        "sharp remove routes <A.B.C.D$start4|X:X::X:X$start6> (1-1000000)$routes [instance (0-255)$instance]",
 244        "Sharp Routing Protocol\n"
 245        "Remove some routes\n"
 246        "Routes to remove\n"
 247        "v4 Starting spot\n"
 248        "v6 Starting spot\n"
 249        "Routes to uninstall\n"
 250        "instance to use\n"
 251        "Value of instance\n")
 252 {
 253         struct prefix prefix;
 254
 255         sg.r.total_routes = routes;
 256         sg.r.removed_routes = 0;
 257         uint32_t rts;
 258
 259         memset(&prefix, 0, sizeof(prefix));
 260
 261         if (start4.s_addr != 0) {
 262                 prefix.family = AF_INET;
 263                 prefix.prefixlen = 32;
 264                 prefix.u.prefix4 = start4;
 265         } else {
 266                 prefix.family = AF_INET6;
 267                 prefix.prefixlen = 128;
 268                 prefix.u.prefix6 = start6;
 269         }
 270
 271         sg.r.inst = instance;
 272         sg.r.vrf_id = VRF_DEFAULT;
 273         rts = routes;
 274         sharp_remove_routes_helper(&prefix, sg.r.vrf_id,
 275                                    sg.r.inst, rts);
 276
 277         return CMD_SUCCESS;
 278 }
 279
 280 DEFUN_NOSH (show_debugging_sharpd,
 281             show_debugging_sharpd_cmd,
 282             "show debugging [sharp]",
 283             SHOW_STR
 284             DEBUG_STR
 285             "Sharp Information\n")
 286 {
 287         vty_out(vty, "Sharp debugging status\n");
 288
 289         return CMD_SUCCESS;
 290 }
 291
 292 void sharp_vty_init(void)
 293 {
 294         install_element(ENABLE_NODE, &install_routes_data_dump_cmd);
 295         install_element(ENABLE_NODE, &install_routes_cmd);
 296         install_element(ENABLE_NODE, &remove_routes_cmd);
 297         install_element(ENABLE_NODE, &vrf_label_cmd);
 298         install_element(ENABLE_NODE, &sharp_nht_data_dump_cmd);
 299         install_element(ENABLE_NODE, &watch_nexthop_v6_cmd);
 300         install_element(ENABLE_NODE, &watch_nexthop_v4_cmd);
 301
 302         install_element(VIEW_NODE, &show_debugging_sharpd_cmd);
 303
 304         return;
 305 }