src/vnet/ip/ip4_source_and_port_range_check.c

   1 /*
   2  * Copyright (c) 2016 Cisco and/or its affiliates.
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at:
   6  *
   7  *         http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15 #include <vnet/ip/ip.h>
  16 #include <vnet/ip/ip_source_and_port_range_check.h>
  17 #include <vnet/dpo/load_balance.h>
  18 #include <vnet/fib/fib_table.h>
  19 #include <vnet/fib/ip4_fib.h>
  20
  21 source_range_check_main_t source_range_check_main;
  22
  23 /**
  24  * @file
  25  * @brief IPv4 Source and Port Range Checking.
  26  *
  27  * This file contains the source code for IPv4 source and port range
  28  * checking.
  29  */
  30
  31
  32 /**
  33  * @brief The pool of range chack DPOs
  34  */
  35 static protocol_port_range_dpo_t *ppr_dpo_pool;
  36
  37 /**
  38  * @brief Dynamically registered DPO type
  39  */
  40 static dpo_type_t ppr_dpo_type;
  41
  42 vlib_node_registration_t ip4_source_port_and_range_check_rx;
  43 vlib_node_registration_t ip4_source_port_and_range_check_tx;
  44
  45 #define foreach_ip4_source_and_port_range_check_error                   \
  46   _(CHECK_FAIL, "ip4 source and port range check bad packets")  \
  47   _(CHECK_OK, "ip4 source and port range check good packets")
  48
  49 typedef enum
  50 {
  51 #define _(sym,str) IP4_SOURCE_AND_PORT_RANGE_CHECK_ERROR_##sym,
  52   foreach_ip4_source_and_port_range_check_error
  53 #undef _
  54     IP4_SOURCE_AND_PORT_RANGE_CHECK_N_ERROR,
  55 } ip4_source_and_port_range_check_error_t;
  56
  57 static char *ip4_source_and_port_range_check_error_strings[] = {
  58 #define _(sym,string) string,
  59   foreach_ip4_source_and_port_range_check_error
  60 #undef _
  61 };
  62
  63 typedef struct
  64 {
  65   u32 pass;
  66   u32 bypass;
  67   u32 is_tcp;
  68   ip4_address_t src_addr;
  69   u16 port;
  70   u32 fib_index;
  71 } ip4_source_and_port_range_check_trace_t;
  72
  73 static u8 *
  74 format_ip4_source_and_port_range_check_trace (u8 * s, va_list * va)
  75 {
  76   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*va, vlib_main_t *);
  77   CLIB_UNUSED (vlib_node_t * node) = va_arg (*va, vlib_node_t *);
  78   ip4_source_and_port_range_check_trace_t *t =
  79     va_arg (*va, ip4_source_and_port_range_check_trace_t *);
  80
  81   if (t->bypass)
  82     s = format (s, "PASS (bypass case)");
  83   else
  84     s = format (s, "fib %d src ip %U %s dst port %d: %s",
  85                 t->fib_index, format_ip4_address, &t->src_addr,
  86                 t->is_tcp ? "TCP" : "UDP", (u32) t->port,
  87                 (t->pass == 1) ? "PASS" : "FAIL");
  88   return s;
  89 }
  90
  91 typedef enum
  92 {
  93   IP4_SOURCE_AND_PORT_RANGE_CHECK_NEXT_DROP,
  94   IP4_SOURCE_AND_PORT_RANGE_CHECK_N_NEXT,
  95 } ip4_source_and_port_range_check_next_t;
  96
  97
  98 static inline u32
  99 check_adj_port_range_x1 (const protocol_port_range_dpo_t * ppr_dpo,
 100                          u16 dst_port, u32 next)
 101 {
 102 #ifdef CLIB_HAVE_VEC128
 103   u16x8 key = u16x8_splat (dst_port);
 104 #endif
 105   int i;
 106
 107   if (NULL == ppr_dpo || dst_port == 0)
 108     return IP4_SOURCE_AND_PORT_RANGE_CHECK_NEXT_DROP;
 109
 110
 111   for (i = 0; i < ppr_dpo->n_used_blocks; i++)
 112 #ifdef CLIB_HAVE_VEC128
 113     if (!u16x8_is_all_zero ((ppr_dpo->blocks[i].low.as_u16x8 <= key) &
 114                             (ppr_dpo->blocks[i].hi.as_u16x8 >= key)))
 115       return next;
 116 #else
 117     {
 118       for (int j = 0; j < 8; j++)
 119         {
 120           if ((ppr_dpo->blocks[i].low.as_u16[j] <= dst_port) &&
 121               (ppr_dpo->blocks[i].hi.as_u16[j] >= dst_port))
 122             return next;
 123         }
 124     };
 125 #endif
 126
 127   return IP4_SOURCE_AND_PORT_RANGE_CHECK_NEXT_DROP;
 128 }
 129
 130 always_inline protocol_port_range_dpo_t *
 131 protocol_port_range_dpo_get (index_t index)
 132 {
 133   return (pool_elt_at_index (ppr_dpo_pool, index));
 134 }
 135
 136 always_inline uword
 137 ip4_source_and_port_range_check_inline (vlib_main_t * vm,
 138                                         vlib_node_runtime_t * node,
 139                                         vlib_frame_t * frame, int is_tx)
 140 {
 141   ip4_main_t *im = &ip4_main;
 142   u32 n_left_from, *from, *to_next;
 143   u32 next_index;
 144   vlib_node_runtime_t *error_node = node;
 145   u32 good_packets = 0;
 146   int i;
 147
 148   from = vlib_frame_vector_args (frame);
 149   n_left_from = frame->n_vectors;
 150   next_index = node->cached_next_index;
 151
 152   while (n_left_from > 0)
 153     {
 154       u32 n_left_to_next;
 155
 156       vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
 157
 158
 159       /*     while (n_left_from >= 4 && n_left_to_next >= 2) */
 160       /*       { */
 161       /*         vlib_buffer_t *b0, *b1; */
 162       /*         ip4_header_t *ip0, *ip1; */
 163       /*         ip4_fib_mtrie_t *mtrie0, *mtrie1; */
 164       /*         ip4_fib_mtrie_leaf_t leaf0, leaf1; */
 165       /*         ip_source_and_port_range_check_config_t *c0, *c1; */
 166       /*         ip_adjacency_t *adj0 = 0, *adj1 = 0; */
 167       /*         u32 bi0, next0, adj_index0, pass0, save_next0, fib_index0; */
 168       /*         u32 bi1, next1, adj_index1, pass1, save_next1, fib_index1; */
 169       /*         udp_header_t *udp0, *udp1; */
 170
 171       /*         /\* Prefetch next iteration. *\/ */
 172       /*         { */
 173       /*           vlib_buffer_t *p2, *p3; */
 174
 175       /*           p2 = vlib_get_buffer (vm, from[2]); */
 176       /*           p3 = vlib_get_buffer (vm, from[3]); */
 177
 178       /*           vlib_prefetch_buffer_header (p2, LOAD); */
 179       /*           vlib_prefetch_buffer_header (p3, LOAD); */
 180
 181       /*           CLIB_PREFETCH (p2->data, sizeof (ip0[0]), LOAD); */
 182       /*           CLIB_PREFETCH (p3->data, sizeof (ip1[0]), LOAD); */
 183       /*         } */
 184
 185       /*         bi0 = to_next[0] = from[0]; */
 186       /*         bi1 = to_next[1] = from[1]; */
 187       /*         from += 2; */
 188       /*         to_next += 2; */
 189       /*         n_left_from -= 2; */
 190       /*         n_left_to_next -= 2; */
 191
 192       /*         b0 = vlib_get_buffer (vm, bi0); */
 193       /*         b1 = vlib_get_buffer (vm, bi1); */
 194
 195       /*         fib_index0 = */
 196       /*           vec_elt (im->fib_index_by_sw_if_index, */
 197       /*                 vnet_buffer (b0)->sw_if_index[VLIB_RX]); */
 198       /*         fib_index1 = */
 199       /*           vec_elt (im->fib_index_by_sw_if_index, */
 200       /*                 vnet_buffer (b1)->sw_if_index[VLIB_RX]); */
 201
 202       /*         ip0 = vlib_buffer_get_current (b0); */
 203       /*         ip1 = vlib_buffer_get_current (b1); */
 204
 205       /*         if (is_tx) */
 206       /*           { */
 207       /*             c0 = vnet_get_config_data (&tx_cm->config_main, */
 208       /*                                     &b0->current_config_index, */
 209       /*                                     &next0, sizeof (c0[0])); */
 210       /*             c1 = vnet_get_config_data (&tx_cm->config_main, */
 211       /*                                     &b1->current_config_index, */
 212       /*                                     &next1, sizeof (c1[0])); */
 213       /*           } */
 214       /*         else */
 215       /*           { */
 216       /*             c0 = vnet_get_config_data (&rx_cm->config_main, */
 217       /*                                     &b0->current_config_index, */
 218       /*                                     &next0, sizeof (c0[0])); */
 219       /*             c1 = vnet_get_config_data (&rx_cm->config_main, */
 220       /*                                     &b1->current_config_index, */
 221       /*                                     &next1, sizeof (c1[0])); */
 222       /*           } */
 223
 224       /*         /\* we can't use the default VRF here... *\/ */
 225       /*         for (i = 0; i < IP_SOURCE_AND_PORT_RANGE_CHECK_N_PROTOCOLS; i++) */
 226       /*           { */
 227       /*             ASSERT (c0->fib_index[i] && c1->fib_index[i]); */
 228       /*           } */
 229
 230
 231       /*         if (is_tx) */
 232       /*           { */
 233       /*             if (ip0->protocol == IP_PROTOCOL_UDP) */
 234       /*            fib_index0 = */
 235       /*              c0->fib_index */
 236       /*              [IP_SOURCE_AND_PORT_RANGE_CHECK_PROTOCOL_UDP_IN]; */
 237       /*             if (ip0->protocol == IP_PROTOCOL_TCP) */
 238       /*            fib_index0 = */
 239       /*              c0->fib_index */
 240       /*              [IP_SOURCE_AND_PORT_RANGE_CHECK_PROTOCOL_TCP_IN]; */
 241       /*           } */
 242       /*         else */
 243       /*           { */
 244       /*             if (ip0->protocol == IP_PROTOCOL_UDP) */
 245       /*            fib_index0 = */
 246       /*              c0->fib_index */
 247       /*              [IP_SOURCE_AND_PORT_RANGE_CHECK_PROTOCOL_UDP_OUT]; */
 248       /*             if (ip0->protocol == IP_PROTOCOL_TCP) */
 249       /*            fib_index0 = */
 250       /*              c0->fib_index */
 251       /*              [IP_SOURCE_AND_PORT_RANGE_CHECK_PROTOCOL_TCP_OUT]; */
 252       /*           } */
 253
 254       /*         if (PREDICT_TRUE (fib_index0 != ~0)) */
 255       /*           { */
 256
 257       /*             mtrie0 = &vec_elt_at_index (im->fibs, fib_index0)->mtrie; */
 258
 259       /*             leaf0 = IP4_FIB_MTRIE_LEAF_ROOT; */
 260
 261       /*             leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, */
 262       /*                                             &ip0->src_address, 0); */
 263
 264       /*             leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, */
 265       /*                                             &ip0->src_address, 1); */
 266
 267       /*             leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, */
 268       /*                                             &ip0->src_address, 2); */
 269
 270       /*             leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, */
 271       /*                                             &ip0->src_address, 3); */
 272
 273       /*             adj_index0 = ip4_fib_mtrie_leaf_get_adj_index (leaf0); */
 274
 275       /*             ASSERT (adj_index0 == ip4_fib_lookup_with_table (im, fib_index0, */
 276       /*                                                           &ip0->src_address, */
 277       /*                                                           0 */
 278       /*                                                           /\* use dflt rt *\/ */
 279       /*                  )); */
 280       /*             adj0 = ip_get_adjacency (lm, adj_index0); */
 281       /*           } */
 282
 283       /*         if (is_tx) */
 284       /*           { */
 285       /*             if (ip1->protocol == IP_PROTOCOL_UDP) */
 286       /*            fib_index1 = */
 287       /*              c1->fib_index */
 288       /*              [IP_SOURCE_AND_PORT_RANGE_CHECK_PROTOCOL_UDP_IN]; */
 289       /*             if (ip1->protocol == IP_PROTOCOL_TCP) */
 290       /*            fib_index1 = */
 291       /*              c1->fib_index */
 292       /*              [IP_SOURCE_AND_PORT_RANGE_CHECK_PROTOCOL_TCP_IN]; */
 293       /*           } */
 294       /*         else */
 295       /*           { */
 296       /*             if (ip1->protocol == IP_PROTOCOL_UDP) */
 297       /*            fib_index1 = */
 298       /*              c1->fib_index */
 299       /*              [IP_SOURCE_AND_PORT_RANGE_CHECK_PROTOCOL_UDP_OUT]; */
 300       /*             if (ip1->protocol == IP_PROTOCOL_TCP) */
 301       /*            fib_index1 = */
 302       /*              c1->fib_index */
 303       /*              [IP_SOURCE_AND_PORT_RANGE_CHECK_PROTOCOL_TCP_OUT]; */
 304       /*           } */
 305
 306       /*         if (PREDICT_TRUE (fib_index1 != ~0)) */
 307       /*           { */
 308
 309       /*             mtrie1 = &vec_elt_at_index (im->fibs, fib_index1)->mtrie; */
 310
 311       /*             leaf1 = IP4_FIB_MTRIE_LEAF_ROOT; */
 312
 313       /*             leaf1 = ip4_fib_mtrie_lookup_step (mtrie1, leaf1, */
 314       /*                                             &ip1->src_address, 0); */
 315
 316       /*             leaf1 = ip4_fib_mtrie_lookup_step (mtrie1, leaf1, */
 317       /*                                             &ip1->src_address, 1); */
 318
 319       /*             leaf1 = ip4_fib_mtrie_lookup_step (mtrie1, leaf1, */
 320       /*                                             &ip1->src_address, 2); */
 321
 322       /*             leaf1 = ip4_fib_mtrie_lookup_step (mtrie1, leaf1, */
 323       /*                                             &ip1->src_address, 3); */
 324
 325       /*             adj_index1 = ip4_fib_mtrie_leaf_get_adj_index (leaf1); */
 326
 327       /*             ASSERT (adj_index1 == ip4_fib_lookup_with_table (im, fib_index1, */
 328       /*                                                           &ip1->src_address, */
 329       /*                                                           0)); */
 330       /*             adj1 = ip_get_adjacency (lm, adj_index1); */
 331       /*           } */
 332
 333       /*         pass0 = 0; */
 334       /*         pass0 |= adj0 == 0; */
 335       /*         pass0 |= ip4_address_is_multicast (&ip0->src_address); */
 336       /*         pass0 |= */
 337       /*           ip0->src_address.as_u32 == clib_host_to_net_u32 (0xFFFFFFFF); */
 338       /*         pass0 |= (ip0->protocol != IP_PROTOCOL_UDP) */
 339       /*           && (ip0->protocol != IP_PROTOCOL_TCP); */
 340
 341       /*         pass1 = 0; */
 342       /*         pass1 |= adj1 == 0; */
 343       /*         pass1 |= ip4_address_is_multicast (&ip1->src_address); */
 344       /*         pass1 |= */
 345       /*           ip1->src_address.as_u32 == clib_host_to_net_u32 (0xFFFFFFFF); */
 346       /*         pass1 |= (ip1->protocol != IP_PROTOCOL_UDP) */
 347       /*           && (ip1->protocol != IP_PROTOCOL_TCP); */
 348
 349       /*         save_next0 = next0; */
 350       /*         udp0 = ip4_next_header (ip0); */
 351       /*         save_next1 = next1; */
 352       /*         udp1 = ip4_next_header (ip1); */
 353
 354       /*         if (PREDICT_TRUE (pass0 == 0)) */
 355       /*           { */
 356       /*             good_packets++; */
 357       /*             next0 = check_adj_port_range_x1 */
 358       /*            (adj0, clib_net_to_host_u16 (udp0->dst_port), next0); */
 359       /*             good_packets -= (save_next0 != next0); */
 360       /*             b0->error = error_node->errors */
 361       /*            [IP4_SOURCE_AND_PORT_RANGE_CHECK_ERROR_CHECK_FAIL]; */
 362       /*           } */
 363
 364       /*         if (PREDICT_TRUE (pass1 == 0)) */
 365       /*           { */
 366       /*             good_packets++; */
 367       /*             next1 = check_adj_port_range_x1 */
 368       /*            (adj1, clib_net_to_host_u16 (udp1->dst_port), next1); */
 369       /*             good_packets -= (save_next1 != next1); */
 370       /*             b1->error = error_node->errors */
 371       /*            [IP4_SOURCE_AND_PORT_RANGE_CHECK_ERROR_CHECK_FAIL]; */
 372       /*           } */
 373
 374       /*         if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE) */
 375       /*                         && (b0->flags & VLIB_BUFFER_IS_TRACED))) */
 376       /*           { */
 377       /*             ip4_source_and_port_range_check_trace_t *t = */
 378       /*            vlib_add_trace (vm, node, b0, sizeof (*t)); */
 379       /*             t->pass = next0 == save_next0; */
 380       /*             t->bypass = pass0; */
 381       /*             t->fib_index = fib_index0; */
 382       /*             t->src_addr.as_u32 = ip0->src_address.as_u32; */
 383       /*             t->port = (pass0 == 0) ? */
 384       /*            clib_net_to_host_u16 (udp0->dst_port) : 0; */
 385       /*             t->is_tcp = ip0->protocol == IP_PROTOCOL_TCP; */
 386       /*           } */
 387
 388       /*         if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE) */
 389       /*                         && (b1->flags & VLIB_BUFFER_IS_TRACED))) */
 390       /*           { */
 391       /*             ip4_source_and_port_range_check_trace_t *t = */
 392       /*            vlib_add_trace (vm, node, b1, sizeof (*t)); */
 393       /*             t->pass = next1 == save_next1; */
 394       /*             t->bypass = pass1; */
 395       /*             t->fib_index = fib_index1; */
 396       /*             t->src_addr.as_u32 = ip1->src_address.as_u32; */
 397       /*             t->port = (pass1 == 0) ? */
 398       /*            clib_net_to_host_u16 (udp1->dst_port) : 0; */
 399       /*             t->is_tcp = ip1->protocol == IP_PROTOCOL_TCP; */
 400       /*           } */
 401
 402       /*         vlib_validate_buffer_enqueue_x2 (vm, node, next_index, */
 403       /*                                       to_next, n_left_to_next, */
 404       /*                                       bi0, bi1, next0, next1); */
 405       /*       } */
 406
 407       while (n_left_from > 0 && n_left_to_next > 0)
 408         {
 409           vlib_buffer_t *b0;
 410           ip4_header_t *ip0;
 411           ip_source_and_port_range_check_config_t *c0;
 412           u32 bi0, next0, lb_index0, pass0, save_next0, fib_index0;
 413           udp_header_t *udp0;
 414           const protocol_port_range_dpo_t *ppr_dpo0 = NULL;
 415           const dpo_id_t *dpo;
 416           u32 sw_if_index0;
 417
 418           bi0 = from[0];
 419           to_next[0] = bi0;
 420           from += 1;
 421           to_next += 1;
 422           n_left_from -= 1;
 423           n_left_to_next -= 1;
 424
 425           b0 = vlib_get_buffer (vm, bi0);
 426           sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];
 427
 428           fib_index0 = vec_elt (im->fib_index_by_sw_if_index, sw_if_index0);
 429
 430           if (is_tx)
 431             vlib_buffer_advance (b0, sizeof (ethernet_header_t));
 432
 433           ip0 = vlib_buffer_get_current (b0);
 434
 435           c0 = vnet_feature_next_with_data (&next0, b0, sizeof (c0[0]));
 436
 437           /* we can't use the default VRF here... */
 438           for (i = 0; i < IP_SOURCE_AND_PORT_RANGE_CHECK_N_PROTOCOLS; i++)
 439             {
 440               ASSERT (c0->fib_index[i]);
 441             }
 442
 443
 444           if (is_tx)
 445             {
 446               if (ip0->protocol == IP_PROTOCOL_UDP)
 447                 fib_index0 =
 448                   c0->fib_index
 449                   [IP_SOURCE_AND_PORT_RANGE_CHECK_PROTOCOL_UDP_IN];
 450               if (ip0->protocol == IP_PROTOCOL_TCP)
 451                 fib_index0 =
 452                   c0->fib_index
 453                   [IP_SOURCE_AND_PORT_RANGE_CHECK_PROTOCOL_TCP_IN];
 454             }
 455           else
 456             {
 457               if (ip0->protocol == IP_PROTOCOL_UDP)
 458                 fib_index0 =
 459                   c0->fib_index
 460                   [IP_SOURCE_AND_PORT_RANGE_CHECK_PROTOCOL_UDP_OUT];
 461               if (ip0->protocol == IP_PROTOCOL_TCP)
 462                 fib_index0 =
 463                   c0->fib_index
 464                   [IP_SOURCE_AND_PORT_RANGE_CHECK_PROTOCOL_TCP_OUT];
 465             }
 466
 467           if (fib_index0 != ~0)
 468             {
 469               lb_index0 = ip4_fib_forwarding_lookup (fib_index0,
 470                                                      &ip0->src_address);
 471
 472               dpo =
 473                 load_balance_get_bucket_i (load_balance_get (lb_index0), 0);
 474
 475               if (ppr_dpo_type == dpo->dpoi_type)
 476                 {
 477                   ppr_dpo0 = protocol_port_range_dpo_get (dpo->dpoi_index);
 478                 }
 479               /*
 480                * else the lookup hit an enty that was no inserted
 481                * by this range checker, which is the default route
 482                */
 483             }
 484           /*
 485            * $$$ which (src,dst) categories should we always pass?
 486            */
 487           pass0 = 0;
 488           pass0 |= ip4_address_is_multicast (&ip0->src_address);
 489           pass0 |=
 490             ip0->src_address.as_u32 == clib_host_to_net_u32 (0xFFFFFFFF);
 491           pass0 |= (ip0->protocol != IP_PROTOCOL_UDP)
 492             && (ip0->protocol != IP_PROTOCOL_TCP);
 493
 494           save_next0 = next0;
 495           udp0 = ip4_next_header (ip0);
 496
 497           if (PREDICT_TRUE (pass0 == 0))
 498             {
 499               good_packets++;
 500               next0 = check_adj_port_range_x1
 501                 (ppr_dpo0, clib_net_to_host_u16 (udp0->dst_port), next0);
 502               good_packets -= (save_next0 != next0);
 503               b0->error = error_node->errors
 504                 [IP4_SOURCE_AND_PORT_RANGE_CHECK_ERROR_CHECK_FAIL];
 505             }
 506
 507           if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE)
 508                              && (b0->flags & VLIB_BUFFER_IS_TRACED)))
 509             {
 510               ip4_source_and_port_range_check_trace_t *t =
 511                 vlib_add_trace (vm, node, b0, sizeof (*t));
 512               t->pass = next0 == save_next0;
 513               t->bypass = pass0;
 514               t->fib_index = fib_index0;
 515               t->src_addr.as_u32 = ip0->src_address.as_u32;
 516               t->port = (pass0 == 0) ?
 517                 clib_net_to_host_u16 (udp0->dst_port) : 0;
 518               t->is_tcp = ip0->protocol == IP_PROTOCOL_TCP;
 519             }
 520
 521           if (is_tx)
 522             vlib_buffer_advance (b0, -sizeof (ethernet_header_t));
 523
 524           vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
 525                                            to_next, n_left_to_next,
 526                                            bi0, next0);
 527         }
 528
 529       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
 530     }
 531
 532   if (is_tx)
 533     vlib_node_increment_counter (vm, ip4_source_port_and_range_check_tx.index,
 534                                  IP4_SOURCE_AND_PORT_RANGE_CHECK_ERROR_CHECK_OK,
 535                                  good_packets);
 536   else
 537     vlib_node_increment_counter (vm, ip4_source_port_and_range_check_rx.index,
 538                                  IP4_SOURCE_AND_PORT_RANGE_CHECK_ERROR_CHECK_OK,
 539                                  good_packets);
 540   return frame->n_vectors;
 541 }
 542
 543 static uword
 544 ip4_source_and_port_range_check_rx (vlib_main_t * vm,
 545                                     vlib_node_runtime_t * node,
 546                                     vlib_frame_t * frame)
 547 {
 548   return ip4_source_and_port_range_check_inline (vm, node, frame,
 549                                                  0 /* !is_tx */ );
 550 }
 551
 552 static uword
 553 ip4_source_and_port_range_check_tx (vlib_main_t * vm,
 554                                     vlib_node_runtime_t * node,
 555                                     vlib_frame_t * frame)
 556 {
 557   return ip4_source_and_port_range_check_inline (vm, node, frame,
 558                                                  1 /* is_tx */ );
 559 }
 560
 561 /* Note: Calling same function for both RX and TX nodes
 562    as always checking dst_port, although
 563    if this changes can easily make new function
 564 */
 565
 566 VLIB_REGISTER_NODE (ip4_source_port_and_range_check_rx) = {
 567   .function = ip4_source_and_port_range_check_rx,
 568   .name = "ip4-source-and-port-range-check-rx",
 569   .vector_size = sizeof (u32),
 570
 571   .n_errors = ARRAY_LEN(ip4_source_and_port_range_check_error_strings),
 572   .error_strings = ip4_source_and_port_range_check_error_strings,
 573
 574   .n_next_nodes = IP4_SOURCE_AND_PORT_RANGE_CHECK_N_NEXT,
 575   .next_nodes = {
 576     [IP4_SOURCE_AND_PORT_RANGE_CHECK_NEXT_DROP] = "ip4-drop",
 577   },
 578
 579   .format_buffer = format_ip4_header,
 580   .format_trace = format_ip4_source_and_port_range_check_trace,
 581 };
 582
 583 VLIB_REGISTER_NODE (ip4_source_port_and_range_check_tx) = {
 584   .function = ip4_source_and_port_range_check_tx,
 585   .name = "ip4-source-and-port-range-check-tx",
 586   .vector_size = sizeof (u32),
 587
 588   .n_errors = ARRAY_LEN(ip4_source_and_port_range_check_error_strings),
 589   .error_strings = ip4_source_and_port_range_check_error_strings,
 590
 591   .n_next_nodes = IP4_SOURCE_AND_PORT_RANGE_CHECK_N_NEXT,
 592   .next_nodes = {
 593     [IP4_SOURCE_AND_PORT_RANGE_CHECK_NEXT_DROP] = "ip4-drop",
 594   },
 595
 596   .format_buffer = format_ip4_header,
 597   .format_trace = format_ip4_source_and_port_range_check_trace,
 598 };
 599
 600 int
 601 set_ip_source_and_port_range_check (vlib_main_t * vm,
 602                                     u32 * fib_index,
 603                                     u32 sw_if_index, u32 is_add)
 604 {
 605   ip_source_and_port_range_check_config_t config;
 606   int rv = 0;
 607   int i;
 608
 609   for (i = 0; i < IP_SOURCE_AND_PORT_RANGE_CHECK_N_PROTOCOLS; i++)
 610     {
 611       config.fib_index[i] = fib_index[i];
 612     }
 613
 614   /* For OUT we are in the RX path */
 615   if ((fib_index[IP_SOURCE_AND_PORT_RANGE_CHECK_PROTOCOL_TCP_OUT] != ~0) ||
 616       (fib_index[IP_SOURCE_AND_PORT_RANGE_CHECK_PROTOCOL_UDP_OUT] != ~0))
 617     {
 618       vnet_feature_enable_disable ("ip4-unicast",
 619                                    "ip4-source-and-port-range-check-rx",
 620                                    sw_if_index, is_add, &config,
 621                                    sizeof (config));
 622     }
 623
 624   /* For IN we are in the TX path */
 625   if ((fib_index[IP_SOURCE_AND_PORT_RANGE_CHECK_PROTOCOL_TCP_IN] != ~0) ||
 626       (fib_index[IP_SOURCE_AND_PORT_RANGE_CHECK_PROTOCOL_UDP_IN] != ~0))
 627     {
 628       vnet_feature_enable_disable ("ip4-output",
 629                                    "ip4-source-and-port-range-check-tx",
 630                                    sw_if_index, is_add, &config,
 631                                    sizeof (config));
 632     }
 633   return rv;
 634 }
 635
 636 static clib_error_t *
 637 set_ip_source_and_port_range_check_fn (vlib_main_t * vm,
 638                                        unformat_input_t * input,
 639                                        vlib_cli_command_t * cmd)
 640 {
 641   vnet_main_t *vnm = vnet_get_main ();
 642   ip4_main_t *im = &ip4_main;
 643   clib_error_t *error = 0;
 644   u8 is_add = 1;
 645   u32 sw_if_index = ~0;
 646   u32 vrf_id[IP_SOURCE_AND_PORT_RANGE_CHECK_N_PROTOCOLS];
 647   u32 fib_index[IP_SOURCE_AND_PORT_RANGE_CHECK_N_PROTOCOLS];
 648   int vrf_set = 0;
 649   uword *p;
 650   int rv = 0;
 651   int i;
 652
 653   sw_if_index = ~0;
 654   for (i = 0; i < IP_SOURCE_AND_PORT_RANGE_CHECK_N_PROTOCOLS; i++)
 655     {
 656       fib_index[i] = ~0;
 657       vrf_id[i] = ~0;
 658     }
 659
 660   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 661     {
 662       if (unformat (input, "%U", unformat_vnet_sw_interface, vnm,
 663                     &sw_if_index))
 664         ;
 665       else
 666         if (unformat
 667             (input, "tcp-out-vrf %d",
 668              &vrf_id[IP_SOURCE_AND_PORT_RANGE_CHECK_PROTOCOL_TCP_OUT]))
 669         vrf_set = 1;
 670       else
 671         if (unformat
 672             (input, "udp-out-vrf %d",
 673              &vrf_id[IP_SOURCE_AND_PORT_RANGE_CHECK_PROTOCOL_UDP_OUT]))
 674         vrf_set = 1;
 675       else
 676         if (unformat
 677             (input, "tcp-in-vrf %d",
 678              &vrf_id[IP_SOURCE_AND_PORT_RANGE_CHECK_PROTOCOL_TCP_IN]))
 679         vrf_set = 1;
 680       else
 681         if (unformat
 682             (input, "udp-in-vrf %d",
 683              &vrf_id[IP_SOURCE_AND_PORT_RANGE_CHECK_PROTOCOL_UDP_IN]))
 684         vrf_set = 1;
 685       else if (unformat (input, "del"))
 686         is_add = 0;
 687       else
 688         break;
 689     }
 690
 691   if (sw_if_index == ~0)
 692     return clib_error_return (0, "Interface required but not specified");
 693
 694   if (!vrf_set)
 695     return clib_error_return (0,
 696                               "TCP or UDP VRF ID required but not specified");
 697
 698   for (i = 0; i < IP_SOURCE_AND_PORT_RANGE_CHECK_N_PROTOCOLS; i++)
 699     {
 700
 701       if (vrf_id[i] == 0)
 702         return clib_error_return (0,
 703                                   "TCP, UDP VRF ID should not be 0 (default). Should be distinct VRF for this purpose. ");
 704
 705       if (vrf_id[i] != ~0)
 706         {
 707           p = hash_get (im->fib_index_by_table_id, vrf_id[i]);
 708
 709           if (p == 0)
 710             return clib_error_return (0, "Invalid VRF ID %d", vrf_id[i]);
 711
 712           fib_index[i] = p[0];
 713         }
 714     }
 715   rv =
 716     set_ip_source_and_port_range_check (vm, fib_index, sw_if_index, is_add);
 717
 718   switch (rv)
 719     {
 720     case 0:
 721       break;
 722
 723     default:
 724       return clib_error_return
 725         (0,
 726          "set source and port-range on interface returned an unexpected value: %d",
 727          rv);
 728     }
 729   return error;
 730 }
 731
 732 /*?
 733  * Add the 'ip4-source-and-port-range-check-rx' or
 734  * 'ip4-source-and-port-range-check-tx' graph node for a given
 735  * interface. 'tcp-out-vrf' and 'udp-out-vrf' will add to
 736  * the RX path. 'tcp-in-vrf' and 'udp-in-vrf' will add to
 737  * the TX path. A graph node will be inserted into the chain when
 738  * the range check is added to the first interface. It will not
 739  * be removed from when range check is removed from the last
 740  * interface.
 741  *
 742  * By adding the range check graph node to the interface, incoming
 743  * or outgoing TCP/UDP packets will be validated using the
 744  * provided IPv4 FIB table (VRF).
 745  *
 746  * @note 'ip4-source-and-port-range-check-rx' and
 747  * 'ip4-source-and-port-range-check-tx' strings are too long, so
 748  * they are truncated on the 'show vlib graph' output.
 749  *
 750  * @todo This content needs to be validated and potentially more detail added.
 751  *
 752  * @cliexpar
 753  * @parblock
 754  * Example of graph node before range checking is enabled:
 755  * @cliexstart{show vlib graph ip4-source-and-port-range-check-tx}
 756  *            Name                      Next                    Previous
 757  * ip4-source-and-port-range-      ip4-drop [0]
 758  * @cliexend
 759  *
 760  * Example of how to enable range checking on TX:
 761  * @cliexcmd{set interface ip source-and-port-range-check GigabitEthernet2/0/0
 762  * udp-in-vrf 7}
 763  *
 764  * Example of graph node after range checking is enabled:
 765  * @cliexstart{show vlib graph ip4-source-and-port-range-check-tx}
 766  *            Name                      Next                    Previous
 767  * ip4-source-and-port-range-      ip4-drop [0]                ip4-rewrite
 768  *                              interface-output [1]
 769  * @cliexend
 770  *
 771  * Example of how to display the features enabled on an interface:
 772  * @cliexstart{show ip interface features GigabitEthernet2/0/0}
 773  * IP feature paths configured on GigabitEthernet2/0/0...
 774  *
 775  * ipv4 unicast:
 776  *   ip4-source-and-port-range-check-rx
 777  *   ip4-lookup
 778  *
 779  * ipv4 multicast:
 780  *   ip4-lookup-multicast
 781  *
 782  * ipv4 multicast:
 783  *   interface-output
 784  *
 785  * ipv6 unicast:
 786  *   ip6-lookup
 787  *
 788  * ipv6 multicast:
 789  *   ip6-lookup
 790  *
 791  * ipv6 multicast:
 792  *   interface-output
 793  * @cliexend
 794  * @endparblock
 795 ?*/
 796 VLIB_CLI_COMMAND (set_interface_ip_source_and_port_range_check_command, static) = {
 797   .path = "set interface ip source-and-port-range-check",
 798   .function = set_ip_source_and_port_range_check_fn,
 799   .short_help = "set interface ip source-and-port-range-check <interface> [tcp-out-vrf <table-id>] [udp-out-vrf <table-id>] [tcp-in-vrf <table-id>] [udp-in-vrf <table-id>] [del]",
 800 };
 801
 802 static u8 *
 803 format_ppr_dpo (u8 * s, va_list * args)
 804 {
 805   index_t index = va_arg (*args, index_t);
 806   CLIB_UNUSED (u32 indent) = va_arg (*args, u32);
 807
 808   protocol_port_range_dpo_t *ppr_dpo;
 809   int i, j;
 810   int printed = 0;
 811
 812   ppr_dpo = protocol_port_range_dpo_get (index);
 813
 814   s = format (s, "allow ");
 815
 816   for (i = 0; i < ppr_dpo->n_used_blocks; i++)
 817     {
 818       for (j = 0; j < 8; j++)
 819         {
 820           if (ppr_dpo->blocks[i].low.as_u16[j])
 821             {
 822               if (printed)
 823                 s = format (s, ", ");
 824               if (ppr_dpo->blocks[i].hi.as_u16[j] >
 825                   (ppr_dpo->blocks[i].low.as_u16[j] + 1))
 826                 s =
 827                   format (s, "%d-%d", (u32) ppr_dpo->blocks[i].low.as_u16[j],
 828                           (u32) ppr_dpo->blocks[i].hi.as_u16[j] - 1);
 829               else
 830                 s = format (s, "%d", ppr_dpo->blocks[i].low.as_u16[j]);
 831               printed = 1;
 832             }
 833         }
 834     }
 835   return s;
 836 }
 837
 838 static void
 839 ppr_dpo_lock (dpo_id_t * dpo)
 840 {
 841 }
 842
 843 static void
 844 ppr_dpo_unlock (dpo_id_t * dpo)
 845 {
 846 }
 847
 848 const static dpo_vft_t ppr_vft = {
 849   .dv_lock = ppr_dpo_lock,
 850   .dv_unlock = ppr_dpo_unlock,
 851   .dv_format = format_ppr_dpo,
 852 };
 853
 854 const static char *const ppr_ip4_nodes[] = {
 855   "ip4-source-and-port-range-check-rx",
 856   NULL,
 857 };
 858
 859 const static char *const *const ppr_nodes[DPO_PROTO_NUM] = {
 860   [DPO_PROTO_IP4] = ppr_ip4_nodes,
 861 };
 862
 863 clib_error_t *
 864 ip4_source_and_port_range_check_init (vlib_main_t * vm)
 865 {
 866   source_range_check_main_t *srm = &source_range_check_main;
 867
 868   srm->vlib_main = vm;
 869   srm->vnet_main = vnet_get_main ();
 870
 871   ppr_dpo_type = dpo_register_new_type (&ppr_vft, ppr_nodes);
 872
 873   return 0;
 874 }
 875
 876 VLIB_INIT_FUNCTION (ip4_source_and_port_range_check_init);
 877
 878 protocol_port_range_dpo_t *
 879 protocol_port_range_dpo_alloc (void)
 880 {
 881   protocol_port_range_dpo_t *ppr_dpo;
 882
 883   pool_get_aligned (ppr_dpo_pool, ppr_dpo, CLIB_CACHE_LINE_BYTES);
 884   clib_memset (ppr_dpo, 0, sizeof (*ppr_dpo));
 885
 886   ppr_dpo->n_free_ranges = N_PORT_RANGES_PER_DPO;
 887
 888   return (ppr_dpo);
 889 }
 890
 891
 892 static int
 893 add_port_range_adjacency (u32 fib_index,
 894                           ip4_address_t * address,
 895                           u32 length, u16 * low_ports, u16 * high_ports)
 896 {
 897   protocol_port_range_dpo_t *ppr_dpo;
 898   dpo_id_t dpop = DPO_INVALID;
 899   int i, j, k;
 900
 901   fib_node_index_t fei;
 902   fib_prefix_t pfx = {
 903     .fp_proto = FIB_PROTOCOL_IP4,
 904     .fp_len = length,
 905     .fp_addr = {
 906                 .ip4 = *address,
 907                 },
 908   };
 909
 910   /*
 911    * check to see if we have already sourced this prefix
 912    */
 913   fei = fib_table_lookup_exact_match (fib_index, &pfx);
 914
 915   if (FIB_NODE_INDEX_INVALID == fei)
 916     {
 917       /*
 918        * this is a first time add for this prefix.
 919        */
 920       ppr_dpo = protocol_port_range_dpo_alloc ();
 921     }
 922   else
 923     {
 924       /*
 925        * the prefix is already there.
 926        * check it was sourced by us, and if so get the ragne DPO from it.
 927        */
 928       dpo_id_t dpo = DPO_INVALID;
 929       const dpo_id_t *bucket;
 930
 931       if (fib_entry_get_dpo_for_source (fei, FIB_SOURCE_SPECIAL, &dpo))
 932         {
 933           /*
 934            * there is existing state. we'll want to add the new ranges to it
 935            */
 936           bucket =
 937             load_balance_get_bucket_i (load_balance_get (dpo.dpoi_index), 0);
 938           ppr_dpo = protocol_port_range_dpo_get (bucket->dpoi_index);
 939           dpo_reset (&dpo);
 940         }
 941       else
 942         {
 943           /*
 944            * there is no PPR state associated with this prefix,
 945            * so we'll need a new DPO
 946            */
 947           ppr_dpo = protocol_port_range_dpo_alloc ();
 948         }
 949     }
 950
 951   if (vec_len (low_ports) > ppr_dpo->n_free_ranges)
 952     return VNET_API_ERROR_EXCEEDED_NUMBER_OF_RANGES_CAPACITY;
 953
 954   j = k = 0;
 955
 956   for (i = 0; i < vec_len (low_ports); i++)
 957     {
 958       for (; j < N_BLOCKS_PER_DPO; j++)
 959         {
 960           for (; k < 8; k++)
 961             {
 962               if (ppr_dpo->blocks[j].low.as_u16[k] == 0)
 963                 {
 964                   ppr_dpo->blocks[j].low.as_u16[k] = low_ports[i];
 965                   ppr_dpo->blocks[j].hi.as_u16[k] = high_ports[i];
 966                   goto doublebreak;
 967                 }
 968             }
 969         }
 970     doublebreak:;
 971     }
 972   ppr_dpo->n_used_blocks = j + 1;
 973
 974   /*
 975    * add or update the entry in the FIB
 976    */
 977   dpo_set (&dpop, ppr_dpo_type, DPO_PROTO_IP4, (ppr_dpo - ppr_dpo_pool));
 978
 979   if (FIB_NODE_INDEX_INVALID == fei)
 980     {
 981       fib_table_entry_special_dpo_add (fib_index,
 982                                        &pfx,
 983                                        FIB_SOURCE_SPECIAL,
 984                                        FIB_ENTRY_FLAG_NONE, &dpop);
 985     }
 986   else
 987     {
 988       fib_entry_special_update (fei,
 989                                 FIB_SOURCE_SPECIAL,
 990                                 FIB_ENTRY_FLAG_NONE, &dpop);
 991     }
 992
 993   return 0;
 994 }
 995
 996 static int
 997 remove_port_range_adjacency (u32 fib_index,
 998                              ip4_address_t * address,
 999                              u32 length, u16 * low_ports, u16 * high_ports)
