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 always_inline void
 283 gbp_classify_get_src_ip_address (const ethernet_header_t * eh0,
 284                                  const ip4_address_t ** ip4,
 285                                  const ip6_address_t ** ip6)
 286 {
 287   u16 etype = clib_net_to_host_u16 (eh0->type);
 288   const void *l3h0 = eh0 + 1;
 289
 290   if (ETHERNET_TYPE_VLAN == etype)
 291     {
 292       const ethernet_vlan_header_t *vh0 =
 293         (ethernet_vlan_header_t *) (eh0 + 1);
 294       etype = clib_net_to_host_u16 (vh0->type);
 295       l3h0 = vh0 + 1;
 296     }
 297
 298   switch (etype)
 299     {
 300     case ETHERNET_TYPE_IP4:
 301       *ip4 = &((const ip4_header_t *) l3h0)->src_address;
 302       break;
 303     case ETHERNET_TYPE_IP6:
 304       *ip6 = &((const ip6_header_t *) l3h0)->src_address;
 305       break;
 306     case ETHERNET_TYPE_ARP:
 307       *ip4 = &((ethernet_arp_header_t *) l3h0)->ip4_over_ethernet[0].ip4;
 308       break;
 309     }
 310 }
 311
 312 /**
 313  * per-packet trace data
 314  */
 315 typedef struct gbp_lpm_classify_trace_t_
 316 {
 317   sclass_t sclass;
 318   index_t lbi;
 319   ip46_address_t src;
 320 } gbp_lpm_classify_trace_t;
 321
 322 /* packet trace format function */
 323 static u8 *
 324 format_gbp_lpm_classify_trace (u8 * s, va_list * args)
 325 {
 326   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
 327   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
 328   gbp_lpm_classify_trace_t *t = va_arg (*args, gbp_lpm_classify_trace_t *);
 329
 330   s = format (s, "sclass:%d lb:%d src:%U",
 331               t->sclass, t->lbi, format_ip46_address, &t->src, IP46_TYPE_ANY);
 332
 333   return s;
 334 }
 335
 336 /*
 337  * Determine the SRC EPG from a LPM
 338  */
 339 always_inline uword
 340 gbp_lpm_classify_inline (vlib_main_t * vm,
 341                          vlib_node_runtime_t * node,
 342                          vlib_frame_t * frame,
 343                          dpo_proto_t dproto, u8 is_recirc)
 344 {
 345   gbp_src_classify_main_t *gscm = &gbp_src_classify_main;
 346   u32 n_left_from, *from, *to_next;
 347   u32 next_index;
 348
 349   next_index = 0;
 350   n_left_from = frame->n_vectors;
 351   from = vlib_frame_vector_args (frame);
 352
 353   while (n_left_from > 0)
 354     {
 355       u32 n_left_to_next;
 356
 357       vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
 358
 359       while (n_left_from > 0 && n_left_to_next > 0)
 360         {
 361           u32 bi0, sw_if_index0, fib_index0, lbi0;
 362           const gbp_endpoint_t *ge0, *ge_lpm0;
 363           gbp_lpm_classify_next_t next0;
 364           const ethernet_header_t *eh0;
 365           const gbp_policy_dpo_t *gpd0;
 366           const ip4_address_t *ip4_0;
 367           const ip6_address_t *ip6_0;
 368           const gbp_recirc_t *gr0;
 369           const dpo_id_t *dpo0;
 370           load_balance_t *lb0;
 371           vlib_buffer_t *b0;
 372           sclass_t sclass0;
 373
 374           bi0 = from[0];
 375           to_next[0] = bi0;
 376           from += 1;
 377           to_next += 1;
 378           n_left_from -= 1;
 379           n_left_to_next -= 1;
 380           ip4_0 = NULL;
 381           ip6_0 = NULL;
 382           next0 = GPB_LPM_CLASSIFY_DROP;
 383
 384           lbi0 = ~0;
 385           eh0 = NULL;
 386           b0 = vlib_get_buffer (vm, bi0);
 387
 388           sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];
 389           vnet_buffer2 (b0)->gbp.flags = VXLAN_GBP_GPFLAGS_NONE;
 390
 391           if (DPO_PROTO_IP4 == dproto)
 392             ip4_0 =
 393               &((ip4_header_t *) vlib_buffer_get_current (b0))->src_address;
 394           else if (DPO_PROTO_IP6 == dproto)
 395             ip6_0 =
 396               &((ip6_header_t *) vlib_buffer_get_current (b0))->src_address;
 397           else if (DPO_PROTO_ETHERNET == dproto)
 398             {
 399               eh0 = vlib_buffer_get_current (b0);
 400               gbp_classify_get_src_ip_address (eh0, &ip4_0, &ip6_0);
 401             }
 402
 403           if (is_recirc)
 404             {
 405               gr0 = gbp_recirc_get (sw_if_index0);
 406               fib_index0 = gr0->gr_fib_index[dproto];
 407               ge0 = NULL;
 408
 409               vnet_feature_next (&next0, b0);
 410             }
 411           else
 412             {
 413               if (NULL == eh0)
 414                 {
 415                   /* packet should be l2 */
 416                   sclass0 = SCLASS_INVALID;
 417                   goto trace;
 418                 }
 419
 420               ge0 = gbp_endpoint_find_mac (eh0->src_address,
 421                                            vnet_buffer (b0)->l2.bd_index);
 422
 423               if (NULL == ge0)
 424                 {
 425                   /* packet must have come from an EP's mac */
 426                   sclass0 = SCLASS_INVALID;
 427                   goto trace;
 428                 }
 429
 430               fib_index0 = ge0->ge_fwd.gef_fib_index;
 431
 432               if (~0 == fib_index0)
 433                 {
 434                   sclass0 = SCLASS_INVALID;
 435                   goto trace;
 436                 }
 437
 438               if (ip4_0)
 439                 {
 440                   ge_lpm0 = gbp_endpoint_find_ip4 (ip4_0, fib_index0);
 441                 }
 442               else if (ip6_0)
 443                 {
 444                   ge_lpm0 = gbp_endpoint_find_ip6 (ip6_0, fib_index0);
 445                 }
 446               else
 447                 {
 448                   ge_lpm0 = NULL;
 449                 }
 450
 451               next0 = vnet_l2_feature_next
 452                 (b0, gscm->l2_input_feat_next[GBP_SRC_CLASSIFY_LPM],
 453                  L2INPUT_FEAT_GBP_LPM_CLASSIFY);
 454
 455               /*
 456                * if we found the EP by IP lookup, it must be from the EP
 457                * not a network behind it
 458                */
 459               if (NULL != ge_lpm0)
 460                 {
 461                   if (PREDICT_FALSE (ge0 != ge_lpm0))
 462                     {
 463                       /* an EP spoofing another EP */
 464                       sclass0 = SCLASS_INVALID;
 465                       next0 = GPB_LPM_CLASSIFY_DROP;
 466                     }
 467                   else
 468                     {
 469                       sclass0 = ge0->ge_fwd.gef_sclass;
 470                     }
 471                   goto trace;
 472                 }
 473             }
 474
 475           if (ip4_0)
 476             {
 477               lbi0 = ip4_fib_forwarding_lookup (fib_index0, ip4_0);
 478             }
 479           else if (ip6_0)
 480             {
 481               lbi0 =
 482                 ip6_fib_table_fwding_lookup (&ip6_main, fib_index0, ip6_0);
 483             }
 484           else
 485             {
 486               /* not IP so no LPM classify possible */
 487               sclass0 = SCLASS_INVALID;
 488               next0 = GPB_LPM_CLASSIFY_DROP;
 489               goto trace;
 490             }
 491           lb0 = load_balance_get (lbi0);
 492           dpo0 = load_balance_get_bucket_i (lb0, 0);
 493
 494           /* all packets from an external network should not be learned by the
 495            * reciever. so set the Do-not-learn bit here */
 496           vnet_buffer2 (b0)->gbp.flags = VXLAN_GBP_GPFLAGS_D;
 497
 498           if (gbp_policy_dpo_type == dpo0->dpoi_type)
 499             {
 500               gpd0 = gbp_policy_dpo_get (dpo0->dpoi_index);
 501               sclass0 = gpd0->gpd_sclass;
 502             }
 503           else
 504             {
 505               /* could not classify => drop */
 506               sclass0 = SCLASS_INVALID;
 507               goto trace;
 508             }
 509
 510         trace:
 511           vnet_buffer2 (b0)->gbp.sclass = sclass0;
 512
 513           if (PREDICT_FALSE ((b0->flags & VLIB_BUFFER_IS_TRACED)))
 514             {
 515               gbp_lpm_classify_trace_t *t =
 516                 vlib_add_trace (vm, node, b0, sizeof (*t));
 517               t->sclass = sclass0;
 518               t->lbi = lbi0;
 519               if (ip4_0)
 520                 t->src.ip4 = *ip4_0;
 521               if (ip6_0)
 522                 t->src.ip6 = *ip6_0;
 523             }
 524
 525           vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
 526                                            to_next, n_left_to_next,
 527                                            bi0, next0);
 528         }
 529
 530       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
 531     }
 532
 533   return frame->n_vectors;
 534 }
 535
 536 VLIB_NODE_FN (gbp_ip4_lpm_classify_node) (vlib_main_t * vm,
 537                                           vlib_node_runtime_t * node,
 538                                           vlib_frame_t * frame)
 539 {
 540   return (gbp_lpm_classify_inline (vm, node, frame, DPO_PROTO_IP4, 1));
 541 }
 542
 543 VLIB_NODE_FN (gbp_ip6_lpm_classify_node) (vlib_main_t * vm,
 544                                           vlib_node_runtime_t * node,
 545                                           vlib_frame_t * frame)
 546 {
 547   return (gbp_lpm_classify_inline (vm, node, frame, DPO_PROTO_IP6, 1));
 548 }
 549
 550 VLIB_NODE_FN (gbp_l2_lpm_classify_node) (vlib_main_t * vm,
 551                                          vlib_node_runtime_t * node,
 552                                          vlib_frame_t * frame)
 553 {
 554   return (gbp_lpm_classify_inline (vm, node, frame, DPO_PROTO_ETHERNET, 0));
 555 }
 556
 557 /* *INDENT-OFF* */
 558 VLIB_REGISTER_NODE (gbp_ip4_lpm_classify_node) = {
 559   .name = "ip4-gbp-lpm-classify",
 560   .vector_size = sizeof (u32),
 561   .format_trace = format_gbp_lpm_classify_trace,
 562   .type = VLIB_NODE_TYPE_INTERNAL,
 563
 564   .n_errors = 0,
 565   .n_next_nodes = 1,
 566   .next_nodes = {
 567     [GPB_LPM_CLASSIFY_DROP] = "ip4-drop"
 568   },
 569 };
 570
 571 VLIB_REGISTER_NODE (gbp_ip6_lpm_classify_node) = {
 572   .name = "ip6-gbp-lpm-classify",
 573   .vector_size = sizeof (u32),
 574   .format_trace = format_gbp_lpm_classify_trace,
 575   .type = VLIB_NODE_TYPE_INTERNAL,
 576
 577   .n_errors = 0,
 578   .n_next_nodes = 1,
 579   .next_nodes = {
 580     [GPB_LPM_CLASSIFY_DROP] = "ip6-drop"
 581   },
 582 };
 583
 584 VLIB_REGISTER_NODE (gbp_l2_lpm_classify_node) = {
 585   .name = "l2-gbp-lpm-classify",
 586   .vector_size = sizeof (u32),
 587   .format_trace = format_gbp_lpm_classify_trace,
 588   .type = VLIB_NODE_TYPE_INTERNAL,
 589
 590   .n_errors = 0,
 591   .n_next_nodes = 1,
 592   .next_nodes = {
 593     [GPB_LPM_CLASSIFY_DROP] = "error-drop"
 594   },
 595 };
 596
 597 VNET_FEATURE_INIT (gbp_ip4_lpm_classify_feat_node, static) =
 598 {
 599   .arc_name = "ip4-unicast",
 600   .node_name = "ip4-gbp-lpm-classify",
 601   .runs_before = VNET_FEATURES ("nat44-out2in"),
 602 };
 603 VNET_FEATURE_INIT (gbp_ip6_lpm_classify_feat_node, static) =
 604 {
 605   .arc_name = "ip6-unicast",
 606   .node_name = "ip6-gbp-lpm-classify",
 607   .runs_before = VNET_FEATURES ("nat66-out2in"),
 608 };
 609
 610 /* *INDENT-ON* */
 611
 612 /*
 613  * fd.io coding-style-patch-verification: ON
 614  *
 615  * Local Variables:
 616  * eval: (c-set-style "gnu")
 617  * End:
 618  */