src/vnet/ip/lookup.c

   1 /*
   2  * Copyright (c) 2015 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 /*
  16  * ip/ip_lookup.c: ip4/6 adjacency and lookup table managment
  17  *
  18  * Copyright (c) 2008 Eliot Dresselhaus
  19  *
  20  * Permission is hereby granted, free of charge, to any person obtaining
  21  * a copy of this software and associated documentation files (the
  22  * "Software"), to deal in the Software without restriction, including
  23  * without limitation the rights to use, copy, modify, merge, publish,
  24  * distribute, sublicense, and/or sell copies of the Software, and to
  25  * permit persons to whom the Software is furnished to do so, subject to
  26  * the following conditions:
  27  *
  28  * The above copyright notice and this permission notice shall be
  29  * included in all copies or substantial portions of the Software.
  30  *
  31  *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  32  *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  33  *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  34  *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  35  *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  36  *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  37  *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  38  */
  39
  40 #include <vnet/ip/ip.h>
  41 #include <vnet/adj/adj.h>
  42 #include <vnet/fib/fib_table.h>
  43 #include <vnet/fib/ip4_fib.h>
  44 #include <vnet/fib/ip6_fib.h>
  45 #include <vnet/mpls/mpls.h>
  46 #include <vnet/mfib/mfib_table.h>
  47 #include <vnet/dpo/drop_dpo.h>
  48 #include <vnet/dpo/classify_dpo.h>
  49 #include <vnet/dpo/punt_dpo.h>
  50 #include <vnet/dpo/receive_dpo.h>
  51 #include <vnet/dpo/ip_null_dpo.h>
  52 #include <vnet/dpo/l3_proxy_dpo.h>
  53 #include <vnet/ip/ip6_neighbor.h>
  54
  55 /**
  56  * @file
  57  * @brief IPv4 and IPv6 adjacency and lookup table managment.
  58  *
  59  */
  60
  61 clib_error_t *
  62 ip_interface_address_add_del (ip_lookup_main_t * lm,
  63                               u32 sw_if_index,
  64                               void *addr_fib,
  65                               u32 address_length,
  66                               u32 is_del, u32 * result_if_address_index)
  67 {
  68   vnet_main_t *vnm = vnet_get_main ();
  69   ip_interface_address_t *a, *prev, *next;
  70   uword *p = mhash_get (&lm->address_to_if_address_index, addr_fib);
  71
  72   vec_validate_init_empty (lm->if_address_pool_index_by_sw_if_index,
  73                            sw_if_index, ~0);
  74   a = p ? pool_elt_at_index (lm->if_address_pool, p[0]) : 0;
  75
  76   /* Verify given length. */
  77   if ((a && (address_length != a->address_length)) ||
  78       (address_length == 0) ||
  79       (lm->is_ip6 && address_length > 128) ||
  80       (!lm->is_ip6 && address_length > 32))
  81     {
  82       vnm->api_errno = VNET_API_ERROR_ADDRESS_LENGTH_MISMATCH;
  83       return clib_error_create
  84         ("%U wrong length (expected %d) for interface %U",
  85          lm->format_address_and_length, addr_fib,
  86          address_length, a ? a->address_length : -1,
  87          format_vnet_sw_if_index_name, vnm, sw_if_index);
  88     }
  89
  90   if (is_del)
  91     {
  92       if (!a)
  93         {
  94           vnet_sw_interface_t *si = vnet_get_sw_interface (vnm, sw_if_index);
  95           vnm->api_errno = VNET_API_ERROR_ADDRESS_NOT_FOUND_FOR_INTERFACE;
  96           return clib_error_create ("%U not found for interface %U",
  97                                     lm->format_address_and_length,
  98                                     addr_fib, address_length,
  99                                     format_vnet_sw_interface_name, vnm, si);
 100         }
 101
 102       if (a->prev_this_sw_interface != ~0)
 103         {
 104           prev =
 105             pool_elt_at_index (lm->if_address_pool,
 106                                a->prev_this_sw_interface);
 107           prev->next_this_sw_interface = a->next_this_sw_interface;
 108         }
 109       if (a->next_this_sw_interface != ~0)
 110         {
 111           next =
 112             pool_elt_at_index (lm->if_address_pool,
 113                                a->next_this_sw_interface);
 114           next->prev_this_sw_interface = a->prev_this_sw_interface;
 115
 116           if (a->prev_this_sw_interface == ~0)
 117             lm->if_address_pool_index_by_sw_if_index[sw_if_index] =
 118               a->next_this_sw_interface;
 119         }
 120
 121       if ((a->next_this_sw_interface == ~0)
 122           && (a->prev_this_sw_interface == ~0))
 123         lm->if_address_pool_index_by_sw_if_index[sw_if_index] = ~0;
 124
 125       mhash_unset (&lm->address_to_if_address_index, addr_fib,
 126                    /* old_value */ 0);
 127       pool_put (lm->if_address_pool, a);
 128
 129       if (result_if_address_index)
 130         *result_if_address_index = ~0;
 131     }
 132
 133   else if (!a)
 134     {
 135       u32 pi;                   /* previous index */
 136       u32 ai;
 137       u32 hi;                   /* head index */
 138
 139       pool_get (lm->if_address_pool, a);
 140       memset (a, ~0, sizeof (a[0]));
 141       ai = a - lm->if_address_pool;
 142
 143       hi = pi = lm->if_address_pool_index_by_sw_if_index[sw_if_index];
 144       prev = 0;
 145       while (pi != (u32) ~ 0)
 146         {
 147           prev = pool_elt_at_index (lm->if_address_pool, pi);
 148           pi = prev->next_this_sw_interface;
 149         }
 150       pi = prev ? prev - lm->if_address_pool : (u32) ~ 0;
 151
 152       a->address_key = mhash_set (&lm->address_to_if_address_index,
 153                                   addr_fib, ai, /* old_value */ 0);
 154       a->address_length = address_length;
 155       a->sw_if_index = sw_if_index;
 156       a->flags = 0;
 157       a->prev_this_sw_interface = pi;
 158       a->next_this_sw_interface = ~0;
 159       if (prev)
 160         prev->next_this_sw_interface = ai;
 161
 162       lm->if_address_pool_index_by_sw_if_index[sw_if_index] =
 163         (hi != ~0) ? hi : ai;
 164       if (result_if_address_index)
 165         *result_if_address_index = ai;
 166     }
 167   else
 168     {
 169       if (sw_if_index != a->sw_if_index)
 170         {
 171           if (result_if_address_index)
 172             *result_if_address_index = ~0;
 173           vnm->api_errno = VNET_API_ERROR_DUPLICATE_IF_ADDRESS;
 174           return clib_error_create
 175             ("Prefix %U already found on interface %U",
 176              lm->format_address_and_length, addr_fib, address_length,
 177              format_vnet_sw_if_index_name, vnm, a->sw_if_index);
 178         }
 179
 180       if (result_if_address_index)
 181         *result_if_address_index = a - lm->if_address_pool;
 182     }
 183
 184   return /* no error */ 0;
 185 }
 186
 187 static clib_error_t *
 188 ip_sw_interface_add_del (vnet_main_t * vnm, u32 sw_if_index, u32 is_add)
 189 {
 190   vec_validate_init_empty (ip4_main.
 191                            lookup_main.if_address_pool_index_by_sw_if_index,
 192                            sw_if_index, ~0);
 193   vec_validate_init_empty (ip6_main.
 194                            lookup_main.if_address_pool_index_by_sw_if_index,
 195                            sw_if_index, ~0);
 196
 197   return (NULL);
 198 }
 199
 200 VNET_SW_INTERFACE_ADD_DEL_FUNCTION (ip_sw_interface_add_del);
 201
 202 void
 203 ip_lookup_init (ip_lookup_main_t * lm, u32 is_ip6)
 204 {
 205   if (!lm->fib_result_n_bytes)
 206     lm->fib_result_n_bytes = sizeof (uword);
 207
 208   lm->is_ip6 = is_ip6;
 209   if (is_ip6)
 210     {
 211       lm->format_address_and_length = format_ip6_address_and_length;
 212       mhash_init (&lm->address_to_if_address_index, sizeof (uword),
 213                   sizeof (ip6_address_fib_t));
 214     }
 215   else
 216     {
 217       lm->format_address_and_length = format_ip4_address_and_length;
 218       mhash_init (&lm->address_to_if_address_index, sizeof (uword),
 219                   sizeof (ip4_address_fib_t));
 220     }
 221
 222   {
 223     int i;
 224
 225     /* Setup all IP protocols to be punted and builtin-unknown. */
 226     for (i = 0; i < 256; i++)
 227       {
 228         lm->local_next_by_ip_protocol[i] = IP_LOCAL_NEXT_PUNT;
 229         lm->builtin_protocol_by_ip_protocol[i] = IP_BUILTIN_PROTOCOL_UNKNOWN;
 230       }
 231
 232     lm->local_next_by_ip_protocol[IP_PROTOCOL_UDP] = IP_LOCAL_NEXT_UDP_LOOKUP;
 233     lm->local_next_by_ip_protocol[is_ip6 ? IP_PROTOCOL_ICMP6 :
 234                                   IP_PROTOCOL_ICMP] = IP_LOCAL_NEXT_ICMP;
 235     lm->builtin_protocol_by_ip_protocol[IP_PROTOCOL_UDP] =
 236       IP_BUILTIN_PROTOCOL_UDP;
 237     lm->builtin_protocol_by_ip_protocol[is_ip6 ? IP_PROTOCOL_ICMP6 :
 238                                         IP_PROTOCOL_ICMP] =
 239       IP_BUILTIN_PROTOCOL_ICMP;
 240   }
 241 }
 242
 243 u8 *
 244 format_ip_flow_hash_config (u8 * s, va_list * args)
 245 {
 246   flow_hash_config_t flow_hash_config = va_arg (*args, u32);
 247
 248 #define _(n,v) if (flow_hash_config & v) s = format (s, "%s ", #n);
 249   foreach_flow_hash_bit;
 250 #undef _
 251
 252   return s;
 253 }
 254
 255 u8 *
 256 format_ip_adjacency_packet_data (u8 * s, va_list * args)
 257 {
 258   u32 adj_index = va_arg (*args, u32);
 259   u8 *packet_data = va_arg (*args, u8 *);
 260   u32 n_packet_data_bytes = va_arg (*args, u32);
 261   ip_adjacency_t *adj = adj_get (adj_index);
 262
 263   switch (adj->lookup_next_index)
 264     {
 265     case IP_LOOKUP_NEXT_REWRITE:
 266     case IP_LOOKUP_NEXT_MCAST:
 267       s =
 268         format (s, "%U", format_hex_bytes, packet_data, n_packet_data_bytes);
 269       break;
 270
 271     default:
 272       break;
 273     }
 274
 275   return s;
 276 }
 277
 278 static uword
 279 unformat_dpo (unformat_input_t * input, va_list * args)
 280 {
 281   dpo_id_t *dpo = va_arg (*args, dpo_id_t *);
 282   fib_protocol_t fp = va_arg (*args, int);
 283   dpo_proto_t proto;
 284
 285   proto = fib_proto_to_dpo (fp);
 286
 287   if (unformat (input, "drop"))
 288     dpo_copy (dpo, drop_dpo_get (proto));
 289   else if (unformat (input, "punt"))
 290     dpo_copy (dpo, punt_dpo_get (proto));
 291   else if (unformat (input, "local"))
 292     receive_dpo_add_or_lock (proto, ~0, NULL, dpo);
 293   else if (unformat (input, "null-send-unreach"))
 294     ip_null_dpo_add_and_lock (proto, IP_NULL_ACTION_SEND_ICMP_UNREACH, dpo);
 295   else if (unformat (input, "null-send-prohibit"))
 296     ip_null_dpo_add_and_lock (proto, IP_NULL_ACTION_SEND_ICMP_PROHIBIT, dpo);
 297   else if (unformat (input, "null"))
 298     ip_null_dpo_add_and_lock (proto, IP_NULL_ACTION_NONE, dpo);
 299   else if (unformat (input, "classify"))
 300     {
 301       u32 classify_table_index;
 302
 303       if (!unformat (input, "%d", &classify_table_index))
 304         {
 305           clib_warning ("classify adj must specify table index");
 306           return 0;
 307         }
 308
 309       dpo_set (dpo, DPO_CLASSIFY, proto,
 310                classify_dpo_create (proto, classify_table_index));
 311     }
 312   else
 313     return 0;
 314
 315   return 1;
 316 }
 317
 318 const ip46_address_t zero_addr = {
 319   .as_u64 = {
 320              0, 0},
 321 };
 322
 323 static clib_error_t *
 324 vnet_ip_route_cmd (vlib_main_t * vm,
 325                    unformat_input_t * main_input, vlib_cli_command_t * cmd)
 326 {
 327   unformat_input_t _line_input, *line_input = &_line_input;
 328   u32 table_id, is_del, fib_index, payload_proto;
 329   dpo_id_t dpo = DPO_INVALID, *dpos = NULL;
 330   fib_route_path_t *rpaths = NULL, rpath;
 331   fib_prefix_t *prefixs = NULL, pfx;
 332   clib_error_t *error = NULL;
 333   f64 count;
 334   int i;
 335
 336   is_del = 0;
 337   table_id = 0;
 338   count = 1;
 339   memset (&pfx, 0, sizeof (pfx));
 340
 341   /* Get a line of input. */
 342   if (!unformat_user (main_input, unformat_line_input, line_input))
 343     return 0;
 344
 345   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 346     {
 347       memset (&rpath, 0, sizeof (rpath));
 348
 349       if (unformat (line_input, "table %d", &table_id))
 350         ;
 351       else if (unformat (line_input, "count %f", &count))
 352         ;
 353
 354       else if (unformat (line_input, "%U/%d",
 355                          unformat_ip4_address, &pfx.fp_addr.ip4, &pfx.fp_len))
 356         {
 357           payload_proto = pfx.fp_proto = FIB_PROTOCOL_IP4;
 358           vec_add1 (prefixs, pfx);
 359         }
 360       else if (unformat (line_input, "%U/%d",
 361                          unformat_ip6_address, &pfx.fp_addr.ip6, &pfx.fp_len))
 362         {
 363           payload_proto = pfx.fp_proto = FIB_PROTOCOL_IP6;
 364           vec_add1 (prefixs, pfx);
 365         }
 366       else if (unformat (line_input, "via %U",
 367                          unformat_fib_route_path, &rpath, &payload_proto))
 368         {
 369           vec_add1 (rpaths, rpath);
 370         }
 371       else if (vec_len (prefixs) > 0 &&
 372                unformat (line_input, "via %U",
 373                          unformat_dpo, &dpo, prefixs[0].fp_proto))
 374         {
 375           vec_add1 (dpos, dpo);
 376         }
 377       else if (unformat (line_input, "del"))
 378         is_del = 1;
 379       else if (unformat (line_input, "add"))
 380         is_del = 0;
 381       else
 382         {
 383           error = unformat_parse_error (line_input);
 384           goto done;
 385         }
 386     }
 387
 388   if (vec_len (prefixs) == 0)
 389     {
 390       error =
 391         clib_error_return (0, "expected ip4/ip6 destination address/length.");
 392       goto done;
 393     }
 394
 395   if (!is_del && vec_len (rpaths) + vec_len (dpos) == 0)
 396     {
 397       error = clib_error_return (0, "expected paths.");
 398       goto done;
 399     }
 400
 401   if (~0 == table_id)
 402     {
 403       /*
 404        * if no table_id is passed we will manipulate the default
 405        */
 406       fib_index = 0;
 407     }
 408   else
 409     {
 410       fib_index = fib_table_find (prefixs[0].fp_proto, table_id);
 411
 412       if (~0 == fib_index)
 413         {
 414           error = clib_error_return (0, "Nonexistent table id %d", table_id);
 415           goto done;
 416         }
 417     }
 418
 419   for (i = 0; i < vec_len (prefixs); i++)
 420     {
 421       if (is_del && 0 == vec_len (rpaths))
 422         {
 423           fib_table_entry_delete (fib_index, &prefixs[i], FIB_SOURCE_CLI);
 424         }
 425       else if (!is_del && 1 == vec_len (dpos))
 426         {
 427           fib_table_entry_special_dpo_add (fib_index,
 428                                            &prefixs[i],
 429                                            FIB_SOURCE_CLI,
 430                                            FIB_ENTRY_FLAG_EXCLUSIVE,
 431                                            &dpos[0]);
 432           dpo_reset (&dpos[0]);
 433         }
 434       else if (vec_len (dpos) > 0)
 435         {
 436           error =
 437             clib_error_return (0,
 438                                "Load-balancing over multiple special adjacencies is unsupported");
 439           goto done;
 440         }
 441       else if (0 < vec_len (rpaths))
 442         {
 443           u32 k, j, n, incr;
 444           ip46_address_t dst = prefixs[i].fp_addr;
 445           f64 t[2];
 446           n = count;
 447           t[0] = vlib_time_now (vm);
 448           incr = 1 << ((FIB_PROTOCOL_IP4 == prefixs[0].fp_proto ? 32 : 128) -
 449                        prefixs[i].fp_len);
 450
 451           for (k = 0; k < n; k++)
 452             {
 453               for (j = 0; j < vec_len (rpaths); j++)
 454                 {
 455                   u32 fi;
 456                   /*
 457                    * the CLI parsing stored table Ids, swap to FIB indicies
 458                    */
 459                   fi = fib_table_find (prefixs[i].fp_proto,
 460                                        rpaths[i].frp_fib_index);
 461
 462                   if (~0 == fi)
 463                     {
 464                       error =
 465                         clib_error_return (0, "Via table %d does not exist",
 466                                            rpaths[i].frp_fib_index);
 467                       goto done;
 468                     }
 469                   rpaths[i].frp_fib_index = fi;
 470
 471                   fib_prefix_t rpfx = {
 472                     .fp_len = prefixs[i].fp_len,
 473                     .fp_proto = prefixs[i].fp_proto,
 474                     .fp_addr = dst,
 475                   };
 476
 477                   if (is_del)
 478                     fib_table_entry_path_remove2 (fib_index,
 479                                                   &rpfx,
 480                                                   FIB_SOURCE_CLI, &rpaths[j]);
 481                   else
 482                     fib_table_entry_path_add2 (fib_index,
 483                                                &rpfx,
 484                                                FIB_SOURCE_CLI,
 485                                                FIB_ENTRY_FLAG_NONE,
 486                                                &rpaths[j]);
 487                 }
 488
 489               if (FIB_PROTOCOL_IP4 == prefixs[0].fp_proto)
 490                 {
 491                   dst.ip4.as_u32 =
 492                     clib_host_to_net_u32 (incr +
 493                                           clib_net_to_host_u32 (dst.
 494                                                                 ip4.as_u32));
 495                 }
 496               else
 497                 {
 498                   int bucket = (incr < 64 ? 0 : 1);
 499                   dst.ip6.as_u64[bucket] =
 500                     clib_host_to_net_u64 (incr +
 501                                           clib_net_to_host_u64 (dst.ip6.as_u64
 502                                                                 [bucket]));
 503
 504                 }
 505             }
 506           t[1] = vlib_time_now (vm);
 507           if (count > 1)
 508             vlib_cli_output (vm, "%.6e routes/sec", count / (t[1] - t[0]));
 509         }
 510       else
 511         {
 512           error = clib_error_return (0, "Don't understand what you want...");
 513           goto done;
 514         }
 515     }
 516
 517
 518 done:
 519   vec_free (dpos);
 520   vec_free (prefixs);
 521   vec_free (rpaths);
 522   unformat_free (line_input);
 523   return error;
 524 }
 525
 526 clib_error_t *
 527 vnet_ip_table_cmd (vlib_main_t * vm,
 528                    unformat_input_t * main_input,
 529                    vlib_cli_command_t * cmd, fib_protocol_t fproto)
 530 {
 531   unformat_input_t _line_input, *line_input = &_line_input;
 532   clib_error_t *error = NULL;
 533   u32 table_id, is_add;
 534   u8 *name = NULL;
 535
 536   is_add = 1;
 537   table_id = ~0;
 538
 539   /* Get a line of input. */
 540   if (!unformat_user (main_input, unformat_line_input, line_input))
 541     return 0;
 542
 543   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 544     {
 545       if (unformat (line_input, "%d", &table_id))
 546         ;
 547       else if (unformat (line_input, "del"))
 548         is_add = 0;
 549       else if (unformat (line_input, "add"))
 550         is_add = 1;
 551       else if (unformat (line_input, "name %s", &name))
 552         ;
 553       else
 554         {
 555           error = unformat_parse_error (line_input);
 556           goto done;
 557         }
 558     }
 559
 560   if (~0 == table_id)
 561     {
 562       error = clib_error_return (0, "No table id");
 563       goto done;
 564     }
 565   else if (0 == table_id)
 566     {
 567       error = clib_error_return (0, "Can't change the default table");
 568       goto done;
 569     }
 570   else
 571     {
 572       if (is_add)
 573         {
 574           ip_table_create (fproto, table_id, 0, name);
 575         }
 576       else
 577         {
 578           ip_table_delete (fproto, table_id, 0);
 579         }
 580     }
 581
 582 done:
 583   unformat_free (line_input);
 584   return error;
 585 }
 586
 587 clib_error_t *
 588 vnet_ip4_table_cmd (vlib_main_t * vm,
 589                     unformat_input_t * main_input, vlib_cli_command_t * cmd)
 590 {
 591   return (vnet_ip_table_cmd (vm, main_input, cmd, FIB_PROTOCOL_IP4));
 592 }
 593
 594 clib_error_t *
 595 vnet_ip6_table_cmd (vlib_main_t * vm,
 596                     unformat_input_t * main_input, vlib_cli_command_t * cmd)
 597 {
 598   return (vnet_ip_table_cmd (vm, main_input, cmd, FIB_PROTOCOL_IP6));
 599 }
 600
 601 /* *INDENT-OFF* */
 602 VLIB_CLI_COMMAND (vlib_cli_ip_command, static) = {
 603   .path = "ip",
 604   .short_help = "Internet protocol (IP) commands",
 605 };
 606 /* *INDENT-ON* */
 607
 608 /* *INDENT-OFF* */
 609 VLIB_CLI_COMMAND (vlib_cli_ip6_command, static) = {
 610   .path = "ip6",
 611   .short_help = "Internet protocol version 6 (IPv6) commands",
 612 };
 613 /* *INDENT-ON* */
 614
 615 /* *INDENT-OFF* */
 616 VLIB_CLI_COMMAND (vlib_cli_show_ip_command, static) = {
 617   .path = "show ip",
 618   .short_help = "Internet protocol (IP) show commands",
 619 };
 620 /* *INDENT-ON* */
 621
 622 /* *INDENT-OFF* */
 623 VLIB_CLI_COMMAND (vlib_cli_show_ip6_command, static) = {
 624   .path = "show ip6",
 625   .short_help = "Internet protocol version 6 (IPv6) show commands",
 626 };
 627 /* *INDENT-ON* */
 628
 629 /*?
 630  * This command is used to add or delete IPv4 or IPv6 routes. All
 631  * IP Addresses ('<em><dst-ip-addr>/<width></em>',
 632  * '<em><next-hop-ip-addr></em>' and '<em><adj-hop-ip-addr></em>')
 633  * can be IPv4 or IPv6, but all must be of the same form in a single
 634  * command. To display the current set of routes, use the commands
 635  * '<em>show ip fib</em>' and '<em>show ip6 fib</em>'.
 636  *
 637  * @cliexpar
 638  * Example of how to add a straight forward static route:
 639  * @cliexcmd{ip route add 6.0.1.2/32 via 6.0.0.1 GigabitEthernet2/0/0}
 640  * Example of how to delete a straight forward static route:
 641  * @cliexcmd{ip route del 6.0.1.2/32 via 6.0.0.1 GigabitEthernet2/0/0}
 642  * Mainly for route add/del performance testing, one can add or delete
 643  * multiple routes by adding 'count N' to the previous item:
 644  * @cliexcmd{ip route add count 10 7.0.0.0/24 via 6.0.0.1 GigabitEthernet2/0/0}
 645  * Add multiple routes for the same destination to create equal-cost multipath:
 646  * @cliexcmd{ip route add 7.0.0.1/32 via 6.0.0.1 GigabitEthernet2/0/0}
 647  * @cliexcmd{ip route add 7.0.0.1/32 via 6.0.0.2 GigabitEthernet2/0/0}
 648  * For unequal-cost multipath, specify the desired weights. This
 649  * combination of weights results in 3/4 of the traffic following the
 650  * second path, 1/4 following the first path:
 651  * @cliexcmd{ip route add 7.0.0.1/32 via 6.0.0.1 GigabitEthernet2/0/0 weight 1}
 652  * @cliexcmd{ip route add 7.0.0.1/32 via 6.0.0.2 GigabitEthernet2/0/0 weight 3}
 653  * To add a route to a particular FIB table (VRF), use:
 654  * @cliexcmd{ip route add 172.16.24.0/24 table 7 via GigabitEthernet2/0/0}
 655  ?*/
 656 /* *INDENT-OFF* */
 657 VLIB_CLI_COMMAND (ip_route_command, static) = {
 658   .path = "ip route",
 659   .short_help = "ip route [add|del] [count <n>] <dst-ip-addr>/<width> [table <table-id>] via [next-hop-address] [next-hop-interface] [next-hop-table <value>] [weight <value>] [preference <value>] [udp-encap-id <value>] [ip4-lookup-in-table <value>] [ip6-lookup-in-table <value>] [mpls-lookup-in-table <value>] [resolve-via-host] [resolve-via-connected] [rx-ip4 <interface>] [out-labels <value value value>]",
 660   .function = vnet_ip_route_cmd,
 661   .is_mp_safe = 1,
 662 };
 663
 664 /* *INDENT-ON* */
 665 /*?
 666  * This command is used to add or delete IPv4  Tables. All
 667  * Tables must be explicitly added before that can be used. Creating a
 668  * table will add both unicast and multicast FIBs
 669  *
 670  ?*/
 671 /* *INDENT-OFF* */
 672 VLIB_CLI_COMMAND (ip4_table_command, static) = {
 673   .path = "ip table",
 674   .short_help = "ip table [add|del] <table-id>",
 675   .function = vnet_ip4_table_cmd,
 676   .is_mp_safe = 1,
 677 };
 678 /* *INDENT-ON* */
 679
 680 /* *INDENT-ON* */
 681 /*?
 682  * This command is used to add or delete IPv4  Tables. All
 683  * Tables must be explicitly added before that can be used. Creating a
 684  * table will add both unicast and multicast FIBs
 685  *
 686  ?*/
 687 /* *INDENT-OFF* */
 688 VLIB_CLI_COMMAND (ip6_table_command, static) = {
 689   .path = "ip6 table",
 690   .short_help = "ip6 table [add|del] <table-id>",
 691   .function = vnet_ip6_table_cmd,
 692   .is_mp_safe = 1,
 693 };
 694
 695 static clib_error_t *
 696 ip_table_bind_cmd (vlib_main_t * vm,
 697                    unformat_input_t * input,
 698                    vlib_cli_command_t * cmd,
 699                    fib_protocol_t fproto)
 700 {
 701   vnet_main_t *vnm = vnet_get_main ();
 702   clib_error_t *error = 0;
 703   u32 sw_if_index, table_id;
 704   int rv;
 705
 706   sw_if_index = ~0;
 707
 708   if (!unformat_user (input, unformat_vnet_sw_interface, vnm, &sw_if_index))
 709     {
 710       error = clib_error_return (0, "unknown interface `%U'",
 711                                  format_unformat_error, input);
 712       goto done;
 713     }
 714
 715   if (unformat (input, "%d", &table_id))
 716     ;
 717   else
 718     {
 719       error = clib_error_return (0, "expected table id `%U'",
 720                                  format_unformat_error, input);
 721       goto done;
 722     }
 723
 724   rv = ip_table_bind (fproto, sw_if_index, table_id, 0);
 725
 726   if (VNET_API_ERROR_ADDRESS_FOUND_FOR_INTERFACE == rv)
 727     {
 728       error = clib_error_return (0, "IP addresses are still present on %U",
 729                                  format_vnet_sw_if_index_name,
 730                                  vnet_get_main(),
 731                                  sw_if_index);
 732     }
 733   else if (VNET_API_ERROR_NO_SUCH_FIB == rv)
 734     {
 735       error = clib_error_return (0, "no such table %d", table_id);
 736     }
 737   else if (0 != rv)
 738     {
 739       error = clib_error_return (0, "unknown error");
 740     }
 741
 742  done:
 743   return error;
 744 }
 745
 746 static clib_error_t *
 747 ip4_table_bind_cmd (vlib_main_t * vm,
 748                     unformat_input_t * input,
 749                     vlib_cli_command_t * cmd)
 750 {
 751   return (ip_table_bind_cmd (vm , input, cmd, FIB_PROTOCOL_IP4));
 752 }
 753
 754 static clib_error_t *
 755 ip6_table_bind_cmd (vlib_main_t * vm,
 756                     unformat_input_t * input,
 757                     vlib_cli_command_t * cmd)
 758 {
 759   return (ip_table_bind_cmd (vm , input, cmd, FIB_PROTOCOL_IP6));
 760 }
 761
 762 /*?
 763  * Place the indicated interface into the supplied IPv4 FIB table (also known
 764  * as a VRF). If the FIB table does not exist, this command creates it. To
 765  * display the current IPv4 FIB table, use the command '<em>show ip fib</em>'.
 766  * FIB table will only be displayed if a route has been added to the table, or
 767  * an IP Address is assigned to an interface in the table (which adds a route
 768  * automatically).
 769  *
 770  * @note IP addresses added after setting the interface IP table are added to
 771  * the indicated FIB table. If an IP address is added prior to changing the
 772  * table then this is an error. The control plane must remove these addresses
 773  * first and then change the table. VPP will not automatically move the
 774  * addresses from the old to the new table as it does not know the validity
 775  * of such a change.
 776  *
 777  * @cliexpar
 778  * Example of how to add an interface to an IPv4 FIB table (where 2 is the table-id):
 779  * @cliexcmd{set interface ip table GigabitEthernet2/0/0 2}
 780  ?*/
 781 /* *INDENT-OFF* */
 782 VLIB_CLI_COMMAND (set_interface_ip_table_command, static) =
 783 {
 784   .path = "set interface ip table",
 785   .function = ip4_table_bind_cmd,
 786   .short_help = "set interface ip table <interface> <table-id>",
 787 };
 788 /* *INDENT-ON* */
 789
 790 /*?
 791  * Place the indicated interface into the supplied IPv6 FIB table (also known
 792  * as a VRF). If the FIB table does not exist, this command creates it. To
 793  * display the current IPv6 FIB table, use the command '<em>show ip6 fib</em>'.
 794  * FIB table will only be displayed if a route has been added to the table, or
 795  * an IP Address is assigned to an interface in the table (which adds a route
 796  * automatically).
 797  *
 798  * @note IP addresses added after setting the interface IP table are added to
 799  * the indicated FIB table. If an IP address is added prior to changing the
 800  * table then this is an error. The control plane must remove these addresses
 801  * first and then change the table. VPP will not automatically move the
 802  * addresses from the old to the new table as it does not know the validity
 803  * of such a change.
 804  *
 805  * @cliexpar
 806  * Example of how to add an interface to an IPv6 FIB table (where 2 is the table-id):
 807  * @cliexcmd{set interface ip6 table GigabitEthernet2/0/0 2}
 808  ?*/
 809 /* *INDENT-OFF* */
 810 VLIB_CLI_COMMAND (set_interface_ip6_table_command, static) =
 811 {
 812   .path = "set interface ip6 table",
 813   .function = ip6_table_bind_cmd,
 814   .short_help = "set interface ip6 table <interface> <table-id>"
 815 };
 816 /* *INDENT-ON* */
 817
 818 clib_error_t *
 819 vnet_ip_mroute_cmd (vlib_main_t * vm,
 820                     unformat_input_t * main_input, vlib_cli_command_t * cmd)
 821 {
 822   unformat_input_t _line_input, *line_input = &_line_input;
 823   clib_error_t *error = NULL;
 824   fib_route_path_t rpath;
 825   u32 table_id, is_del;
 826   vnet_main_t *vnm;
 827   mfib_prefix_t pfx;
 828   u32 fib_index;
 829   mfib_itf_flags_t iflags = 0;
 830   mfib_entry_flags_t eflags = 0;
 831   u32 gcount, scount, ss, gg, incr;
 832   f64 timet[2];
 833
 834   gcount = scount = 1;
 835   vnm = vnet_get_main ();
 836   is_del = 0;
 837   table_id = 0;
 838   memset (&pfx, 0, sizeof (pfx));
 839   memset (&rpath, 0, sizeof (rpath));
 840   rpath.frp_sw_if_index = ~0;
 841
 842   /* Get a line of input. */
 843   if (!unformat_user (main_input, unformat_line_input, line_input))
 844     return 0;
 845
 846   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 847     {
 848       if (unformat (line_input, "table %d", &table_id))
 849         ;
 850       else if (unformat (line_input, "del"))
 851         is_del = 1;
 852       else if (unformat (line_input, "add"))
 853         is_del = 0;
 854       else if (unformat (line_input, "scount %d", &scount))
 855         ;
 856       else if (unformat (line_input, "gcount %d", &gcount))
 857         ;
 858       else if (unformat (line_input, "%U %U",
 859                          unformat_ip4_address,
 860                          &pfx.fp_src_addr.ip4,
 861                          unformat_ip4_address, &pfx.fp_grp_addr.ip4))
 862         {
 863           pfx.fp_proto = FIB_PROTOCOL_IP4;
 864           pfx.fp_len = 64;
 865         }
 866       else if (unformat (line_input, "%U %U",
 867                          unformat_ip6_address,
 868                          &pfx.fp_src_addr.ip6,
 869                          unformat_ip6_address, &pfx.fp_grp_addr.ip6))
 870         {
 871           pfx.fp_proto = FIB_PROTOCOL_IP6;
 872           pfx.fp_len = 256;
 873         }
 874       else if (unformat (line_input, "%U/%d",
 875                          unformat_ip4_address,
 876                          &pfx.fp_grp_addr.ip4, &pfx.fp_len))
 877         {
 878           memset (&pfx.fp_src_addr.ip4, 0, sizeof (pfx.fp_src_addr.ip4));
 879           pfx.fp_proto = FIB_PROTOCOL_IP4;
 880         }
 881       else if (unformat (line_input, "%U/%d",
 882                          unformat_ip6_address,
 883                          &pfx.fp_grp_addr.ip6, &pfx.fp_len))
 884         {
 885           memset (&pfx.fp_src_addr.ip6, 0, sizeof (pfx.fp_src_addr.ip6));
 886           pfx.fp_proto = FIB_PROTOCOL_IP6;
 887         }
 888       else if (unformat (line_input, "%U",
 889                          unformat_ip4_address, &pfx.fp_grp_addr.ip4))
 890         {
 891           memset (&pfx.fp_src_addr.ip4, 0, sizeof (pfx.fp_src_addr.ip4));
 892           pfx.fp_proto = FIB_PROTOCOL_IP4;
 893           pfx.fp_len = 32;
 894         }
 895       else if (unformat (line_input, "%U",
 896                          unformat_ip6_address, &pfx.fp_grp_addr.ip6))
 897         {
 898           memset (&pfx.fp_src_addr.ip6, 0, sizeof (pfx.fp_src_addr.ip6));
 899           pfx.fp_proto = FIB_PROTOCOL_IP6;
 900           pfx.fp_len = 128;
 901         }
 902       else if (unformat (line_input, "via %U",
 903                          unformat_vnet_sw_interface, vnm,
 904                          &rpath.frp_sw_if_index))
 905         {
 906           rpath.frp_weight = 1;
 907         }
 908       else if (unformat (line_input, "via local"))
 909         {
 910           rpath.frp_sw_if_index = ~0;
 911           rpath.frp_weight = 1;
 912           rpath.frp_flags |= FIB_ROUTE_PATH_LOCAL;
 913         }
 914       else if (unformat (line_input, "%U", unformat_mfib_itf_flags, &iflags))
 915         ;
 916       else if (unformat (line_input, "%U",
 917                          unformat_mfib_entry_flags, &eflags))
 918         ;
 919       else
 920         {
 921           error = unformat_parse_error (line_input);
 922           goto done;
 923         }
 924     }
 925
 926   if (~0 == table_id)
 927     {
 928       /*
 929        * if no table_id is passed we will manipulate the default
 930        */
 931       fib_index = 0;
 932     }
 933   else
 934     {
 935       fib_index = mfib_table_find (pfx.fp_proto, table_id);
 936
 937       if (~0 == fib_index)
 938         {
 939           error = clib_error_return (0, "Nonexistent table id %d", table_id);
 940           goto done;
 941         }
 942     }
 943
 944   timet[0] = vlib_time_now (vm);
 945
 946   if (FIB_PROTOCOL_IP4 == pfx.fp_proto)
 947     {
 948       incr = 1 << (32 - (pfx.fp_len % 32));
 949     }
 950   else
 951     {
 952       incr = 1 << (128 - (pfx.fp_len % 128));
 953     }
 954
 955   for (ss = 0; ss < scount; ss++)
 956     {
 957       for (gg = 0; gg < gcount; gg++)
 958         {
 959           if (is_del && 0 == rpath.frp_weight)
 960             {
 961               /* no path provided => route delete */
 962               mfib_table_entry_delete (fib_index, &pfx, MFIB_SOURCE_CLI);
 963             }
 964           else if (eflags)
 965             {
 966               mfib_table_entry_update (fib_index, &pfx, MFIB_SOURCE_CLI,
 967                                        MFIB_RPF_ID_NONE, eflags);
 968             }
 969           else
 970             {
 971               if (is_del)
 972                 mfib_table_entry_path_remove (fib_index,
 973                                               &pfx, MFIB_SOURCE_CLI, &rpath);
 974               else
 975                 mfib_table_entry_path_update (fib_index,
 976                                               &pfx, MFIB_SOURCE_CLI, &rpath,
 977                                               iflags);
 978             }
 979
 980           if (FIB_PROTOCOL_IP4 == pfx.fp_proto)
 981             {
 982               pfx.fp_grp_addr.ip4.as_u32 =
 983                 clib_host_to_net_u32 (incr +
 984                                       clib_net_to_host_u32 (pfx.
 985                                                             fp_grp_addr.ip4.
 986                                                             as_u32));
 987             }
 988           else
 989             {
 990               int bucket = (incr < 64 ? 0 : 1);
 991               pfx.fp_grp_addr.ip6.as_u64[bucket] =
 992                 clib_host_to_net_u64 (incr +
 993                                       clib_net_to_host_u64 (pfx.
 994                                                             fp_grp_addr.ip6.as_u64
 995                                                             [bucket]));
 996
 997             }
 998         }
 999       if (FIB_PROTOCOL_IP4 == pfx.fp_proto)
1000         {
1001           pfx.fp_src_addr.ip4.as_u32 =
1002             clib_host_to_net_u32 (1 +
1003                                   clib_net_to_host_u32 (pfx.fp_src_addr.
1004                                                         ip4.as_u32));
1005         }
1006       else
1007         {
1008           pfx.fp_src_addr.ip6.as_u64[1] =
1009             clib_host_to_net_u64 (1 +
1010                                   clib_net_to_host_u64 (pfx.fp_src_addr.
1011                                                         ip6.as_u64[1]));
1012         }
1013     }
1014
1015   timet[1] = vlib_time_now (vm);
1016
1017   if (scount > 1 || gcount > 1)
1018     vlib_cli_output (vm, "%.6e routes/sec",
1019                      (scount * gcount) / (timet[1] - timet[0]));
1020
1021 done:
1022   unformat_free (line_input);
1023
1024   return error;
1025 }
1026
1027 /*?
1028  * This command is used to add or delete IPv4 or IPv6  multicastroutes. All
1029  * IP Addresses ('<em><dst-ip-addr>/<width></em>',
1030  * '<em><next-hop-ip-addr></em>' and '<em><adj-hop-ip-addr></em>')
1031  * can be IPv4 or IPv6, but all must be of the same form in a single
1032  * command. To display the current set of routes, use the commands
1033  * '<em>show ip mfib</em>' and '<em>show ip6 mfib</em>'.
1034  * The full set of support flags for interfaces and route is shown via;
1035  * '<em>show mfib route flags</em>' and '<em>show mfib itf flags</em>'
1036  * respectively.
1037  * @cliexpar
1038  * Example of how to add a forwarding interface to a route (and create the
1039  * route if it does not exist)
1040  * @cliexcmd{ip mroute add 232.1.1.1 via GigabitEthernet2/0/0 Forward}
1041  * Example of how to add an accepting interface to a route (and create the
1042  * route if it does not exist)
1043  * @cliexcmd{ip mroute add 232.1.1.1 via GigabitEthernet2/0/1 Accept}
1044  * Example of changing the route's flags to send signals via the API
1045  * @cliexcmd{ip mroute add 232.1.1.1 Signal}
1046
1047  ?*/
1048 /* *INDENT-OFF* */
1049 VLIB_CLI_COMMAND (ip_mroute_command, static) =
1050 {
1051   .path = "ip mroute",
1052   .short_help = "ip mroute [add|del] <dst-ip-addr>/<width> [table <table-id>] [via <next-hop-ip-addr> [<interface>],",
1053   .function = vnet_ip_mroute_cmd,
1054   .is_mp_safe = 1,
1055 };
1056 /* *INDENT-ON* */
1057
1058 /*
1059  * The next two routines address a longstanding script hemorrhoid.
1060  * Probing a v4 or v6 neighbor needs to appear to be synchronous,
1061  * or dependent route-adds will simply fail.
1062  */
1063 static clib_error_t *
1064 ip6_probe_neighbor_wait (vlib_main_t * vm, ip6_address_t * a, u32 sw_if_index,
1065                          int retry_count)
1066 {
1067   vnet_main_t *vnm = vnet_get_main ();
1068   clib_error_t *e;
1069   int i;
1070   int resolved = 0;
1071   uword event_type;
1072   uword *event_data = 0;
1073
1074   ASSERT (vlib_in_process_context (vm));
1075
1076   if (retry_count > 0)
1077     vnet_register_ip6_neighbor_resolution_event
1078       (vnm, a, vlib_get_current_process (vm)->node_runtime.node_index,
1079        1 /* event */ , 0 /* data */ );
1080
1081   for (i = 0; i < retry_count; i++)
1082     {
1083       /* The interface may be down, etc. */
1084       e = ip6_probe_neighbor (vm, a, sw_if_index);
1085
1086       if (e)
1087         return e;
1088
1089       vlib_process_wait_for_event_or_clock (vm, 1.0);
1090       event_type = vlib_process_get_events (vm, &event_data);
1091       switch (event_type)
1092         {
1093         case 1:         /* resolved... */
1094           vlib_cli_output (vm, "Resolved %U", format_ip6_address, a);
1095           resolved = 1;
1096           goto done;
1097
1098         case ~0:                /* timeout */
1099           break;
1100
1101         default:
1102           clib_warning ("unknown event_type %d", event_type);
1103         }
1104       vec_reset_length (event_data);
1105     }
1106
1107 done:
1108
1109   if (!resolved)
1110     return clib_error_return (0, "Resolution failed for %U",
1111                               format_ip6_address, a);
1112   return 0;
1113 }
1114
1115 static clib_error_t *
1116 ip4_probe_neighbor_wait (vlib_main_t * vm, ip4_address_t * a, u32 sw_if_index,
1117                          int retry_count)
1118 {
1119   vnet_main_t *vnm = vnet_get_main ();
1120   clib_error_t *e;
1121   int i;
1122   int resolved = 0;
1123   uword event_type;
1124   uword *event_data = 0;
1125
1126   ASSERT (vlib_in_process_context (vm));
1127
1128   if (retry_count > 0)
1129     vnet_register_ip4_arp_resolution_event
1130       (vnm, a, vlib_get_current_process (vm)->node_runtime.node_index,
1131        1 /* event */ , 0 /* data */ );
1132
1133   for (i = 0; i < retry_count; i++)
1134     {
1135       /* The interface may be down, etc. */
1136       e = ip4_probe_neighbor (vm, a, sw_if_index);
1137
1138       if (e)
1139         return e;
1140
1141       vlib_process_wait_for_event_or_clock (vm, 1.0);
1142       event_type = vlib_process_get_events (vm, &event_data);
1143       switch (event_type)
1144         {
1145         case 1:         /* resolved... */
1146           vlib_cli_output (vm, "Resolved %U", format_ip4_address, a);
1147           resolved = 1;
1148           goto done;
1149
1150         case ~0:                /* timeout */
1151           break;
1152
1153         default:
1154           clib_warning ("unknown event_type %d", event_type);
1155         }
1156       vec_reset_length (event_data);
1157     }
1158
1159 done:
1160
1161   vec_reset_length (event_data);
1162
1163   if (!resolved)
1164     return clib_error_return (0, "Resolution failed for %U",
1165                               format_ip4_address, a);
1166   return 0;
1167 }
1168
1169 static clib_error_t *
1170 probe_neighbor_address (vlib_main_t * vm,
1171                         unformat_input_t * input, vlib_cli_command_t * cmd)
1172 {
1173   vnet_main_t *vnm = vnet_get_main ();
1174   unformat_input_t _line_input, *line_input = &_line_input;
1175   ip4_address_t a4;
1176   ip6_address_t a6;
1177   clib_error_t *error = 0;
1178   u32 sw_if_index = ~0;
1179   int retry_count = 3;
1180   int is_ip4 = 1;
1181   int address_set = 0;
1182
1183   /* Get a line of input. */
1184   if (!unformat_user (input, unformat_line_input, line_input))
1185     return 0;
1186
1187   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1188     {
1189       if (unformat_user (line_input, unformat_vnet_sw_interface, vnm,
1190                          &sw_if_index))
1191         ;
1192       else if (unformat (line_input, "retry %d", &retry_count))
1193         ;
1194
1195       else if (unformat (line_input, "%U", unformat_ip4_address, &a4))
1196         address_set++;
1197       else if (unformat (line_input, "%U", unformat_ip6_address, &a6))
1198         {
1199           address_set++;
1200           is_ip4 = 0;
1201         }
1202       else
1203         {
1204           error = clib_error_return (0, "unknown input '%U'",
1205                                      format_unformat_error, line_input);
1206           goto done;
1207         }
1208     }
1209
1210   if (sw_if_index == ~0)
1211     {
1212       error = clib_error_return (0, "Interface required, not set.");
1213       goto done;
1214     }
1215   if (address_set == 0)
1216     {
1217       error = clib_error_return (0, "ip address required, not set.");
1218       goto done;
1219     }
1220   if (address_set > 1)
1221     {
1222       error = clib_error_return (0, "Multiple ip addresses not supported.");
1223       goto done;
1224     }
1225
1226   if (is_ip4)
1227     error = ip4_probe_neighbor_wait (vm, &a4, sw_if_index, retry_count);
1228   else
1229     error = ip6_probe_neighbor_wait (vm, &a6, sw_if_index, retry_count);
1230
1231 done:
1232   unformat_free (line_input);
1233
1234   return error;
1235 }
1236
1237 /*?
1238  * The '<em>ip probe-neighbor</em>' command ARPs for IPv4 addresses or
1239  * attempts IPv6 neighbor discovery depending on the supplied IP address
1240  * format.
1241  *
1242  * @note This command will not immediately affect the indicated FIB; it
1243  * is not suitable for use in establishing a FIB entry prior to adding
1244  * recursive FIB entries. As in: don't use it in a script to probe a
1245  * gateway prior to adding a default route. It won't work. Instead,
1246  * configure a static ARP cache entry [see '<em>set ip arp</em>'], or
1247  * a static IPv6 neighbor [see '<em>set ip6 neighbor</em>'].
1248  *
1249  * @cliexpar
1250  * Example of probe for an IPv4 address:
1251  * @cliexcmd{ip probe-neighbor GigabitEthernet2/0/0 172.16.1.2}
1252 ?*/
1253 /* *INDENT-OFF* */
1254 VLIB_CLI_COMMAND (ip_probe_neighbor_command, static) = {
1255   .path = "ip probe-neighbor",
1256   .function = probe_neighbor_address,
1257   .short_help = "ip probe-neighbor <interface> <ip4-addr> | <ip6-addr> [retry nn]",
1258   .is_mp_safe = 1,
1259 };
1260 /* *INDENT-ON* */
1261
1262 clib_error_t *
1263 vnet_ip_container_proxy_add_del (vnet_ip_container_proxy_args_t * args)
1264 {
1265   u32 fib_index;
1266
1267   if (!vnet_sw_interface_is_api_valid (vnet_get_main (), args->sw_if_index))
1268     return clib_error_return_code (0, VNET_API_ERROR_INVALID_INTERFACE, 0,
1269                                    "invalid sw_if_index");
1270
1271   fib_index = fib_table_get_table_id_for_sw_if_index (args->prefix.fp_proto,
1272                                                       args->sw_if_index);
1273   if (args->is_add)
1274     {
1275       dpo_id_t proxy_dpo = DPO_INVALID;
1276       l3_proxy_dpo_add_or_lock (fib_proto_to_dpo (args->prefix.fp_proto),
1277                                 args->sw_if_index, &proxy_dpo);
1278       fib_table_entry_special_dpo_add (fib_index,
1279                                        &args->prefix,
1280                                        FIB_SOURCE_PROXY,
1281                                        FIB_ENTRY_FLAG_EXCLUSIVE, &proxy_dpo);
1282       dpo_reset (&proxy_dpo);
1283     }
1284   else
1285     {
1286       fib_table_entry_special_remove (fib_index, &args->prefix,
1287                                       FIB_SOURCE_PROXY);
1288     }
1289   return 0;
1290 }
1291
1292 u8
1293 ip_container_proxy_is_set (fib_prefix_t * pfx, u32 sw_if_index)
1294 {
1295   u32 fib_index;
1296   fib_node_index_t fei;
1297   const dpo_id_t *dpo;
1298   l3_proxy_dpo_t *l3p;
1299   load_balance_t *lb0;
1300
1301   fib_index = fib_table_get_table_id_for_sw_if_index (pfx->fp_proto,
1302                                                       sw_if_index);
1303   if (fib_index == ~0)
1304     return 0;
1305
1306   fei = fib_table_lookup_exact_match (fib_index, pfx);
1307   if (fei == FIB_NODE_INDEX_INVALID)
1308     return 0;
1309
1310   dpo = fib_entry_contribute_ip_forwarding (fei);
1311   lb0 = load_balance_get (dpo->dpoi_index);
1312   dpo = load_balance_get_bucket_i (lb0, 0);
1313   if (dpo->dpoi_type != DPO_L3_PROXY)
1314     return 0;
1315
1316   l3p = l3_proxy_dpo_get (dpo->dpoi_index);
1317   return (l3p->l3p_sw_if_index == sw_if_index);
1318 }
1319
1320 clib_error_t *
1321 ip_container_cmd (vlib_main_t * vm,
1322                   unformat_input_t * main_input, vlib_cli_command_t * cmd)
1323 {
1324   unformat_input_t _line_input, *line_input = &_line_input;
1325   fib_prefix_t pfx;
1326   u32 is_del, addr_set = 0;
1327   vnet_main_t *vnm;
1328   u32 sw_if_index;
1329
1330   vnm = vnet_get_main ();
1331   is_del = 0;
1332   sw_if_index = ~0;
1333   memset (&pfx, 0, sizeof (pfx));
1334
1335   /* Get a line of input. */
1336   if (!unformat_user (main_input, unformat_line_input, line_input))
1337     return 0;
1338
1339   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1340     {
1341       if (unformat (line_input, "%U", unformat_ip4_address, &pfx.fp_addr.ip4))
1342         {
1343           pfx.fp_proto = FIB_PROTOCOL_IP4;
1344           pfx.fp_len = 32;
1345           addr_set = 1;
1346         }
1347       else if (unformat (line_input, "%U",
1348                          unformat_ip6_address, &pfx.fp_addr.ip6))
1349         {
1350           pfx.fp_proto = FIB_PROTOCOL_IP6;
1351           pfx.fp_len = 128;
1352           addr_set = 1;
1353         }
1354       else if (unformat (line_input, "%U",
1355                          unformat_vnet_sw_interface, vnm, &sw_if_index))
1356         ;
1357       else if (unformat (line_input, "del"))
1358         is_del = 1;
1359       else
1360         {
1361           unformat_free (line_input);
1362           return (clib_error_return (0, "unknown input '%U'",
1363                                      format_unformat_error, line_input));
1364         }
1365     }
1366
1367   if (~0 == sw_if_index || !addr_set)
1368     {
1369       unformat_free (line_input);
1370       vlib_cli_output (vm, "interface and address must be set");
1371       return 0;
1372     }
1373
1374   vnet_ip_container_proxy_args_t args = {
1375     .prefix = pfx,
1376     .sw_if_index = sw_if_index,
1377     .is_add = !is_del,
1378   };
1379   vnet_ip_container_proxy_add_del (&args);
1380   unformat_free (line_input);
1381   return (NULL);
1382 }
1383
1384 /* *INDENT-OFF* */
1385 VLIB_CLI_COMMAND (ip_container_command_node, static) = {
1386   .path = "ip container",
1387   .function = ip_container_cmd,
1388   .short_help = "ip container <address> <interface>",
1389   .is_mp_safe = 1,
1390 };
1391 /* *INDENT-ON* */
1392
1393 clib_error_t *
1394 show_ip_container_cmd_fn (vlib_main_t * vm, unformat_input_t * main_input,
1395                           vlib_cli_command_t * cmd)
1396 {
1397   unformat_input_t _line_input, *line_input = &_line_input;
1398   vnet_main_t *vnm = vnet_get_main ();
1399   fib_prefix_t pfx;
1400   u32 sw_if_index = ~0;
1401   u8 has_proxy;
1402
1403   if (!unformat_user (main_input, unformat_line_input, line_input))
1404     return 0;
1405   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1406     {
1407       if (unformat (line_input, "%U", unformat_ip4_address, &pfx.fp_addr.ip4))
1408         {
1409           pfx.fp_proto = FIB_PROTOCOL_IP4;
1410           pfx.fp_len = 32;
1411         }
1412       else if (unformat (line_input, "%U",
1413                          unformat_ip6_address, &pfx.fp_addr.ip6))
1414         {
1415           pfx.fp_proto = FIB_PROTOCOL_IP6;
1416           pfx.fp_len = 128;
1417         }
1418       else if (unformat (line_input, "%U",
1419                          unformat_vnet_sw_interface, vnm, &sw_if_index))
1420         ;
1421       else
1422         {
1423           unformat_free (line_input);
1424           return (clib_error_return (0, "unknown input '%U'",
1425                                      format_unformat_error, line_input));
1426         }
1427     }
1428
1429   if (~0 == sw_if_index)
1430     {
1431       unformat_free (line_input);
1432       vlib_cli_output (vm, "no interface");
1433       return (clib_error_return (0, "no interface"));
1434     }
1435
1436   has_proxy = ip_container_proxy_is_set (&pfx, sw_if_index);
1437   vlib_cli_output (vm, "ip container proxy is: %s", has_proxy ? "on" : "off");
1438
1439   unformat_free (line_input);
1440   return 0;
1441 }
1442
1443 /* *INDENT-OFF* */
1444 VLIB_CLI_COMMAND (show_ip_container_command, static) = {
1445   .path = "show ip container",
1446   .function = show_ip_container_cmd_fn,
1447   .short_help = "show ip container <address> <interface>",
1448   .is_mp_safe = 1,
1449 };
1450 /* *INDENT-ON* */
1451
1452 /*
1453  * fd.io coding-style-patch-verification: ON
1454  *
1455  * Local Variables:
1456  * eval: (c-set-style "gnu")
1457  * End:
1458  */