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                   fib_prefix_t rpfx = {
 456                     .fp_len = prefixs[i].fp_len,
 457                     .fp_proto = prefixs[i].fp_proto,
 458                     .fp_addr = dst,
 459                   };
 460
 461                   if (is_del)
 462                     fib_table_entry_path_remove2 (fib_index,
 463                                                   &rpfx,
 464                                                   FIB_SOURCE_CLI, &rpaths[j]);
 465                   else
 466                     fib_table_entry_path_add2 (fib_index,
 467                                                &rpfx,
 468                                                FIB_SOURCE_CLI,
 469                                                FIB_ENTRY_FLAG_NONE,
 470                                                &rpaths[j]);
 471                 }
 472
 473               if (FIB_PROTOCOL_IP4 == prefixs[0].fp_proto)
 474                 {
 475                   dst.ip4.as_u32 =
 476                     clib_host_to_net_u32 (incr +
 477                                           clib_net_to_host_u32 (dst.
 478                                                                 ip4.as_u32));
 479                 }
 480               else
 481                 {
 482                   int bucket = (incr < 64 ? 0 : 1);
 483                   dst.ip6.as_u64[bucket] =
 484                     clib_host_to_net_u64 (incr +
 485                                           clib_net_to_host_u64 (dst.ip6.as_u64
 486                                                                 [bucket]));
 487
 488                 }
 489             }
 490           t[1] = vlib_time_now (vm);
 491           if (count > 1)
 492             vlib_cli_output (vm, "%.6e routes/sec", count / (t[1] - t[0]));
 493         }
 494       else
 495         {
 496           error = clib_error_return (0, "Don't understand what you want...");
 497           goto done;
 498         }
 499     }
 500
 501
 502 done:
 503   vec_free (dpos);
 504   vec_free (prefixs);
 505   vec_free (rpaths);
 506   unformat_free (line_input);
 507   return error;
 508 }
 509
 510 clib_error_t *
 511 vnet_ip_table_cmd (vlib_main_t * vm,
 512                    unformat_input_t * main_input,
 513                    vlib_cli_command_t * cmd, fib_protocol_t fproto)
 514 {
 515   unformat_input_t _line_input, *line_input = &_line_input;
 516   clib_error_t *error = NULL;
 517   u32 table_id, is_add;
 518   u8 *name = NULL;
 519
 520   is_add = 1;
 521   table_id = ~0;
 522
 523   /* Get a line of input. */
 524   if (!unformat_user (main_input, unformat_line_input, line_input))
 525     return 0;
 526
 527   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 528     {
 529       if (unformat (line_input, "%d", &table_id))
 530         ;
 531       else if (unformat (line_input, "del"))
 532         is_add = 0;
 533       else if (unformat (line_input, "add"))
 534         is_add = 1;
 535       else if (unformat (line_input, "name %s", &name))
 536         ;
 537       else
 538         {
 539           error = unformat_parse_error (line_input);
 540           goto done;
 541         }
 542     }
 543
 544   if (~0 == table_id)
 545     {
 546       error = clib_error_return (0, "No table id");
 547       goto done;
 548     }
 549   else if (0 == table_id)
 550     {
 551       error = clib_error_return (0, "Can't change the default table");
 552       goto done;
 553     }
 554   else
 555     {
 556       if (is_add)
 557         {
 558           ip_table_create (fproto, table_id, 0, name);
 559         }
 560       else
 561         {
 562           ip_table_delete (fproto, table_id, 0);
 563         }
 564     }
 565
 566 done:
 567   unformat_free (line_input);
 568   return error;
 569 }
 570
 571 clib_error_t *
 572 vnet_ip4_table_cmd (vlib_main_t * vm,
 573                     unformat_input_t * main_input, vlib_cli_command_t * cmd)
 574 {
 575   return (vnet_ip_table_cmd (vm, main_input, cmd, FIB_PROTOCOL_IP4));
 576 }
 577
 578 clib_error_t *
 579 vnet_ip6_table_cmd (vlib_main_t * vm,
 580                     unformat_input_t * main_input, vlib_cli_command_t * cmd)
 581 {
 582   return (vnet_ip_table_cmd (vm, main_input, cmd, FIB_PROTOCOL_IP6));
 583 }
 584
 585 /* *INDENT-OFF* */
 586 VLIB_CLI_COMMAND (vlib_cli_ip_command, static) = {
 587   .path = "ip",
 588   .short_help = "Internet protocol (IP) commands",
 589 };
 590 /* *INDENT-ON* */
 591
 592 /* *INDENT-OFF* */
 593 VLIB_CLI_COMMAND (vlib_cli_ip6_command, static) = {
 594   .path = "ip6",
 595   .short_help = "Internet protocol version 6 (IPv6) commands",
 596 };
 597 /* *INDENT-ON* */
 598
 599 /* *INDENT-OFF* */
 600 VLIB_CLI_COMMAND (vlib_cli_show_ip_command, static) = {
 601   .path = "show ip",
 602   .short_help = "Internet protocol (IP) show commands",
 603 };
 604 /* *INDENT-ON* */
 605
 606 /* *INDENT-OFF* */
 607 VLIB_CLI_COMMAND (vlib_cli_show_ip6_command, static) = {
 608   .path = "show ip6",
 609   .short_help = "Internet protocol version 6 (IPv6) show commands",
 610 };
 611 /* *INDENT-ON* */
 612
 613 /*?
 614  * This command is used to add or delete IPv4 or IPv6 routes. All
 615  * IP Addresses ('<em><dst-ip-addr>/<width></em>',
 616  * '<em><next-hop-ip-addr></em>' and '<em><adj-hop-ip-addr></em>')
 617  * can be IPv4 or IPv6, but all must be of the same form in a single
 618  * command. To display the current set of routes, use the commands
 619  * '<em>show ip fib</em>' and '<em>show ip6 fib</em>'.
 620  *
 621  * @cliexpar
 622  * Example of how to add a straight forward static route:
 623  * @cliexcmd{ip route add 6.0.1.2/32 via 6.0.0.1 GigabitEthernet2/0/0}
 624  * Example of how to delete a straight forward static route:
 625  * @cliexcmd{ip route del 6.0.1.2/32 via 6.0.0.1 GigabitEthernet2/0/0}
 626  * Mainly for route add/del performance testing, one can add or delete
 627  * multiple routes by adding 'count N' to the previous item:
 628  * @cliexcmd{ip route add count 10 7.0.0.0/24 via 6.0.0.1 GigabitEthernet2/0/0}
 629  * Add multiple routes for the same destination to create equal-cost multipath:
 630  * @cliexcmd{ip route add 7.0.0.1/32 via 6.0.0.1 GigabitEthernet2/0/0}
 631  * @cliexcmd{ip route add 7.0.0.1/32 via 6.0.0.2 GigabitEthernet2/0/0}
 632  * For unequal-cost multipath, specify the desired weights. This
 633  * combination of weights results in 3/4 of the traffic following the
 634  * second path, 1/4 following the first path:
 635  * @cliexcmd{ip route add 7.0.0.1/32 via 6.0.0.1 GigabitEthernet2/0/0 weight 1}
 636  * @cliexcmd{ip route add 7.0.0.1/32 via 6.0.0.2 GigabitEthernet2/0/0 weight 3}
 637  * To add a route to a particular FIB table (VRF), use:
 638  * @cliexcmd{ip route add 172.16.24.0/24 table 7 via GigabitEthernet2/0/0}
 639  ?*/
 640 /* *INDENT-OFF* */
 641 VLIB_CLI_COMMAND (ip_route_command, static) = {
 642   .path = "ip route",
 643   .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>]",
 644   .function = vnet_ip_route_cmd,
 645   .is_mp_safe = 1,
 646 };
 647
 648 /* *INDENT-ON* */
 649 /*?
 650  * This command is used to add or delete IPv4  Tables. All
 651  * Tables must be explicitly added before that can be used. Creating a
 652  * table will add both unicast and multicast FIBs
 653  *
 654  ?*/
 655 /* *INDENT-OFF* */
 656 VLIB_CLI_COMMAND (ip4_table_command, static) = {
 657   .path = "ip table",
 658   .short_help = "ip table [add|del] <table-id>",
 659   .function = vnet_ip4_table_cmd,
 660   .is_mp_safe = 1,
 661 };
 662 /* *INDENT-ON* */
 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 (ip6_table_command, static) = {
 673   .path = "ip6 table",
 674   .short_help = "ip6 table [add|del] <table-id>",
 675   .function = vnet_ip6_table_cmd,
 676   .is_mp_safe = 1,
 677 };
 678
 679 static clib_error_t *
 680 ip_table_bind_cmd (vlib_main_t * vm,
 681                    unformat_input_t * input,
 682                    vlib_cli_command_t * cmd,
 683                    fib_protocol_t fproto)
 684 {
 685   vnet_main_t *vnm = vnet_get_main ();
 686   clib_error_t *error = 0;
 687   u32 sw_if_index, table_id;
 688   int rv;
 689
 690   sw_if_index = ~0;
 691
 692   if (!unformat_user (input, unformat_vnet_sw_interface, vnm, &sw_if_index))
 693     {
 694       error = clib_error_return (0, "unknown interface `%U'",
 695                                  format_unformat_error, input);
 696       goto done;
 697     }
 698
 699   if (unformat (input, "%d", &table_id))
 700     ;
 701   else
 702     {
 703       error = clib_error_return (0, "expected table id `%U'",
 704                                  format_unformat_error, input);
 705       goto done;
 706     }
 707
 708   rv = ip_table_bind (fproto, sw_if_index, table_id, 0);
 709
 710   if (VNET_API_ERROR_ADDRESS_FOUND_FOR_INTERFACE == rv)
 711     {
 712       error = clib_error_return (0, "IP addresses are still present on %U",
 713                                  format_vnet_sw_if_index_name,
 714                                  vnet_get_main(),
 715                                  sw_if_index);
 716     }
 717   else if (VNET_API_ERROR_NO_SUCH_FIB == rv)
 718     {
 719       error = clib_error_return (0, "no such table %d", table_id);
 720     }
 721   else if (0 != rv)
 722     {
 723       error = clib_error_return (0, "unknown error");
 724     }
 725
 726  done:
 727   return error;
 728 }
 729
 730 static clib_error_t *
 731 ip4_table_bind_cmd (vlib_main_t * vm,
 732                     unformat_input_t * input,
 733                     vlib_cli_command_t * cmd)
 734 {
 735   return (ip_table_bind_cmd (vm , input, cmd, FIB_PROTOCOL_IP4));
 736 }
 737
 738 static clib_error_t *
 739 ip6_table_bind_cmd (vlib_main_t * vm,
 740                     unformat_input_t * input,
 741                     vlib_cli_command_t * cmd)
 742 {
 743   return (ip_table_bind_cmd (vm , input, cmd, FIB_PROTOCOL_IP6));
 744 }
 745
 746 /*?
 747  * Place the indicated interface into the supplied IPv4 FIB table (also known
 748  * as a VRF). The FIB table must be created using "ip table add" already. To
 749  * display the current IPv4 FIB table, use the command '<em>show ip fib</em>'.
 750  * FIB table will only be displayed if a route has been added to the table, or
 751  * an IP Address is assigned to an interface in the table (which adds a route
 752  * automatically).
 753  *
 754  * @note IP addresses added after setting the interface IP table are added to
 755  * the indicated FIB table. If an IP address is added prior to changing the
 756  * table then this is an error. The control plane must remove these addresses
 757  * first and then change the table. VPP will not automatically move the
 758  * addresses from the old to the new table as it does not know the validity
 759  * of such a change.
 760  *
 761  * @cliexpar
 762  * Example of how to add an interface to an IPv4 FIB table (where 2 is the table-id):
 763  * @cliexcmd{set interface ip table GigabitEthernet2/0/0 2}
 764  ?*/
 765 /* *INDENT-OFF* */
 766 VLIB_CLI_COMMAND (set_interface_ip_table_command, static) =
 767 {
 768   .path = "set interface ip table",
 769   .function = ip4_table_bind_cmd,
 770   .short_help = "set interface ip table <interface> <table-id>",
 771 };
 772 /* *INDENT-ON* */
 773
 774 /*?
 775  * Place the indicated interface into the supplied IPv6 FIB table (also known
 776  * as a VRF). The FIB table must be created using "ip6 table add" already. To
 777  * display the current IPv6 FIB table, use the command '<em>show ip6 fib</em>'.
 778  * FIB table will only be displayed if a route has been added to the table, or
 779  * an IP Address is assigned to an interface in the table (which adds a route
 780  * automatically).
 781  *
 782  * @note IP addresses added after setting the interface IP table are added to
 783  * the indicated FIB table. If an IP address is added prior to changing the
 784  * table then this is an error. The control plane must remove these addresses
 785  * first and then change the table. VPP will not automatically move the
 786  * addresses from the old to the new table as it does not know the validity
 787  * of such a change.
 788  *
 789  * @cliexpar
 790  * Example of how to add an interface to an IPv6 FIB table (where 2 is the table-id):
 791  * @cliexcmd{set interface ip6 table GigabitEthernet2/0/0 2}
 792  ?*/
 793 /* *INDENT-OFF* */
 794 VLIB_CLI_COMMAND (set_interface_ip6_table_command, static) =
 795 {
 796   .path = "set interface ip6 table",
 797   .function = ip6_table_bind_cmd,
 798   .short_help = "set interface ip6 table <interface> <table-id>"
 799 };
 800 /* *INDENT-ON* */
 801
 802 clib_error_t *
 803 vnet_ip_mroute_cmd (vlib_main_t * vm,
 804                     unformat_input_t * main_input, vlib_cli_command_t * cmd)
 805 {
 806   unformat_input_t _line_input, *line_input = &_line_input;
 807   clib_error_t *error = NULL;
 808   fib_route_path_t rpath;
 809   u32 table_id, is_del;
 810   vnet_main_t *vnm;
 811   mfib_prefix_t pfx;
 812   u32 fib_index;
 813   mfib_itf_flags_t iflags = 0;
 814   mfib_entry_flags_t eflags = 0;
 815   u32 gcount, scount, ss, gg, incr;
 816   f64 timet[2];
 817
 818   gcount = scount = 1;
 819   vnm = vnet_get_main ();
 820   is_del = 0;
 821   table_id = 0;
 822   memset (&pfx, 0, sizeof (pfx));
 823   memset (&rpath, 0, sizeof (rpath));
 824   rpath.frp_sw_if_index = ~0;
 825
 826   /* Get a line of input. */
 827   if (!unformat_user (main_input, unformat_line_input, line_input))
 828     return 0;
 829
 830   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 831     {
 832       if (unformat (line_input, "table %d", &table_id))
 833         ;
 834       else if (unformat (line_input, "del"))
 835         is_del = 1;
 836       else if (unformat (line_input, "add"))
 837         is_del = 0;
 838       else if (unformat (line_input, "scount %d", &scount))
 839         ;
 840       else if (unformat (line_input, "gcount %d", &gcount))
 841         ;
 842       else if (unformat (line_input, "%U %U",
 843                          unformat_ip4_address,
 844                          &pfx.fp_src_addr.ip4,
 845                          unformat_ip4_address, &pfx.fp_grp_addr.ip4))
 846         {
 847           pfx.fp_proto = FIB_PROTOCOL_IP4;
 848           pfx.fp_len = 64;
 849         }
 850       else if (unformat (line_input, "%U %U",
 851                          unformat_ip6_address,
 852                          &pfx.fp_src_addr.ip6,
 853                          unformat_ip6_address, &pfx.fp_grp_addr.ip6))
 854         {
 855           pfx.fp_proto = FIB_PROTOCOL_IP6;
 856           pfx.fp_len = 256;
 857         }
 858       else if (unformat (line_input, "%U/%d",
 859                          unformat_ip4_address,
 860                          &pfx.fp_grp_addr.ip4, &pfx.fp_len))
 861         {
 862           memset (&pfx.fp_src_addr.ip4, 0, sizeof (pfx.fp_src_addr.ip4));
 863           pfx.fp_proto = FIB_PROTOCOL_IP4;
 864         }
 865       else if (unformat (line_input, "%U/%d",
 866                          unformat_ip6_address,
 867                          &pfx.fp_grp_addr.ip6, &pfx.fp_len))
 868         {
 869           memset (&pfx.fp_src_addr.ip6, 0, sizeof (pfx.fp_src_addr.ip6));
 870           pfx.fp_proto = FIB_PROTOCOL_IP6;
 871         }
 872       else if (unformat (line_input, "%U",
 873                          unformat_ip4_address, &pfx.fp_grp_addr.ip4))
 874         {
 875           memset (&pfx.fp_src_addr.ip4, 0, sizeof (pfx.fp_src_addr.ip4));
 876           pfx.fp_proto = FIB_PROTOCOL_IP4;
 877           pfx.fp_len = 32;
 878         }
 879       else if (unformat (line_input, "%U",
 880                          unformat_ip6_address, &pfx.fp_grp_addr.ip6))
 881         {
 882           memset (&pfx.fp_src_addr.ip6, 0, sizeof (pfx.fp_src_addr.ip6));
 883           pfx.fp_proto = FIB_PROTOCOL_IP6;
 884           pfx.fp_len = 128;
 885         }
 886       else if (unformat (line_input, "via %U %U",
 887                          unformat_ip4_address, &rpath.frp_addr.ip4,
 888                          unformat_vnet_sw_interface, vnm,
 889                          &rpath.frp_sw_if_index))
 890         {
 891           rpath.frp_weight = 1;
 892         }
 893       else if (unformat (line_input, "via %U %U",
 894                          unformat_ip6_address, &rpath.frp_addr.ip6,
 895                          unformat_vnet_sw_interface, vnm,
 896                          &rpath.frp_sw_if_index))
 897         {
 898           rpath.frp_weight = 1;
 899         }
 900       else if (unformat (line_input, "via %U",
 901                          unformat_vnet_sw_interface, vnm,
 902                          &rpath.frp_sw_if_index))
 903         {
 904           memset (&rpath.frp_addr, 0, sizeof (rpath.frp_addr));
 905           rpath.frp_weight = 1;
 906         }
 907       else if (unformat (line_input, "via local"))
 908         {
 909           memset (&rpath.frp_addr, 0, sizeof (rpath.frp_addr));
 910           rpath.frp_sw_if_index = ~0;
 911           rpath.frp_weight = 1;
 912           rpath.frp_flags |= FIB_ROUTE_PATH_LOCAL;
 913           /*
 914            * set the path proto appropriately for the prefix
 915            */
 916           rpath.frp_proto = fib_proto_to_dpo (pfx.fp_proto);
 917         }
 918       else if (unformat (line_input, "%U", unformat_mfib_itf_flags, &iflags))
 919         ;
 920       else if (unformat (line_input, "%U",
 921                          unformat_mfib_entry_flags, &eflags))
 922         ;
 923       else
 924         {
 925           error = unformat_parse_error (line_input);
 926           goto done;
 927         }
 928     }
 929
 930   if (~0 == table_id)
 931     {
 932       /*
 933        * if no table_id is passed we will manipulate the default
 934        */
 935       fib_index = 0;
 936     }
 937   else
 938     {
 939       fib_index = mfib_table_find (pfx.fp_proto, table_id);
 940
 941       if (~0 == fib_index)
 942         {
 943           error = clib_error_return (0, "Nonexistent table id %d", table_id);
 944           goto done;
 945         }
 946     }
 947
 948   timet[0] = vlib_time_now (vm);
 949
 950   if (FIB_PROTOCOL_IP4 == pfx.fp_proto)
 951     {
 952       incr = 1 << (32 - (pfx.fp_len % 32));
 953     }
 954   else
 955     {
 956       incr = 1 << (128 - (pfx.fp_len % 128));
 957     }
 958
 959   for (ss = 0; ss < scount; ss++)
 960     {
 961       for (gg = 0; gg < gcount; gg++)
 962         {
 963           if (is_del && 0 == rpath.frp_weight)
 964             {
 965               /* no path provided => route delete */
 966               mfib_table_entry_delete (fib_index, &pfx, MFIB_SOURCE_CLI);
 967             }
 968           else if (eflags)
 969             {
 970               mfib_table_entry_update (fib_index, &pfx, MFIB_SOURCE_CLI,
 971                                        MFIB_RPF_ID_NONE, eflags);
 972             }
 973           else
 974             {
 975               if (is_del)
 976                 mfib_table_entry_path_remove (fib_index,
 977                                               &pfx, MFIB_SOURCE_CLI, &rpath);
 978               else
 979                 mfib_table_entry_path_update (fib_index,
 980                                               &pfx, MFIB_SOURCE_CLI, &rpath,
 981                                               iflags);
 982             }
 983
 984           if (FIB_PROTOCOL_IP4 == pfx.fp_proto)
 985             {
 986               pfx.fp_grp_addr.ip4.as_u32 =
 987                 clib_host_to_net_u32 (incr +
 988                                       clib_net_to_host_u32 (pfx.
 989                                                             fp_grp_addr.ip4.
 990                                                             as_u32));
 991             }
 992           else
 993             {
 994               int bucket = (incr < 64 ? 0 : 1);
 995               pfx.fp_grp_addr.ip6.as_u64[bucket] =
 996                 clib_host_to_net_u64 (incr +
 997                                       clib_net_to_host_u64 (pfx.
 998                                                             fp_grp_addr.ip6.as_u64
 999                                                             [bucket]));
1000
1001             }
1002         }
1003       if (FIB_PROTOCOL_IP4 == pfx.fp_proto)
1004         {
1005           pfx.fp_src_addr.ip4.as_u32 =
1006             clib_host_to_net_u32 (1 +
1007                                   clib_net_to_host_u32 (pfx.fp_src_addr.
1008                                                         ip4.as_u32));
1009         }
1010       else
1011         {
1012           pfx.fp_src_addr.ip6.as_u64[1] =
1013             clib_host_to_net_u64 (1 +
1014                                   clib_net_to_host_u64 (pfx.fp_src_addr.
1015                                                         ip6.as_u64[1]));
1016         }
1017     }
1018
1019   timet[1] = vlib_time_now (vm);
1020
1021   if (scount > 1 || gcount > 1)
1022     vlib_cli_output (vm, "%.6e routes/sec",
1023                      (scount * gcount) / (timet[1] - timet[0]));
1024
1025 done:
1026   unformat_free (line_input);
1027
1028   return error;
1029 }
1030
1031 /*?
1032  * This command is used to add or delete IPv4 or IPv6  multicastroutes. All
1033  * IP Addresses ('<em><dst-ip-addr>/<width></em>',
1034  * '<em><next-hop-ip-addr></em>' and '<em><adj-hop-ip-addr></em>')
1035  * can be IPv4 or IPv6, but all must be of the same form in a single
1036  * command. To display the current set of routes, use the commands
1037  * '<em>show ip mfib</em>' and '<em>show ip6 mfib</em>'.
1038  * The full set of support flags for interfaces and route is shown via;
1039  * '<em>show mfib route flags</em>' and '<em>show mfib itf flags</em>'
1040  * respectively.
1041  * @cliexpar
1042  * Example of how to add a forwarding interface to a route (and create the
1043  * route if it does not exist)
1044  * @cliexcmd{ip mroute add 232.1.1.1 via GigabitEthernet2/0/0 Forward}
1045  * Example of how to add an accepting interface to a route (and create the
1046  * route if it does not exist)
1047  * @cliexcmd{ip mroute add 232.1.1.1 via GigabitEthernet2/0/1 Accept}
1048  * Example of changing the route's flags to send signals via the API
1049  * @cliexcmd{ip mroute add 232.1.1.1 Signal}
1050
1051  ?*/
1052 /* *INDENT-OFF* */
1053 VLIB_CLI_COMMAND (ip_mroute_command, static) =
1054 {
1055   .path = "ip mroute",
1056   .short_help = "ip mroute [add|del] <dst-ip-addr>/<width> [table <table-id>] [via <next-hop-ip-addr> [<interface>],",
1057   .function = vnet_ip_mroute_cmd,
1058   .is_mp_safe = 1,
1059 };
1060 /* *INDENT-ON* */
1061
1062 /*
1063  * The next two routines address a longstanding script hemorrhoid.
1064  * Probing a v4 or v6 neighbor needs to appear to be synchronous,
1065  * or dependent route-adds will simply fail.
1066  */
1067 static clib_error_t *
1068 ip6_probe_neighbor_wait (vlib_main_t * vm, ip6_address_t * a, u32 sw_if_index,
1069                          int retry_count)
1070 {
1071   vnet_main_t *vnm = vnet_get_main ();
1072   clib_error_t *e;
1073   int i;
1074   int resolved = 0;
1075   uword event_type;
1076   uword *event_data = 0;
1077
1078   ASSERT (vlib_in_process_context (vm));
1079
1080   if (retry_count > 0)
1081     vnet_register_ip6_neighbor_resolution_event
1082       (vnm, a, vlib_get_current_process (vm)->node_runtime.node_index,
1083        1 /* event */ , 0 /* data */ );
1084
1085   for (i = 0; i < retry_count; i++)
1086     {
1087       /* The interface may be down, etc. */
1088       e = ip6_probe_neighbor (vm, a, sw_if_index, 0);
1089
1090       if (e)
1091         return e;
1092
1093       vlib_process_wait_for_event_or_clock (vm, 1.0);
1094       event_type = vlib_process_get_events (vm, &event_data);
1095       switch (event_type)
1096         {
1097         case 1:         /* resolved... */
1098           vlib_cli_output (vm, "Resolved %U", format_ip6_address, a);
1099           resolved = 1;
1100           goto done;
1101
1102         case ~0:                /* timeout */
1103           break;
1104
1105         default:
1106           clib_warning ("unknown event_type %d", event_type);
1107         }
1108       vec_reset_length (event_data);
1109     }
1110
1111 done:
1112
1113   if (!resolved)
1114     return clib_error_return (0, "Resolution failed for %U",
1115                               format_ip6_address, a);
1116   return 0;
1117 }
1118
1119 static clib_error_t *
1120 ip4_probe_neighbor_wait (vlib_main_t * vm, ip4_address_t * a, u32 sw_if_index,
1121                          int retry_count)
1122 {
1123   vnet_main_t *vnm = vnet_get_main ();
1124   clib_error_t *e;
1125   int i;
1126   int resolved = 0;
1127   uword event_type;
1128   uword *event_data = 0;
1129
1130   ASSERT (vlib_in_process_context (vm));
1131
1132   if (retry_count > 0)
1133     vnet_register_ip4_arp_resolution_event
1134       (vnm, a, vlib_get_current_process (vm)->node_runtime.node_index,
1135        1 /* event */ , 0 /* data */ );
1136
1137   for (i = 0; i < retry_count; i++)
1138     {
1139       /* The interface may be down, etc. */
1140       e = ip4_probe_neighbor (vm, a, sw_if_index, 0);
1141
1142       if (e)
1143         return e;
1144
1145       vlib_process_wait_for_event_or_clock (vm, 1.0);
1146       event_type = vlib_process_get_events (vm, &event_data);
1147       switch (event_type)
1148         {
1149         case 1:         /* resolved... */
1150           vlib_cli_output (vm, "Resolved %U", format_ip4_address, a);
1151           resolved = 1;
1152           goto done;
1153
1154         case ~0:                /* timeout */
1155           break;
1156
1157         default:
1158           clib_warning ("unknown event_type %d", event_type);
1159         }
1160       vec_reset_length (event_data);
1161     }
1162
1163 done:
1164
1165   vec_reset_length (event_data);
1166
1167   if (!resolved)
1168     return clib_error_return (0, "Resolution failed for %U",
1169                               format_ip4_address, a);
1170   return 0;
1171 }
1172
1173 static clib_error_t *
1174 probe_neighbor_address (vlib_main_t * vm,
1175                         unformat_input_t * input, vlib_cli_command_t * cmd)
1176 {
1177   vnet_main_t *vnm = vnet_get_main ();
1178   unformat_input_t _line_input, *line_input = &_line_input;
1179   ip4_address_t a4;
1180   ip6_address_t a6;
1181   clib_error_t *error = 0;
1182   u32 sw_if_index = ~0;
1183   int retry_count = 3;
1184   int is_ip4 = 1;
1185   int address_set = 0;
1186
1187   /* Get a line of input. */
1188   if (!unformat_user (input, unformat_line_input, line_input))
1189     return 0;
1190
1191   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1192     {
1193       if (unformat_user (line_input, unformat_vnet_sw_interface, vnm,
1194                          &sw_if_index))
1195         ;
1196       else if (unformat (line_input, "retry %d", &retry_count))
1197         ;
1198
1199       else if (unformat (line_input, "%U", unformat_ip4_address, &a4))
1200         address_set++;
1201       else if (unformat (line_input, "%U", unformat_ip6_address, &a6))
1202         {
1203           address_set++;
1204           is_ip4 = 0;
1205         }
1206       else
1207         {
1208           error = clib_error_return (0, "unknown input '%U'",
1209                                      format_unformat_error, line_input);
1210           goto done;
1211         }
1212     }
1213
1214   if (sw_if_index == ~0)
1215     {
1216       error = clib_error_return (0, "Interface required, not set.");
1217       goto done;
1218     }
1219   if (address_set == 0)
1220     {
1221       error = clib_error_return (0, "ip address required, not set.");
1222       goto done;
1223     }
1224   if (address_set > 1)
1225     {
1226       error = clib_error_return (0, "Multiple ip addresses not supported.");
1227       goto done;
1228     }
1229
1230   if (is_ip4)
1231     error = ip4_probe_neighbor_wait (vm, &a4, sw_if_index, retry_count);
1232   else
1233     error = ip6_probe_neighbor_wait (vm, &a6, sw_if_index, retry_count);
1234
1235 done:
1236   unformat_free (line_input);
1237
1238   return error;
1239 }
1240
1241 /*?
1242  * The '<em>ip probe-neighbor</em>' command ARPs for IPv4 addresses or
1243  * attempts IPv6 neighbor discovery depending on the supplied IP address
1244  * format.
1245  *
1246  * @note This command will not immediately affect the indicated FIB; it
1247  * is not suitable for use in establishing a FIB entry prior to adding
1248  * recursive FIB entries. As in: don't use it in a script to probe a
1249  * gateway prior to adding a default route. It won't work. Instead,
1250  * configure a static ARP cache entry [see '<em>set ip arp</em>'], or
1251  * a static IPv6 neighbor [see '<em>set ip6 neighbor</em>'].
1252  *
1253  * @cliexpar
1254  * Example of probe for an IPv4 address:
1255  * @cliexcmd{ip probe-neighbor GigabitEthernet2/0/0 172.16.1.2}
1256 ?*/
1257 /* *INDENT-OFF* */
1258 VLIB_CLI_COMMAND (ip_probe_neighbor_command, static) = {
1259   .path = "ip probe-neighbor",
1260   .function = probe_neighbor_address,
1261   .short_help = "ip probe-neighbor <interface> <ip4-addr> | <ip6-addr> [retry nn]",
1262   .is_mp_safe = 1,
1263 };
1264 /* *INDENT-ON* */
1265
1266 clib_error_t *
1267 vnet_ip_container_proxy_add_del (vnet_ip_container_proxy_args_t * args)
1268 {
1269   u32 fib_index;
1270
1271   if (!vnet_sw_interface_is_api_valid (vnet_get_main (), args->sw_if_index))
1272     return clib_error_return_code (0, VNET_API_ERROR_INVALID_INTERFACE, 0,
1273                                    "invalid sw_if_index");
1274
1275   fib_index = fib_table_get_table_id_for_sw_if_index (args->prefix.fp_proto,
1276                                                       args->sw_if_index);
1277   if (args->is_add)
1278     {
1279       dpo_id_t proxy_dpo = DPO_INVALID;
1280       l3_proxy_dpo_add_or_lock (fib_proto_to_dpo (args->prefix.fp_proto),
1281                                 args->sw_if_index, &proxy_dpo);
1282       fib_table_entry_special_dpo_add (fib_index,
1283                                        &args->prefix,
1284                                        FIB_SOURCE_PROXY,
1285                                        FIB_ENTRY_FLAG_EXCLUSIVE, &proxy_dpo);
1286       dpo_reset (&proxy_dpo);
1287     }
1288   else
1289     {
1290       fib_table_entry_special_remove (fib_index, &args->prefix,
1291                                       FIB_SOURCE_PROXY);
1292     }
1293   return 0;
1294 }
1295
1296 u8
1297 ip_container_proxy_is_set (fib_prefix_t * pfx, u32 sw_if_index)
1298 {
1299   u32 fib_index;
1300   fib_node_index_t fei;
1301   const dpo_id_t *dpo;
1302   l3_proxy_dpo_t *l3p;
1303   load_balance_t *lb0;
1304
1305   fib_index = fib_table_get_table_id_for_sw_if_index (pfx->fp_proto,
1306                                                       sw_if_index);
1307   if (fib_index == ~0)
1308     return 0;
1309
1310   fei = fib_table_lookup_exact_match (fib_index, pfx);
1311   if (fei == FIB_NODE_INDEX_INVALID)
1312     return 0;
1313
1314   dpo = fib_entry_contribute_ip_forwarding (fei);
1315   lb0 = load_balance_get (dpo->dpoi_index);
1316   dpo = load_balance_get_bucket_i (lb0, 0);
1317   if (dpo->dpoi_type != DPO_L3_PROXY)
1318     return 0;
1319
1320   l3p = l3_proxy_dpo_get (dpo->dpoi_index);
1321   return (l3p->l3p_sw_if_index == sw_if_index);
1322 }
1323
1324 typedef struct ip_container_proxy_walk_ctx_t_
1325 {
1326   ip_container_proxy_cb_t cb;
1327   void *ctx;
1328 } ip_container_proxy_walk_ctx_t;
1329
1330 static fib_table_walk_rc_t
1331 ip_container_proxy_fib_table_walk (fib_node_index_t fei, void *arg)
1332 {
1333   ip_container_proxy_walk_ctx_t *ctx = arg;
1334   const fib_prefix_t *pfx;
1335   const dpo_id_t *dpo;
1336   load_balance_t *lb;
1337   l3_proxy_dpo_t *l3p;
1338
1339   pfx = fib_entry_get_prefix (fei);
1340   if (fib_entry_is_sourced (fei, FIB_SOURCE_PROXY))
1341     {
1342       dpo = fib_entry_contribute_ip_forwarding (fei);
1343       lb = load_balance_get (dpo->dpoi_index);
1344       dpo = load_balance_get_bucket_i (lb, 0);
1345       l3p = l3_proxy_dpo_get (dpo->dpoi_index);
1346       ctx->cb (pfx, l3p->l3p_sw_if_index, ctx->ctx);
1347     }
1348
1349   return FIB_TABLE_WALK_CONTINUE;
1350 }
1351
1352 void
1353 ip_container_proxy_walk (ip_container_proxy_cb_t cb, void *ctx)
1354 {
1355   fib_table_t *fib_table;
1356   ip_container_proxy_walk_ctx_t wctx = {
1357     .cb = cb,
1358     .ctx = ctx,
1359   };
1360
1361   /* *INDENT-OFF* */
1362   pool_foreach (fib_table, ip4_main.fibs,
1363   ({
1364     fib_table_walk(fib_table->ft_index,
1365                    FIB_PROTOCOL_IP4,
1366                    ip_container_proxy_fib_table_walk,
1367                    &wctx);
1368   }));
1369   pool_foreach (fib_table, ip6_main.fibs,
1370   ({
1371     fib_table_walk(fib_table->ft_index,
1372                    FIB_PROTOCOL_IP6,
1373                    ip_container_proxy_fib_table_walk,
1374                    &wctx);
1375   }));
1376   /* *INDENT-ON* */
1377 }
1378
1379 clib_error_t *
1380 ip_container_cmd (vlib_main_t * vm,
1381                   unformat_input_t * main_input, vlib_cli_command_t * cmd)
1382 {
1383   unformat_input_t _line_input, *line_input = &_line_input;
1384   fib_prefix_t pfx;
1385   u32 is_del, addr_set = 0;
1386   vnet_main_t *vnm;
1387   u32 sw_if_index;
1388
1389   vnm = vnet_get_main ();
1390   is_del = 0;
1391   sw_if_index = ~0;
1392   memset (&pfx, 0, sizeof (pfx));
1393
1394   /* Get a line of input. */
1395   if (!unformat_user (main_input, unformat_line_input, line_input))
1396     return 0;
1397
1398   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1399     {
1400       if (unformat (line_input, "%U", unformat_ip4_address, &pfx.fp_addr.ip4))
1401         {
1402           pfx.fp_proto = FIB_PROTOCOL_IP4;
1403           pfx.fp_len = 32;
1404           addr_set = 1;
1405         }
1406       else if (unformat (line_input, "%U",
1407                          unformat_ip6_address, &pfx.fp_addr.ip6))
1408         {
1409           pfx.fp_proto = FIB_PROTOCOL_IP6;
1410           pfx.fp_len = 128;
1411           addr_set = 1;
1412         }
1413       else if (unformat (line_input, "%U",
1414                          unformat_vnet_sw_interface, vnm, &sw_if_index))
1415         ;
1416       else if (unformat (line_input, "del"))
1417         is_del = 1;
1418       else
1419         {
1420           unformat_free (line_input);
1421           return (clib_error_return (0, "unknown input '%U'",
1422                                      format_unformat_error, line_input));
1423         }
1424     }
1425
1426   if (~0 == sw_if_index || !addr_set)
1427     {
1428       unformat_free (line_input);
1429       vlib_cli_output (vm, "interface and address must be set");
1430       return 0;
1431     }
1432
1433   vnet_ip_container_proxy_args_t args = {
1434     .prefix = pfx,
1435     .sw_if_index = sw_if_index,
1436     .is_add = !is_del,
1437   };
1438   vnet_ip_container_proxy_add_del (&args);
1439   unformat_free (line_input);
1440   return (NULL);
1441 }
1442
1443 /* *INDENT-OFF* */
1444 VLIB_CLI_COMMAND (ip_container_command_node, static) = {
1445   .path = "ip container",
1446   .function = ip_container_cmd,
1447   .short_help = "ip container <address> <interface>",
1448   .is_mp_safe = 1,
1449 };
1450 /* *INDENT-ON* */
1451
1452 clib_error_t *
1453 show_ip_container_cmd_fn (vlib_main_t * vm, unformat_input_t * main_input,
1454                           vlib_cli_command_t * cmd)
1455 {
1456   unformat_input_t _line_input, *line_input = &_line_input;
1457   vnet_main_t *vnm = vnet_get_main ();
1458   fib_prefix_t pfx;
1459   u32 sw_if_index = ~0;
1460   u8 has_proxy;
1461
1462   if (!unformat_user (main_input, unformat_line_input, line_input))
1463     return 0;
1464   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1465     {
1466       if (unformat (line_input, "%U", unformat_ip4_address, &pfx.fp_addr.ip4))
1467         {
1468           pfx.fp_proto = FIB_PROTOCOL_IP4;
1469           pfx.fp_len = 32;
1470         }
1471       else if (unformat (line_input, "%U",
1472                          unformat_ip6_address, &pfx.fp_addr.ip6))
1473         {
1474           pfx.fp_proto = FIB_PROTOCOL_IP6;
1475           pfx.fp_len = 128;
1476         }
1477       else if (unformat (line_input, "%U",
1478                          unformat_vnet_sw_interface, vnm, &sw_if_index))
1479         ;
1480       else
1481         {
1482           unformat_free (line_input);
1483           return (clib_error_return (0, "unknown input '%U'",
1484                                      format_unformat_error, line_input));
1485         }
1486     }
1487
1488   if (~0 == sw_if_index)
1489     {
1490       unformat_free (line_input);
1491       vlib_cli_output (vm, "no interface");
1492       return (clib_error_return (0, "no interface"));
1493     }
1494
1495   has_proxy = ip_container_proxy_is_set (&pfx, sw_if_index);
1496   vlib_cli_output (vm, "ip container proxy is: %s", has_proxy ? "on" : "off");
1497
1498   unformat_free (line_input);
1499   return 0;
1500 }
1501
1502 /* *INDENT-OFF* */
1503 VLIB_CLI_COMMAND (show_ip_container_command, static) = {
1504   .path = "show ip container",
1505   .function = show_ip_container_cmd_fn,
1506   .short_help = "show ip container <address> <interface>",
1507   .is_mp_safe = 1,
1508 };
1509 /* *INDENT-ON* */
1510
1511 /*
1512  * fd.io coding-style-patch-verification: ON
1513  *
1514  * Local Variables:
1515  * eval: (c-set-style "gnu")
1516  * End:
1517  */