bgpd/bgp_flowspec_vty.c

   1 /* BGP FlowSpec VTY
   2  * Copyright (C) 2018 6WIND
   3  *
   4  * FRRouting is free software; you can redistribute it and/or modify it
   5  * under the terms of the GNU General Public License as published by the
   6  * Free Software Foundation; either version 2, or (at your option) any
   7  * later version.
   8  *
   9  * FRRouting is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along
  15  * with this program; see the file COPYING; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  17  */
  18
  19 #include <zebra.h>
  20 #include "command.h"
  21
  22 #include "bgpd/bgpd.h"
  23 #include "bgpd/bgp_table.h"
  24 #include "bgpd/bgp_attr.h"
  25 #include "bgpd/bgp_ecommunity.h"
  26 #include "bgpd/bgp_vty.h"
  27 #include "bgpd/bgp_route.h"
  28 #include "bgpd/bgp_aspath.h"
  29 #include "bgpd/bgp_flowspec.h"
  30 #include "bgpd/bgp_flowspec_util.h"
  31 #include "bgpd/bgp_flowspec_private.h"
  32 #include "bgpd/bgp_debug.h"
  33 #include "bgpd/bgp_pbr.h"
  34
  35 /* Local Structures and variables declarations
  36  * This code block hosts the struct declared that host the flowspec rules
  37  * as well as some structure used to convert to stringx
  38  */
  39
  40 static const struct message bgp_flowspec_display_large[] = {
  41         {FLOWSPEC_DEST_PREFIX, "Destination Address"},
  42         {FLOWSPEC_SRC_PREFIX, "Source Address"},
  43         {FLOWSPEC_IP_PROTOCOL, "IP Protocol"},
  44         {FLOWSPEC_PORT, "Port"},
  45         {FLOWSPEC_DEST_PORT, "Destination Port"},
  46         {FLOWSPEC_SRC_PORT, "Source Port"},
  47         {FLOWSPEC_ICMP_TYPE, "ICMP Type"},
  48         {FLOWSPEC_ICMP_CODE, "ICMP Code"},
  49         {FLOWSPEC_TCP_FLAGS, "TCP Flags"},
  50         {FLOWSPEC_PKT_LEN, "Packet Length"},
  51         {FLOWSPEC_DSCP, "DSCP field"},
  52         {FLOWSPEC_FRAGMENT, "Packet Fragment"},
  53         {0}
  54 };
  55
  56 static const struct message bgp_flowspec_display_min[] = {
  57         {FLOWSPEC_DEST_PREFIX, "to"},
  58         {FLOWSPEC_SRC_PREFIX, "from"},
  59         {FLOWSPEC_IP_PROTOCOL, "proto"},
  60         {FLOWSPEC_PORT, "port"},
  61         {FLOWSPEC_DEST_PORT, "dstp"},
  62         {FLOWSPEC_SRC_PORT, "srcp"},
  63         {FLOWSPEC_ICMP_TYPE, "type"},
  64         {FLOWSPEC_ICMP_CODE, "code"},
  65         {FLOWSPEC_TCP_FLAGS, "tcp"},
  66         {FLOWSPEC_PKT_LEN, "pktlen"},
  67         {FLOWSPEC_DSCP, "dscp"},
  68         {FLOWSPEC_FRAGMENT, "pktfrag"},
  69         {0}
  70 };
  71
  72 #define FS_STRING_UPDATE(count, ptr, format, remaining_len) do {        \
  73                 int _len_written;                                       \
  74                                                                         \
  75                 if (((format) == NLRI_STRING_FORMAT_DEBUG) && (count)) {\
  76                         _len_written = snprintf((ptr), (remaining_len), \
  77                                                 ", ");                  \
  78                         (remaining_len) -= _len_written;                \
  79                         (ptr) += _len_written;                          \
  80                 } else if (((format) == NLRI_STRING_FORMAT_MIN)         \
  81                            && (count)) {                                \
  82                         _len_written = snprintf((ptr), (remaining_len), \
  83                                                 " ");                   \
  84                         (remaining_len) -= _len_written;                \
  85                         (ptr) += _len_written;                          \
  86                 }                                                       \
  87                 count++;                                                \
  88         } while (0)
  89
  90 /* Parse FLOWSPEC NLRI
  91  * passed return_string string has assumed length
  92  * BGP_FLOWSPEC_STRING_DISPLAY_MAX
  93  */
  94 void bgp_fs_nlri_get_string(unsigned char *nlri_content, size_t len,
  95                             char *return_string, int format,
  96                             json_object *json_path)
  97 {
  98         uint32_t offset = 0;
  99         int type;
 100         int ret = 0, error = 0;
 101         char *ptr = return_string;
 102         char local_string[BGP_FLOWSPEC_STRING_DISPLAY_MAX];
 103         int count = 0;
 104         char extra[2] = "";
 105         char pre_extra[2] = "";
 106         const struct message *bgp_flowspec_display;
 107         enum bgp_flowspec_util_nlri_t type_util;
 108         int len_string = BGP_FLOWSPEC_STRING_DISPLAY_MAX;
 109         int len_written;
 110
 111         if (format == NLRI_STRING_FORMAT_LARGE) {
 112                 snprintf(pre_extra, sizeof(pre_extra), "\t");
 113                 snprintf(extra, sizeof(extra), "\n");
 114                 bgp_flowspec_display = bgp_flowspec_display_large;
 115         } else
 116                 bgp_flowspec_display = bgp_flowspec_display_min;
 117         /* if needed. type_util can be set to other values */
 118         type_util = BGP_FLOWSPEC_RETURN_STRING;
 119         error = 0;
 120         while (offset < len-1 && error >= 0) {
 121                 type = nlri_content[offset];
 122                 offset++;
 123                 switch (type) {
 124                 case FLOWSPEC_DEST_PREFIX:
 125                 case FLOWSPEC_SRC_PREFIX:
 126                         ret = bgp_flowspec_ip_address(
 127                                                 type_util,
 128                                                 nlri_content+offset,
 129                                                 len - offset,
 130                                                 local_string, &error);
 131                         if (ret <= 0)
 132                                 break;
 133                         if (json_path) {
 134                                 json_object_string_add(json_path,
 135                                      lookup_msg(bgp_flowspec_display, type, ""),
 136                                      local_string);
 137                                 break;
 138                         }
 139                         FS_STRING_UPDATE(count, ptr, format, len_string);
 140                         len_written = snprintf(ptr, len_string, "%s%s %s%s",
 141                                         pre_extra,
 142                                         lookup_msg(bgp_flowspec_display,
 143                                                    type, ""),
 144                                         local_string, extra);
 145                         len_string -= len_written;
 146                         ptr += len_written;
 147                         break;
 148                 case FLOWSPEC_IP_PROTOCOL:
 149                 case FLOWSPEC_PORT:
 150                 case FLOWSPEC_DEST_PORT:
 151                 case FLOWSPEC_SRC_PORT:
 152                 case FLOWSPEC_ICMP_TYPE:
 153                 case FLOWSPEC_ICMP_CODE:
 154                         ret = bgp_flowspec_op_decode(type_util,
 155                                                      nlri_content+offset,
 156                                                      len - offset,
 157                                                      local_string, &error);
 158                         if (ret <= 0)
 159                                 break;
 160                         if (json_path) {
 161                                 json_object_string_add(json_path,
 162                                      lookup_msg(bgp_flowspec_display, type, ""),
 163                                      local_string);
 164                                 break;
 165                         }
 166                         FS_STRING_UPDATE(count, ptr, format, len_string);
 167                         len_written = snprintf(ptr, len_string, "%s%s %s%s",
 168                                         pre_extra,
 169                                         lookup_msg(bgp_flowspec_display,
 170                                         type, ""),
 171                                      local_string, extra);
 172                         len_string -= len_written;
 173                         ptr += len_written;
 174                         break;
 175                 case FLOWSPEC_TCP_FLAGS:
 176                         ret = bgp_flowspec_bitmask_decode(
 177                                               type_util,
 178                                               nlri_content+offset,
 179                                               len - offset,
 180                                               local_string, &error);
 181                         if (ret <= 0)
 182                                 break;
 183                         if (json_path) {
 184                                 json_object_string_add(json_path,
 185                                      lookup_msg(bgp_flowspec_display,
 186                                                 type, ""),
 187                                      local_string);
 188                                 break;
 189                         }
 190                         FS_STRING_UPDATE(count, ptr, format, len_string);
 191                         len_written = snprintf(ptr, len_string, "%s%s %s%s",
 192                                         pre_extra,
 193                                         lookup_msg(bgp_flowspec_display,
 194                                                    type, ""),
 195                                         local_string, extra);
 196                         len_string -= len_written;
 197                         ptr += len_written;
 198                         break;
 199                 case FLOWSPEC_PKT_LEN:
 200                 case FLOWSPEC_DSCP:
 201                         ret = bgp_flowspec_op_decode(
 202                                                 type_util,
 203                                                 nlri_content + offset,
 204                                                 len - offset, local_string,
 205                                                 &error);
 206                         if (ret <= 0)
 207                                 break;
 208                         if (json_path) {
 209                                 json_object_string_add(json_path,
 210                                     lookup_msg(bgp_flowspec_display, type, ""),
 211                                     local_string);
 212                                 break;
 213                         }
 214                         FS_STRING_UPDATE(count, ptr, format, len_string);
 215                         len_written = snprintf(ptr, len_string, "%s%s %s%s",
 216                                         pre_extra,
 217                                         lookup_msg(bgp_flowspec_display,
 218                                         type, ""),
 219                                      local_string, extra);
 220                         len_string -= len_written;
 221                         ptr += len_written;
 222                         break;
 223                 case FLOWSPEC_FRAGMENT:
 224                         ret = bgp_flowspec_bitmask_decode(
 225                                               type_util,
 226                                               nlri_content+offset,
 227                                               len - offset,
 228                                               local_string, &error);
 229                         if (ret <= 0)
 230                                 break;
 231                         if (json_path) {
 232                                 json_object_string_add(json_path,
 233                                     lookup_msg(bgp_flowspec_display,
 234                                                type, ""),
 235                                     local_string);
 236                                 break;
 237                         }
 238                         FS_STRING_UPDATE(count, ptr, format, len_string);
 239                         len_written = snprintf(ptr, len_string, "%s%s %s%s",
 240                                         pre_extra,
 241                                         lookup_msg(bgp_flowspec_display,
 242                                         type, ""),
 243                                         local_string, extra);
 244                         len_string -= len_written;
 245                         ptr += len_written;
 246                         break;
 247                 default:
 248                         error = -1;
 249                         break;
 250                 }
 251                 offset += ret;
 252         }
 253 }
 254
 255 void route_vty_out_flowspec(struct vty *vty, struct prefix *p,
 256                             struct bgp_info *binfo,
 257                             int display, json_object *json_paths)
 258 {
 259         struct attr *attr;
 260         char return_string[BGP_FLOWSPEC_STRING_DISPLAY_MAX];
 261         char *s;
 262         json_object *json_nlri_path = NULL;
 263         json_object *json_ecom_path = NULL;
 264         json_object *json_time_path = NULL;
 265         char timebuf[BGP_UPTIME_LEN];
 266
 267         /* Print prefix */
 268         if (p != NULL) {
 269                 if (p->family != AF_FLOWSPEC)
 270                         return;
 271                 if (json_paths) {
 272                         if (display == NLRI_STRING_FORMAT_JSON)
 273                                 json_nlri_path = json_object_new_object();
 274                         else
 275                                 json_nlri_path = json_paths;
 276                 }
 277                 if (display == NLRI_STRING_FORMAT_LARGE && binfo)
 278                         vty_out(vty, "BGP flowspec entry: (flags 0x%x)\n",
 279                                 binfo->flags);
 280                 bgp_fs_nlri_get_string((unsigned char *)
 281                                        p->u.prefix_flowspec.ptr,
 282                                        p->u.prefix_flowspec.prefixlen,
 283                                        return_string,
 284                                        display,
 285                                        json_nlri_path);
 286                 if (display == NLRI_STRING_FORMAT_LARGE)
 287                         vty_out(vty, "%s", return_string);
 288                 else if (display == NLRI_STRING_FORMAT_DEBUG)
 289                         vty_out(vty, "%s", return_string);
 290                 else if (display == NLRI_STRING_FORMAT_MIN)
 291                         vty_out(vty, " %-30s", return_string);
 292                 else if (json_paths && display == NLRI_STRING_FORMAT_JSON)
 293                         json_object_array_add(json_paths, json_nlri_path);
 294         }
 295         if (!binfo)
 296                 return;
 297         if (binfo->attr && binfo->attr->ecommunity) {
 298                 /* Print attribute */
 299                 attr = binfo->attr;
 300                 s = ecommunity_ecom2str(attr->ecommunity,
 301                                         ECOMMUNITY_FORMAT_ROUTE_MAP, 0);
 302                 if (!s)
 303                         return;
 304                 if (display == NLRI_STRING_FORMAT_LARGE)
 305                         vty_out(vty, "\t%s\n", s);
 306                 else if (display == NLRI_STRING_FORMAT_MIN)
 307                         vty_out(vty, "%s", s);
 308                 else if (json_paths) {
 309                         json_ecom_path = json_object_new_object();
 310                         json_object_string_add(json_ecom_path,
 311                                        "ecomlist", s);
 312                         if (display == NLRI_STRING_FORMAT_JSON)
 313                                 json_object_array_add(json_paths,
 314                                                       json_ecom_path);
 315                 }
 316                 if (attr->nexthop.s_addr != 0 &&
 317                     display == NLRI_STRING_FORMAT_LARGE)
 318                         vty_out(vty, "\tNH %-16s\n", inet_ntoa(attr->nexthop));
 319                 XFREE(MTYPE_ECOMMUNITY_STR, s);
 320         }
 321         peer_uptime(binfo->uptime, timebuf, BGP_UPTIME_LEN, 0, NULL);
 322         if (display == NLRI_STRING_FORMAT_LARGE) {
 323                 vty_out(vty, "\treceived for %8s\n", timebuf);
 324         } else if (json_paths) {
 325                 json_time_path = json_object_new_object();
 326                 json_object_string_add(json_time_path,
 327                                        "time", timebuf);
 328                 if (display == NLRI_STRING_FORMAT_JSON)
 329                         json_object_array_add(json_paths, json_time_path);
 330         }
 331         if (display == NLRI_STRING_FORMAT_LARGE) {
 332                 struct bgp_info_extra *extra = bgp_info_extra_get(binfo);
 333
 334                 if (extra->bgp_fs_pbr) {
 335                         struct listnode *node;
 336                         struct bgp_pbr_match_entry *bpme;
 337                         struct bgp_pbr_match *bpm;
 338                         bool list_began = false;
 339                         struct list *list_bpm;
 340
 341                         list_bpm = list_new();
 342                         if (listcount(extra->bgp_fs_pbr))
 343                                 vty_out(vty, "\tinstalled in PBR");
 344                         for (ALL_LIST_ELEMENTS_RO(extra->bgp_fs_pbr,
 345                                                   node, bpme)) {
 346                                 bpm = bpme->backpointer;
 347                                 if (listnode_lookup(list_bpm, bpm))
 348                                         continue;
 349                                 listnode_add(list_bpm, bpm);
 350                                 if (!list_began) {
 351                                         vty_out(vty, " (");
 352                                         list_began = true;
 353                                 } else
 354                                         vty_out(vty, ", ");
 355                                 vty_out(vty, "%s", bpm->ipset_name);
 356                         }
 357                         if (list_began)
 358                                 vty_out(vty, ")");
 359                         vty_out(vty, "\n");
 360                         list_delete(&list_bpm);
 361                 } else
 362                         vty_out(vty, "\tnot installed in PBR\n");
 363         }
 364 }
 365
 366 int bgp_show_table_flowspec(struct vty *vty, struct bgp *bgp, afi_t afi,
 367                             struct bgp_table *table, enum bgp_show_type type,
 368                             void *output_arg, bool use_json, int is_last,
 369                             unsigned long *output_cum, unsigned long *total_cum)
 370 {
 371         struct bgp_info *ri;
 372         struct bgp_node *rn;
 373         unsigned long total_count = 0;
 374         json_object *json_paths = NULL;
 375         int display = NLRI_STRING_FORMAT_LARGE;
 376
 377         if (type != bgp_show_type_detail)
 378                 return CMD_SUCCESS;
 379
 380         for (rn = bgp_table_top(table); rn; rn = bgp_route_next(rn)) {
 381                 if (rn->info == NULL)
 382                         continue;
 383                 if (use_json) {
 384                         json_paths = json_object_new_array();
 385                         display = NLRI_STRING_FORMAT_JSON;
 386                 }
 387                 for (ri = rn->info; ri; ri = ri->next) {
 388                         total_count++;
 389                         route_vty_out_flowspec(vty, &rn->p,
 390                                                ri, display,
 391                                                json_paths);
 392
 393                 }
 394                 if (use_json) {
 395                         vty_out(vty, "%s\n",
 396                                 json_object_to_json_string_ext(
 397                                                 json_paths,
 398                                                 JSON_C_TO_STRING_PRETTY));
 399                         json_object_free(json_paths);
 400                         json_paths = NULL;
 401                 }
 402         }
 403         if (total_count && !use_json)
 404                 vty_out(vty,
 405                         "\nDisplayed  %ld flowspec entries\n",
 406                         total_count);
 407         return CMD_SUCCESS;
 408 }
 409
 410 DEFUN (debug_bgp_flowspec,
 411        debug_bgp_flowspec_cmd,
 412        "debug bgp flowspec",
 413        DEBUG_STR
 414        BGP_STR
 415        "BGP allow flowspec debugging entries\n")
 416 {
 417         if (vty->node == CONFIG_NODE)
 418                 DEBUG_ON(flowspec, FLOWSPEC);
 419         else {
 420                 TERM_DEBUG_ON(flowspec, FLOWSPEC);
 421                 vty_out(vty, "BGP flowspec debugging is on\n");
 422         }
 423         return CMD_SUCCESS;
 424 }
 425
 426 DEFUN (no_debug_bgp_flowspec,
 427        no_debug_bgp_flowspec_cmd,
 428        "no debug bgp flowspec",
 429        NO_STR
 430        DEBUG_STR
 431        BGP_STR
 432        "BGP allow flowspec debugging entries\n")
 433 {
 434         if (vty->node == CONFIG_NODE)
 435                 DEBUG_OFF(flowspec, FLOWSPEC);
 436         else {
 437                 TERM_DEBUG_OFF(flowspec, FLOWSPEC);
 438                 vty_out(vty, "BGP flowspec debugging is off\n");
 439         }
 440         return CMD_SUCCESS;
 441 }
 442
 443 int bgp_fs_config_write_pbr(struct vty *vty, struct bgp *bgp,
 444                             afi_t afi, safi_t safi)
 445 {
 446         struct bgp_pbr_interface *pbr_if;
 447         bool declare_node = false;
 448         struct bgp_pbr_config *bgp_pbr_cfg = bgp->bgp_pbr_cfg;
 449         struct bgp_pbr_interface_head *head;
 450         bool bgp_pbr_interface_any;
 451
 452         if (!bgp_pbr_cfg || safi != SAFI_FLOWSPEC || afi != AFI_IP)
 453                 return 0;
 454         head = &(bgp_pbr_cfg->ifaces_by_name_ipv4);
 455         bgp_pbr_interface_any = bgp_pbr_cfg->pbr_interface_any_ipv4;
 456         if (!RB_EMPTY(bgp_pbr_interface_head, head) ||
 457              !bgp_pbr_interface_any)
 458                 declare_node = true;
 459         RB_FOREACH (pbr_if, bgp_pbr_interface_head, head) {
 460                 vty_out(vty, "  local-install %s\n", pbr_if->name);
 461         }
 462         return declare_node ? 1 : 0;
 463 }
 464
 465 static int bgp_fs_local_install_interface(struct bgp *bgp,
 466                                           const char *no, const char *ifname)
 467 {
 468         struct bgp_pbr_interface *pbr_if;
 469         struct bgp_pbr_config *bgp_pbr_cfg = bgp->bgp_pbr_cfg;
 470         struct bgp_pbr_interface_head *head;
 471         bool *bgp_pbr_interface_any;
 472
 473         if (!bgp_pbr_cfg)
 474                 return CMD_SUCCESS;
 475         head = &(bgp_pbr_cfg->ifaces_by_name_ipv4);
 476         bgp_pbr_interface_any = &(bgp_pbr_cfg->pbr_interface_any_ipv4);
 477         if (no) {
 478                 if (!ifname) {
 479                         if (*bgp_pbr_interface_any) {
 480                                 *bgp_pbr_interface_any = false;
 481                                 /* remove all other interface list */
 482                                 bgp_pbr_reset(bgp, AFI_IP);
 483                         }
 484                         return CMD_SUCCESS;
 485                 }
 486                 pbr_if = bgp_pbr_interface_lookup(ifname, head);
 487                 if (!pbr_if)
 488                         return CMD_SUCCESS;
 489                 RB_REMOVE(bgp_pbr_interface_head, head, pbr_if);
 490                 return CMD_SUCCESS;
 491         }
 492         if (ifname) {
 493                 pbr_if = bgp_pbr_interface_lookup(ifname, head);
 494                 if (pbr_if)
 495                         return CMD_SUCCESS;
 496                 pbr_if = XCALLOC(MTYPE_TMP,
 497                                  sizeof(struct bgp_pbr_interface));
 498                 strlcpy(pbr_if->name, ifname, INTERFACE_NAMSIZ);
 499                 RB_INSERT(bgp_pbr_interface_head, head, pbr_if);
 500                 *bgp_pbr_interface_any = false;
 501         } else {
 502                 /* set to default */
 503                 if (!*bgp_pbr_interface_any) {
 504                         /* remove all other interface list
 505                          */
 506                         bgp_pbr_reset(bgp, AFI_IP);
 507                         *bgp_pbr_interface_any = true;
 508                 }
 509         }
 510         return CMD_SUCCESS;
 511 }
 512
 513 DEFUN (bgp_fs_local_install_ifname,
 514         bgp_fs_local_install_ifname_cmd,
 515         "[no] local-install INTERFACE",
 516         NO_STR
 517         "Apply local policy routing\n"
 518         "Interface name\n")
 519 {
 520         struct bgp *bgp = VTY_GET_CONTEXT(bgp);
 521         int idx = 0;
 522         const char *no = strmatch(argv[0]->text, "no") ? "no" : NULL;
 523         char *ifname = argv_find(argv, argc, "INTERFACE", &idx) ?
 524                 argv[idx]->arg : NULL;
 525
 526         return bgp_fs_local_install_interface(bgp, no, ifname);
 527 }
 528
 529 extern int bgp_flowspec_display_match_per_ip(afi_t afi, struct bgp_table *rib,
 530                                              struct prefix *match,
 531                                              int prefix_check, struct vty *vty,
 532                                              bool use_json,
 533                                              json_object *json_paths)
 534 {
 535         struct bgp_node *rn;
 536         struct prefix *prefix;
 537         int display = 0;
 538
 539         for (rn = bgp_table_top(rib); rn; rn = bgp_route_next(rn)) {
 540                 prefix = &rn->p;
 541
 542                 if (prefix->family != AF_FLOWSPEC)
 543                         continue;
 544
 545                 if (bgp_flowspec_contains_prefix(prefix, match, prefix_check)) {
 546                         route_vty_out_flowspec(vty, &rn->p,
 547                                                rn->info, use_json ?
 548                                                NLRI_STRING_FORMAT_JSON :
 549                                                NLRI_STRING_FORMAT_LARGE,
 550                                                json_paths);
 551                         display++;
 552                 }
 553         }
 554         return display;
 555 }
 556
 557 void bgp_flowspec_vty_init(void)
 558 {
 559         install_element(ENABLE_NODE, &debug_bgp_flowspec_cmd);
 560         install_element(CONFIG_NODE, &debug_bgp_flowspec_cmd);
 561         install_element(ENABLE_NODE, &no_debug_bgp_flowspec_cmd);
 562         install_element(CONFIG_NODE, &no_debug_bgp_flowspec_cmd);
 563         install_element(BGP_FLOWSPECV4_NODE, &bgp_fs_local_install_ifname_cmd);
 564 }