src/plugins/gbp/gbp_classify_node.c

   1 /*
   2  * gbp.h : Group Based Policy
   3  *
   4  * Copyright (c) 2018 Cisco and/or its affiliates.
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at:
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 #include <plugins/gbp/gbp.h>
  19 #include <plugins/gbp/gbp_classify.h>
  20 #include <plugins/gbp/gbp_policy_dpo.h>
  21 #include <plugins/gbp/gbp_ext_itf.h>
  22 #include <vnet/fib/ip4_fib.h>
  23 #include <vnet/fib/ip6_fib.h>
  24 #include <vnet/dpo/load_balance.h>
  25 #include <vnet/l2/l2_input.h>
  26 #include <vnet/l2/feat_bitmap.h>
  27 #include <vnet/fib/fib_table.h>
  28 #include <vnet/vxlan-gbp/vxlan_gbp_packet.h>
  29 #include <vnet/ethernet/arp_packet.h>
  30
  31 /**
  32  * per-packet trace data
  33  */
  34 typedef struct gbp_classify_trace_t_
  35 {
  36   /* per-pkt trace data */
  37   sclass_t sclass;
  38 } gbp_classify_trace_t;
  39
  40 /*
  41  * determine the SRC EPG form the input port
  42  */
  43 always_inline uword
  44 gbp_classify_inline (vlib_main_t * vm,
  45                      vlib_node_runtime_t * node,
  46                      vlib_frame_t * frame,
  47                      gbp_src_classify_type_t type, dpo_proto_t dproto)
  48 {
  49   gbp_src_classify_main_t *gscm = &gbp_src_classify_main;
  50   u32 n_left_from, *from, *to_next;
  51   u32 next_index;
  52
  53   next_index = 0;
  54   n_left_from = frame->n_vectors;
  55   from = vlib_frame_vector_args (frame);
  56
  57   while (n_left_from > 0)
  58     {
  59       u32 n_left_to_next;
  60
  61       vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
  62
  63       while (n_left_from > 0 && n_left_to_next > 0)
  64         {
  65           u32 next0, bi0, sw_if_index0;
  66           const gbp_endpoint_t *ge0;
  67           vlib_buffer_t *b0;
  68           sclass_t sclass0;
  69
  70           bi0 = from[0];
  71           to_next[0] = bi0;
  72           from += 1;
  73           to_next += 1;
  74           n_left_from -= 1;
  75           n_left_to_next -= 1;
  76
  77           b0 = vlib_get_buffer (vm, bi0);
  78
  79           sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];
  80           vnet_buffer2 (b0)->gbp.flags = VXLAN_GBP_GPFLAGS_NONE;
  81
  82           if (GBP_SRC_CLASSIFY_NULL == type)
  83             {
  84               sclass0 = SCLASS_INVALID;
  85               next0 =
  86                 vnet_l2_feature_next (b0, gscm->l2_input_feat_next[type],
  87                                       L2INPUT_FEAT_GBP_NULL_CLASSIFY);
  88             }
  89           else
  90             {
  91               if (DPO_PROTO_ETHERNET == dproto)
  92                 {
  93                   const ethernet_header_t *h0;
  94
  95                   h0 = vlib_buffer_get_current (b0);
  96                   next0 =
  97                     vnet_l2_feature_next (b0, gscm->l2_input_feat_next[type],
  98                                           L2INPUT_FEAT_GBP_SRC_CLASSIFY);
  99                   ge0 = gbp_endpoint_find_mac (h0->src_address,
 100                                                vnet_buffer (b0)->l2.bd_index);
 101                 }
 102               else if (DPO_PROTO_IP4 == dproto)
 103                 {
 104                   const ip4_header_t *h0;
 105
 106                   h0 = vlib_buffer_get_current (b0);
 107
 108                   ge0 = gbp_endpoint_find_ip4
 109                     (&h0->src_address,
 110                      fib_table_get_index_for_sw_if_index (FIB_PROTOCOL_IP4,
 111                                                           sw_if_index0));
 112
 113
 114                   /*
 115                    * Go straight to looukp, do not pass go, do not collect $200
 116                    */
 117                   next0 = 0;
 118                 }
 119               else if (DPO_PROTO_IP6 == dproto)
 120                 {
 121                   const ip6_header_t *h0;
 122
 123                   h0 = vlib_buffer_get_current (b0);
 124
 125                   ge0 = gbp_endpoint_find_ip6
 126                     (&h0->src_address,
 127                      fib_table_get_index_for_sw_if_index (FIB_PROTOCOL_IP6,
 128                                                           sw_if_index0));
 129
 130
 131                   /*
 132                    * Go straight to lookup, do not pass go, do not collect $200
 133                    */
 134                   next0 = 0;
 135                 }
 136               else
 137                 {
 138                   ge0 = NULL;
 139                   next0 = 0;
 140                   ASSERT (0);
 141                 }
 142
 143               if (PREDICT_TRUE (NULL != ge0))
 144                 sclass0 = ge0->ge_fwd.gef_sclass;
 145               else
 146                 sclass0 = SCLASS_INVALID;
 147             }
 148
 149           vnet_buffer2 (b0)->gbp.sclass = sclass0;
 150
 151           if (PREDICT_FALSE ((b0->flags & VLIB_BUFFER_IS_TRACED)))
 152             {
 153               gbp_classify_trace_t *t =
 154                 vlib_add_trace (vm, node, b0, sizeof (*t));
 155               t->sclass = sclass0;
 156             }
 157
 158           vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
 159                                            to_next, n_left_to_next,
 160                                            bi0, next0);
 161         }
 162
 163       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
 164     }
 165
 166   return frame->n_vectors;
 167 }
 168
 169 VLIB_NODE_FN (gbp_src_classify_node) (vlib_main_t * vm,
 170                                       vlib_node_runtime_t * node,
 171                                       vlib_frame_t * frame)
 172 {
 173   return (gbp_classify_inline (vm, node, frame,
 174                                GBP_SRC_CLASSIFY_PORT, DPO_PROTO_ETHERNET));
 175 }
 176
 177 VLIB_NODE_FN (gbp_null_classify_node) (vlib_main_t * vm,
 178                                        vlib_node_runtime_t * node,
 179                                        vlib_frame_t * frame)
 180 {
 181   return (gbp_classify_inline (vm, node, frame,
 182                                GBP_SRC_CLASSIFY_NULL, DPO_PROTO_ETHERNET));
 183 }
 184
 185 VLIB_NODE_FN (gbp_ip4_src_classify_node) (vlib_main_t * vm,
 186                                           vlib_node_runtime_t * node,
 187                                           vlib_frame_t * frame)
 188 {
 189   return (gbp_classify_inline (vm, node, frame,
 190                                GBP_SRC_CLASSIFY_PORT, DPO_PROTO_IP4));
 191 }
 192
 193 VLIB_NODE_FN (gbp_ip6_src_classify_node) (vlib_main_t * vm,
 194                                           vlib_node_runtime_t * node,
 195                                           vlib_frame_t * frame)
 196 {
 197   return (gbp_classify_inline (vm, node, frame,
 198                                GBP_SRC_CLASSIFY_PORT, DPO_PROTO_IP6));
 199 }
 200
 201
 202 /* packet trace format function */
 203 static u8 *
 204 format_gbp_classify_trace (u8 * s, va_list * args)
 205 {
 206   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
 207   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
 208   gbp_classify_trace_t *t = va_arg (*args, gbp_classify_trace_t *);
 209
 210   s = format (s, "sclass:%d", t->sclass);
 211
 212   return s;
 213 }
 214
 215 /* *INDENT-OFF* */
 216 VLIB_REGISTER_NODE (gbp_null_classify_node) = {
 217   .name = "gbp-null-classify",
 218   .vector_size = sizeof (u32),
 219   .format_trace = format_gbp_classify_trace,
 220   .type = VLIB_NODE_TYPE_INTERNAL,
 221
 222   .n_errors = 0,
 223   .n_next_nodes = 0,
 224 };
 225
 226 VLIB_REGISTER_NODE (gbp_src_classify_node) = {
 227   .name = "gbp-src-classify",
 228   .vector_size = sizeof (u32),
 229   .format_trace = format_gbp_classify_trace,
 230   .type = VLIB_NODE_TYPE_INTERNAL,
 231
 232   .n_errors = 0,
 233   .n_next_nodes = 0,
 234 };
 235
 236 VLIB_REGISTER_NODE (gbp_ip4_src_classify_node) = {
 237   .name = "ip4-gbp-src-classify",
 238   .vector_size = sizeof (u32),
 239   .format_trace = format_gbp_classify_trace,
 240   .type = VLIB_NODE_TYPE_INTERNAL,
 241
 242   .n_errors = 0,
 243   .n_next_nodes = 1,
 244   .next_nodes = {
 245     [0] = "ip4-lookup"
 246   },
 247 };
 248
 249 VLIB_REGISTER_NODE (gbp_ip6_src_classify_node) = {
 250   .name = "ip6-gbp-src-classify",
 251   .vector_size = sizeof (u32),
 252   .format_trace = format_gbp_classify_trace,
 253   .type = VLIB_NODE_TYPE_INTERNAL,
 254
 255   .n_errors = 0,
 256   .n_next_nodes = 1,
 257   .next_nodes = {
 258     [0] = "ip6-lookup"
 259   },
 260 };
 261
 262 VNET_FEATURE_INIT (gbp_ip4_src_classify_feat_node, static) =
 263 {
 264   .arc_name = "ip4-unicast",
 265   .node_name = "ip4-gbp-src-classify",
 266   .runs_before = VNET_FEATURES ("nat44-out2in"),
 267 };
 268 VNET_FEATURE_INIT (gbp_ip6_src_classify_feat_node, static) =
 269 {
 270   .arc_name = "ip6-unicast",
 271   .node_name = "ip6-gbp-src-classify",
 272   .runs_before = VNET_FEATURES ("nat66-out2in"),
 273 };
 274
 275 /* *INDENT-ON* */
 276
 277 typedef enum gbp_lpm_classify_next_t_
 278 {
 279   GPB_LPM_CLASSIFY_DROP,
 280 } gbp_lpm_classify_next_t;
 281
 282 /**
 283  * per-packet trace data
 284  */
 285 typedef struct gbp_lpm_classify_trace_t_
 286 {
 287   sclass_t sclass;
 288   index_t lbi;
 289   ip46_address_t src;
 290 } gbp_lpm_classify_trace_t;
 291
 292 /* packet trace format function */
 293 static u8 *
 294 format_gbp_lpm_classify_trace (u8 * s, va_list * args)
 295 {
 296   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
 297   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
 298   gbp_lpm_classify_trace_t *t = va_arg (*args, gbp_lpm_classify_trace_t *);
 299
 300   s = format (s, "sclass:%d lb:%d src:%U",
 301               t->sclass, t->lbi, format_ip46_address, &t->src, IP46_TYPE_ANY);
 302
 303   return s;
 304 }
 305
 306 enum gbp_lpm_type
 307 {
 308   GBP_LPM_RECIRC,
 309   GBP_LPM_EPG,
 310   GBP_LPM_ANON
 311 };
 312
 313 /*
 314  * Determine the SRC EPG from a LPM
 315  */
 316 always_inline uword
 317 gbp_lpm_classify_inline (vlib_main_t * vm,
 318                          vlib_node_runtime_t * node,
 319                          vlib_frame_t * frame,
 320                          const dpo_proto_t dproto,
 321                          const enum gbp_lpm_type type)
 322 {
 323   gbp_src_classify_main_t *gscm = &gbp_src_classify_main;
 324   u32 n_left_from, *from, *to_next;
 325   u32 next_index;
 326
 327   next_index = 0;
 328   n_left_from = frame->n_vectors;
 329   from = vlib_frame_vector_args (frame);
 330
 331   while (n_left_from > 0)
 332     {
 333       u32 n_left_to_next;
 334
 335       vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
 336
 337       while (n_left_from > 0 && n_left_to_next > 0)
 338         {
 339           u32 bi0, sw_if_index0, fib_index0, lbi0;
 340           const gbp_endpoint_t *ge0, *ge_lpm0;
 341           gbp_lpm_classify_next_t next0;
 342           const ethernet_header_t *eh0;
 343           const gbp_policy_dpo_t *gpd0;
 344           const ip4_address_t *ip4_0;
 345           const ip6_address_t *ip6_0;
 346           const gbp_recirc_t *gr0;
 347           vlib_buffer_t *b0;
 348           sclass_t sclass0;
 349
 350           bi0 = from[0];
 351           to_next[0] = bi0;
 352           from += 1;
 353           to_next += 1;
 354           n_left_from -= 1;
 355           n_left_to_next -= 1;
 356           ip4_0 = NULL;
 357           ip6_0 = NULL;
 358           next0 = GPB_LPM_CLASSIFY_DROP;
 359
 360           lbi0 = ~0;
 361           eh0 = NULL;
 362           b0 = vlib_get_buffer (vm, bi0);
 363
 364           sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];
 365           vnet_buffer2 (b0)->gbp.flags = VXLAN_GBP_GPFLAGS_NONE;
 366
 367           if (DPO_PROTO_IP4 == dproto)
 368             ip4_0 =
 369               &((ip4_header_t *) vlib_buffer_get_current (b0))->src_address;
 370           else if (DPO_PROTO_IP6 == dproto)
 371             ip6_0 =
 372               &((ip6_header_t *) vlib_buffer_get_current (b0))->src_address;
 373           else if (DPO_PROTO_ETHERNET == dproto)
 374             {
 375               eh0 = vlib_buffer_get_current (b0);
 376               gbp_classify_get_ip_address (eh0, &ip4_0, &ip6_0,
 377                                            GBP_CLASSIFY_GET_IP_SRC);
 378             }
 379
 380           if (GBP_LPM_RECIRC == type)
 381             {
 382               gr0 = gbp_recirc_get (sw_if_index0);
 383               fib_index0 = gr0->gr_fib_index[dproto];
 384               ge0 = NULL;
 385
 386               vnet_feature_next (&next0, b0);
 387             }
 388           else
 389             {
 390               if (NULL == eh0)
 391                 {
 392                   /* packet should be l2 */
 393                   sclass0 = SCLASS_INVALID;
 394                   goto trace;
 395                 }
 396
 397               if (GBP_LPM_ANON == type)
 398                 {
 399                   /*
 400                    * anonymous LPM classification: only honour LPM as no EP
 401                    * were programmed
 402                    */
 403                   gbp_ext_itf_t *gei = gbp_ext_itf_get (sw_if_index0);
 404                   if (ip4_0)
 405                     fib_index0 = gei->gx_fib_index[DPO_PROTO_IP4];
 406                   else if (ip6_0)
 407                     fib_index0 = gei->gx_fib_index[DPO_PROTO_IP6];
 408                   else
 409                     {
 410                       /* not IP so no LPM classify possible */
 411                       sclass0 = SCLASS_INVALID;
 412                       next0 = GPB_LPM_CLASSIFY_DROP;
 413                       goto trace;
 414                     }
 415                   next0 = vnet_l2_feature_next
 416                     (b0, gscm->l2_input_feat_next[GBP_SRC_CLASSIFY_LPM_ANON],
 417                      L2INPUT_FEAT_GBP_LPM_ANON_CLASSIFY);
 418                 }
 419               else
 420                 {
 421                   /*
 422                    * not an anonymous LPM classification: check it comes from
 423                    * an EP, and use EP RD info
 424                    */
 425                   ge0 = gbp_endpoint_find_mac (eh0->src_address,
 426                                                vnet_buffer (b0)->l2.bd_index);
 427
 428                   if (NULL == ge0)
 429                     {
 430                       /* packet must have come from an EP's mac */
 431                       sclass0 = SCLASS_INVALID;
 432                       goto trace;
 433                     }
 434
 435                   fib_index0 = ge0->ge_fwd.gef_fib_index;
 436
 437                   if (~0 == fib_index0)
 438                     {
 439                       sclass0 = SCLASS_INVALID;
 440                       goto trace;
 441                     }
 442
 443                   if (ip4_0)
 444                     {
 445                       ge_lpm0 = gbp_endpoint_find_ip4 (ip4_0, fib_index0);
 446                     }
 447                   else if (ip6_0)
 448                     {
 449                       ge_lpm0 = gbp_endpoint_find_ip6 (ip6_0, fib_index0);
 450                     }
 451                   else
 452                     {
 453                       ge_lpm0 = NULL;
 454                     }
 455
 456                   next0 = vnet_l2_feature_next
 457                     (b0, gscm->l2_input_feat_next[GBP_SRC_CLASSIFY_LPM],
 458                      L2INPUT_FEAT_GBP_LPM_CLASSIFY);
 459
 460                   /*
 461                    * if we found the EP by IP lookup, it must be from the EP
 462                    * not a network behind it
 463                    */
 464                   if (NULL != ge_lpm0)
 465                     {
 466                       if (PREDICT_FALSE (ge0 != ge_lpm0))
 467                         {
 468                           /* an EP spoofing another EP */
 469                           sclass0 = SCLASS_INVALID;
 470                           next0 = GPB_LPM_CLASSIFY_DROP;
 471                         }
 472                       else
 473                         {
 474                           sclass0 = ge0->ge_fwd.gef_sclass;
 475                         }
 476                       goto trace;
 477                     }
 478                 }
 479             }
 480
 481           gpd0 = gbp_classify_get_gpd (ip4_0, ip6_0, fib_index0);
 482           if (0 == gpd0)
 483             {
 484               /* could not classify => drop */
 485               sclass0 = SCLASS_INVALID;
 486               next0 = GPB_LPM_CLASSIFY_DROP;
 487               goto trace;
 488             }
 489
 490           sclass0 = gpd0->gpd_sclass;
 491
 492           /* all packets from an external network should not be learned by the
 493            * reciever. so set the Do-not-learn bit here */
 494           vnet_buffer2 (b0)->gbp.flags = VXLAN_GBP_GPFLAGS_D;
 495
 496         trace:
 497           vnet_buffer2 (b0)->gbp.sclass = sclass0;
 498
 499           if (PREDICT_FALSE ((b0->flags & VLIB_BUFFER_IS_TRACED)))
 500             {
 501               gbp_lpm_classify_trace_t *t =
 502                 vlib_add_trace (vm, node, b0, sizeof (*t));
 503               t->sclass = sclass0;
 504               t->lbi = lbi0;
 505               if (ip4_0)
 506                 t->src.ip4 = *ip4_0;
 507               if (ip6_0)
 508                 t->src.ip6 = *ip6_0;
 509             }
 510
 511           vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
 512                                            to_next, n_left_to_next,
 513                                            bi0, next0);
 514         }
 515
 516       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
 517     }
 518
 519   return frame->n_vectors;
 520 }
 521
 522 VLIB_NODE_FN (gbp_ip4_lpm_classify_node) (vlib_main_t * vm,
 523                                           vlib_node_runtime_t * node,
 524                                           vlib_frame_t * frame)
 525 {
 526   return (gbp_lpm_classify_inline
 527           (vm, node, frame, DPO_PROTO_IP4, GBP_LPM_RECIRC));
 528 }
 529
 530 VLIB_NODE_FN (gbp_ip6_lpm_classify_node) (vlib_main_t * vm,
 531                                           vlib_node_runtime_t * node,
 532                                           vlib_frame_t * frame)
 533 {
 534   return (gbp_lpm_classify_inline
 535           (vm, node, frame, DPO_PROTO_IP6, GBP_LPM_RECIRC));
 536 }
 537
 538 VLIB_NODE_FN (gbp_l2_lpm_classify_node) (vlib_main_t * vm,
 539                                          vlib_node_runtime_t * node,
 540                                          vlib_frame_t * frame)
 541 {
 542   return (gbp_lpm_classify_inline
 543           (vm, node, frame, DPO_PROTO_ETHERNET, GBP_LPM_EPG));
 544 }
 545
 546 VLIB_NODE_FN (gbp_l2_lpm_anon_classify_node) (vlib_main_t * vm,
 547                                               vlib_node_runtime_t * node,
 548                                               vlib_frame_t * frame)
 549 {
 550   return (gbp_lpm_classify_inline
 551           (vm, node, frame, DPO_PROTO_ETHERNET, GBP_LPM_ANON));
 552 }
 553
 554 /* *INDENT-OFF* */
 555 VLIB_REGISTER_NODE (gbp_ip4_lpm_classify_node) = {
 556   .name = "ip4-gbp-lpm-classify",
 557   .vector_size = sizeof (u32),
 558   .format_trace = format_gbp_lpm_classify_trace,
 559   .type = VLIB_NODE_TYPE_INTERNAL,
 560
 561   .n_errors = 0,
 562   .n_next_nodes = 1,
 563   .next_nodes = {
 564     [GPB_LPM_CLASSIFY_DROP] = "ip4-drop"
 565   },
 566 };
 567
 568 VLIB_REGISTER_NODE (gbp_ip6_lpm_classify_node) = {
 569   .name = "ip6-gbp-lpm-classify",
 570   .vector_size = sizeof (u32),
 571   .format_trace = format_gbp_lpm_classify_trace,
 572   .type = VLIB_NODE_TYPE_INTERNAL,
 573
 574   .n_errors = 0,
 575   .n_next_nodes = 1,
 576   .next_nodes = {
 577     [GPB_LPM_CLASSIFY_DROP] = "ip6-drop"
 578   },
 579 };
 580
 581 VLIB_REGISTER_NODE (gbp_l2_lpm_classify_node) = {
 582   .name = "l2-gbp-lpm-classify",
 583   .vector_size = sizeof (u32),
 584   .format_trace = format_gbp_lpm_classify_trace,
 585   .type = VLIB_NODE_TYPE_INTERNAL,
 586
 587   .n_errors = 0,
 588   .n_next_nodes = 1,
 589   .next_nodes = {
 590     [GPB_LPM_CLASSIFY_DROP] = "error-drop"
 591   },
 592 };
 593
 594 VLIB_REGISTER_NODE (gbp_l2_lpm_anon_classify_node) = {
 595   .name = "l2-gbp-lpm-anon-classify",
 596   .vector_size = sizeof (u32),
 597   .format_trace = format_gbp_lpm_classify_trace,
 598   .type = VLIB_NODE_TYPE_INTERNAL,
 599
 600   .n_errors = 0,
 601   .n_next_nodes = 1,
 602   .next_nodes = {
 603     [GPB_LPM_CLASSIFY_DROP] = "error-drop"
 604   },
 605 };
 606
 607 VNET_FEATURE_INIT (gbp_ip4_lpm_classify_feat_node, static) =
 608 {
 609   .arc_name = "ip4-unicast",
 610   .node_name = "ip4-gbp-lpm-classify",
 611   .runs_before = VNET_FEATURES ("nat44-out2in"),
 612 };
 613 VNET_FEATURE_INIT (gbp_ip6_lpm_classify_feat_node, static) =
 614 {
 615   .arc_name = "ip6-unicast",
 616   .node_name = "ip6-gbp-lpm-classify",
 617   .runs_before = VNET_FEATURES ("nat66-out2in"),
 618 };
 619
 620 /* *INDENT-ON* */
 621
 622 /*
 623  * fd.io coding-style-patch-verification: ON
 624  *
 625  * Local Variables:
 626  * eval: (c-set-style "gnu")
 627  * End:
 628  */