1000 {
1001   protocol_port_range_dpo_t *ppr_dpo;
1002   fib_node_index_t fei;
1003   int i, j, k;
1004
1005   fib_prefix_t pfx = {
1006     .fp_proto = FIB_PROTOCOL_IP4,
1007     .fp_len = length,
1008     .fp_addr = {
1009                 .ip4 = *address,
1010                 },
1011   };
1012
1013   /*
1014    * check to see if we have sourced this prefix
1015    */
1016   fei = fib_table_lookup_exact_match (fib_index, &pfx);
1017
1018   if (FIB_NODE_INDEX_INVALID == fei)
1019     {
1020       /*
1021        * not one of ours
1022        */
1023       return VNET_API_ERROR_INCORRECT_ADJACENCY_TYPE;
1024     }
1025   else
1026     {
1027       /*
1028        * the prefix is already there.
1029        * check it was sourced by us
1030        */
1031       dpo_id_t dpo = DPO_INVALID;
1032       const dpo_id_t *bucket;
1033
1034       if (fib_entry_get_dpo_for_source (fei, FIB_SOURCE_SPECIAL, &dpo))
1035         {
1036           /*
1037            * there is existing state. we'll want to add the new ranges to it
1038            */
1039           bucket =
1040             load_balance_get_bucket_i (load_balance_get (dpo.dpoi_index), 0);
1041           ppr_dpo = protocol_port_range_dpo_get (bucket->dpoi_index);
1042           dpo_reset (&dpo);
1043         }
1044       else
1045         {
1046           /*
1047            * not one of ours
1048            */
1049           return VNET_API_ERROR_INCORRECT_ADJACENCY_TYPE;
1050         }
1051     }
1052
1053   for (i = 0; i < vec_len (low_ports); i++)
1054     {
1055       for (j = 0; j < N_BLOCKS_PER_DPO; j++)
1056         {
1057           for (k = 0; k < 8; k++)
1058             {
1059               if (low_ports[i] == ppr_dpo->blocks[j].low.as_u16[k] &&
1060                   high_ports[i] == ppr_dpo->blocks[j].hi.as_u16[k])
1061                 {
1062                   ppr_dpo->blocks[j].low.as_u16[k] =
1063                     ppr_dpo->blocks[j].hi.as_u16[k] = 0;
1064                   goto doublebreak;
1065                 }
1066             }
1067         }
1068     doublebreak:;
1069     }
1070
1071   ppr_dpo->n_free_ranges = 0;
1072
1073   /* Have we deleted all ranges yet? */
1074   for (i = 0; i < N_BLOCKS_PER_DPO; i++)
1075     {
1076       for (j = 0; j < 8; j++)
1077         {
1078           if (ppr_dpo->blocks[j].low.as_u16[i] == 0)
1079             ppr_dpo->n_free_ranges++;
1080         }
1081     }
1082
1083   if (N_PORT_RANGES_PER_DPO == ppr_dpo->n_free_ranges)
1084     {
1085       /* Yes, lose the adjacency... */
1086       fib_table_entry_special_remove (fib_index, &pfx, FIB_SOURCE_SPECIAL);
1087     }
1088   else
1089     {
1090       /*
1091        * compact the ranges down to a contiguous block
1092        */
1093       // FIXME. TODO.
1094     }
1095
1096   return 0;
1097 }
1098
1099 // This will be moved to another file and implemented post API freeze.
1100 int
1101 ip6_source_and_port_range_check_add_del (ip6_address_t * address,
1102                                          u32 length,
1103                                          u32 vrf_id,
1104                                          u16 * low_ports,
1105                                          u16 * high_ports, int is_add)
1106 {
1107   u32 fib_index;
1108
1109   fib_index = fib_table_find (FIB_PROTOCOL_IP4, vrf_id);
1110
1111   ASSERT (~0 != fib_index);
1112
1113   fib_table_unlock (fib_index, FIB_PROTOCOL_IP4, FIB_SOURCE_CLASSIFY);
1114
1115   return 0;
1116 }
1117
1118 int
1119 ip4_source_and_port_range_check_add_del (ip4_address_t * address,
1120                                          u32 length,
1121                                          u32 vrf_id,
1122                                          u16 * low_ports,
1123                                          u16 * high_ports, int is_add)
1124 {
1125   u32 fib_index;
1126
1127   fib_index = fib_table_find_or_create_and_lock (FIB_PROTOCOL_IP4, vrf_id,
1128                                                  FIB_SOURCE_CLASSIFY);
1129
1130   if (is_add == 0)
1131     {
1132       remove_port_range_adjacency (fib_index, address, length,
1133                                    low_ports, high_ports);
1134     }
1135   else
1136     {
1137       add_port_range_adjacency (fib_index, address, length,
1138                                 low_ports, high_ports);
1139     }
1140
1141   return 0;
1142 }
1143
1144 static clib_error_t *
1145 ip_source_and_port_range_check_command_fn (vlib_main_t * vm,
1146                                            unformat_input_t * input,
1147                                            vlib_cli_command_t * cmd)
1148 {
1149   u16 *low_ports = 0;
1150   u16 *high_ports = 0;
1151   u16 this_low;
1152   u16 this_hi;
1153   ip4_address_t ip4_addr;
1154   ip6_address_t ip6_addr;       //This function will be moved to generic impl when v6 done.
1155   u32 length;
1156   u32 tmp, tmp2;
1157   u32 vrf_id = ~0;
1158   int is_add = 1, ip_ver = ~0;
1159   int rv;
1160
1161
1162   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
1163     {
1164       if (unformat (input, "%U/%d", unformat_ip4_address, &ip4_addr, &length))
1165         ip_ver = 4;
1166       else
1167         if (unformat
1168             (input, "%U/%d", unformat_ip6_address, &ip6_addr, &length))
1169         ip_ver = 6;
1170       else if (unformat (input, "vrf %d", &vrf_id))
1171         ;
1172       else if (unformat (input, "del"))
1173         is_add = 0;
1174       else if (unformat (input, "port %d", &tmp))
1175         {
1176           if (tmp == 0 || tmp > 65535)
1177             return clib_error_return (0, "port %d out of range", tmp);
1178           this_low = tmp;
1179           this_hi = this_low + 1;
1180           vec_add1 (low_ports, this_low);
1181           vec_add1 (high_ports, this_hi);
1182         }
1183       else if (unformat (input, "range %d - %d", &tmp, &tmp2))
1184         {
1185           if (tmp > tmp2)
1186             return clib_error_return (0, "ports %d and %d out of order",
1187                                       tmp, tmp2);
1188           if (tmp == 0 || tmp > 65535)
1189             return clib_error_return (0, "low port %d out of range", tmp);
1190           if (tmp2 == 0 || tmp2 > 65535)
1191             return clib_error_return (0, "high port %d out of range", tmp2);
1192           this_low = tmp;
1193           this_hi = tmp2 + 1;
1194           vec_add1 (low_ports, this_low);
1195           vec_add1 (high_ports, this_hi);
1196         }
1197       else
1198         break;
1199     }
1200
1201   if (ip_ver == ~0)
1202     return clib_error_return (0, " <address>/<mask> not specified");
1203
1204   if (vrf_id == ~0)
1205     return clib_error_return (0, " VRF ID required, not specified");
1206
1207   if (vec_len (low_ports) == 0)
1208     return clib_error_return (0,
1209                               " Both VRF ID and range/port must be set for a protocol.");
1210
1211   if (vrf_id == 0)
1212     return clib_error_return (0, " VRF ID can not be 0 (default).");
1213
1214
1215   if (ip_ver == 4)
1216     rv = ip4_source_and_port_range_check_add_del
1217       (&ip4_addr, length, vrf_id, low_ports, high_ports, is_add);
1218   else
1219     return clib_error_return (0, " IPv6 in subsequent patch");
1220
1221   switch (rv)
1222     {
1223     case 0:
1224       break;
1225
1226     case VNET_API_ERROR_INCORRECT_ADJACENCY_TYPE:
1227       return clib_error_return
1228         (0, " Incorrect adjacency for add/del operation");
1229
1230     case VNET_API_ERROR_EXCEEDED_NUMBER_OF_PORTS_CAPACITY:
1231       return clib_error_return (0, " Too many ports in add/del operation");
1232
1233     case VNET_API_ERROR_EXCEEDED_NUMBER_OF_RANGES_CAPACITY:
1234       return clib_error_return
1235         (0, " Too many ranges requested for add operation");
1236
1237     default:
1238       return clib_error_return (0, " returned an unexpected value: %d", rv);
1239     }
1240
1241   return 0;
1242 }
1243
1244 /*?
1245  * This command adds an IP Subnet and range of ports to be validated
1246  * by an IP FIB table (VRF).
1247  *
1248  * @todo This is incomplete. This needs a detailed description and a
1249  * practical example.
1250  *
1251  * @cliexpar
1252  * Example of how to add an IPv4 subnet and single port to an IPv4 FIB table:
1253  * @cliexcmd{set ip source-and-port-range-check vrf 7 172.16.1.0/24 port 23}
1254  * Example of how to add an IPv4 subnet and range of ports to an IPv4 FIB table:
1255  * @cliexcmd{set ip source-and-port-range-check vrf 7 172.16.1.0/24 range 23 - 100}
1256  * Example of how to delete an IPv4 subnet and single port from an IPv4 FIB table:
1257  * @cliexcmd{set ip source-and-port-range-check vrf 7 172.16.1.0/24 port 23 del}
1258  * Example of how to delete an IPv4 subnet and range of ports from an IPv4 FIB table:
1259  * @cliexcmd{set ip source-and-port-range-check vrf 7 172.16.1.0/24 range 23 - 100 del}
1260 ?*/
1261 VLIB_CLI_COMMAND (ip_source_and_port_range_check_command, static) = {
1262   .path = "set ip source-and-port-range-check",
1263   .function = ip_source_and_port_range_check_command_fn,
1264   .short_help =
1265   "set ip source-and-port-range-check vrf <table-id> <ip-addr>/<mask> {port nn | range <nn> - <nn>} [del]",
1266 };
1267
1268
1269 static clib_error_t *
1270 show_source_and_port_range_check_fn (vlib_main_t * vm,
1271                                      unformat_input_t * input,
1272                                      vlib_cli_command_t * cmd)
1273 {
1274   protocol_port_range_dpo_t *ppr_dpo;
1275   u32 fib_index;
1276   u8 addr_set = 0;
1277   u32 vrf_id = ~0;
1278   int rv, i, j;
1279   u32 port = 0;
1280   fib_prefix_t pfx = {
1281     .fp_proto = FIB_PROTOCOL_IP4,
1282     .fp_len = 32,
1283   };
1284
1285   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
1286     {
1287       if (unformat (input, "%U", unformat_ip4_address, &pfx.fp_addr.ip4))
1288         addr_set = 1;
1289       else if (unformat (input, "vrf %d", &vrf_id))
1290         ;
1291       else if (unformat (input, "port %d", &port))
1292         ;
1293       else
1294         break;
1295     }
1296
1297   if (addr_set == 0)
1298     return clib_error_return (0, "<address> not specified");
1299
1300   if (vrf_id == ~0)
1301     return clib_error_return (0, "VRF ID required, not specified");
1302
1303   fib_index = fib_table_find (FIB_PROTOCOL_IP4, vrf_id);
1304   if (~0 == fib_index)
1305     return clib_error_return (0, "VRF %d not found", vrf_id);
1306
1307   /*
1308    * find the longest prefix match on the address requested,
1309    * check it was sourced by us
1310    */
1311   dpo_id_t dpo = DPO_INVALID;
1312   const dpo_id_t *bucket;
1313
1314   if (!fib_entry_get_dpo_for_source (fib_table_lookup (fib_index, &pfx),
1315                                      FIB_SOURCE_SPECIAL, &dpo))
1316     {
1317       /*
1318        * not one of ours
1319        */
1320       vlib_cli_output (vm, "%U: src address drop", format_ip4_address,
1321                        &pfx.fp_addr.ip4);
1322       return 0;
1323     }
1324
1325   bucket = load_balance_get_bucket_i (load_balance_get (dpo.dpoi_index), 0);
1326   ppr_dpo = protocol_port_range_dpo_get (bucket->dpoi_index);
1327   dpo_reset (&dpo);
1328
1329   if (port)
1330     {
1331       rv = check_adj_port_range_x1 (ppr_dpo, (u16) port, 1234);
1332       if (rv == 1234)
1333         vlib_cli_output (vm, "%U port %d PASS", format_ip4_address,
1334                          &pfx.fp_addr.ip4, port);
1335       else
1336         vlib_cli_output (vm, "%U port %d FAIL", format_ip4_address,
1337                          &pfx.fp_addr.ip4, port);
1338       return 0;
1339     }
1340   else
1341     {
1342       u8 *s;
1343
1344       s = format (0, "%U: ", format_ip4_address, &pfx.fp_addr.ip4);
1345
1346       for (i = 0; i < N_BLOCKS_PER_DPO; i++)
1347         {
1348           for (j = 0; j < 8; j++)
1349             {
1350               if (ppr_dpo->blocks[i].low.as_u16[j])
1351                 s = format (s, "%d - %d ",
1352                             (u32) ppr_dpo->blocks[i].low.as_u16[j],
1353                             (u32) ppr_dpo->blocks[i].hi.as_u16[j]);
1354             }
1355         }
1356       vlib_cli_output (vm, "%s", s);
1357       vec_free (s);
1358     }
1359
1360   return 0;
1361 }
1362
1363 /*?
1364  * Display the range of ports being validated by an IPv4 FIB for a given
1365  * IP or subnet, or test if a given IP and port are being validated.
1366  *
1367  * @todo This is incomplete. This needs a detailed description and a
1368  * practical example.
1369  *
1370  * @cliexpar
1371  * Example of how to display the set of ports being validated for a given
1372  * IPv4 subnet:
1373  * @cliexstart{show ip source-and-port-range-check vrf 7 172.16.2.0}
1374  * 172.16.2.0: 23 - 101
1375  * @cliexend
1376  * Example of how to test to determine of a given iPv4 address and port
1377  * are being validated:
1378  * @cliexstart{show ip source-and-port-range-check vrf 7 172.16.2.2 port 23}
1379  * 172.16.2.2 port 23 PASS
1380  * @cliexend
1381  * @cliexstart{show ip source-and-port-range-check vrf 7 172.16.2.2 port 250}
1382  * 172.16.2.2 port 250 FAIL
1383  * @cliexend
1384  ?*/
1385 VLIB_CLI_COMMAND (show_source_and_port_range_check, static) = {
1386   .path = "show ip source-and-port-range-check",
1387   .function = show_source_and_port_range_check_fn,
1388   .short_help =
1389   "show ip source-and-port-range-check vrf <table-id> <ip-addr> [port <n>]",
1390 };
1391
1392 /*
1393  * fd.io coding-style-patch-verification: ON
1394  *
1395  * Local Variables:
1396  * eval: (c-set-style "gnu")
1397  * End:
1398  */