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). The FIB table must be created using "ip table add" already. 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). The FIB table must be created using "ip6 table add" already. 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 %U",
 903                          unformat_ip4_address, &rpath.frp_addr.ip4,
 904                          unformat_vnet_sw_interface, vnm,
 905                          &rpath.frp_sw_if_index))
 906         {
 907           rpath.frp_weight = 1;
 908         }
 909       else if (unformat (line_input, "via %U %U",
 910                          unformat_ip6_address, &rpath.frp_addr.ip6,
 911                          unformat_vnet_sw_interface, vnm,
 912                          &rpath.frp_sw_if_index))
 913         {
 914           rpath.frp_weight = 1;
 915         }
 916       else if (unformat (line_input, "via %U",
 917                          unformat_vnet_sw_interface, vnm,
 918                          &rpath.frp_sw_if_index))
 919         {
 920           memset (&rpath.frp_addr, 0, sizeof (rpath.frp_addr));
 921           rpath.frp_weight = 1;
 922         }
 923       else if (unformat (line_input, "via local"))
 924         {
 925           memset (&rpath.frp_addr, 0, sizeof (rpath.frp_addr));
 926           rpath.frp_sw_if_index = ~0;
 927           rpath.frp_weight = 1;
 928           rpath.frp_flags |= FIB_ROUTE_PATH_LOCAL;
 929           /*
 930            * set the path proto appropriately for the prefix
 931            */
 932           rpath.frp_proto = fib_proto_to_dpo (pfx.fp_proto);
 933         }
 934       else if (unformat (line_input, "%U", unformat_mfib_itf_flags, &iflags))
 935         ;
 936       else if (unformat (line_input, "%U",
 937                          unformat_mfib_entry_flags, &eflags))
 938         ;
 939       else
 940         {
 941           error = unformat_parse_error (line_input);
 942           goto done;
 943         }
 944     }
 945
 946   if (~0 == table_id)
 947     {
 948       /*
 949        * if no table_id is passed we will manipulate the default
 950        */
 951       fib_index = 0;
 952     }
 953   else
 954     {
 955       fib_index = mfib_table_find (pfx.fp_proto, table_id);
 956
 957       if (~0 == fib_index)
 958         {
 959           error = clib_error_return (0, "Nonexistent table id %d", table_id);
 960           goto done;
 961         }
 962     }
 963
 964   timet[0] = vlib_time_now (vm);
 965
 966   if (FIB_PROTOCOL_IP4 == pfx.fp_proto)
 967     {
 968       incr = 1 << (32 - (pfx.fp_len % 32));
 969     }
 970   else
 971     {
 972       incr = 1 << (128 - (pfx.fp_len % 128));
 973     }
 974
 975   for (ss = 0; ss < scount; ss++)
 976     {
 977       for (gg = 0; gg < gcount; gg++)
 978         {
 979           if (is_del && 0 == rpath.frp_weight)
 980             {
 981               /* no path provided => route delete */
 982               mfib_table_entry_delete (fib_index, &pfx, MFIB_SOURCE_CLI);
 983             }
 984           else if (eflags)
 985             {
 986               mfib_table_entry_update (fib_index, &pfx, MFIB_SOURCE_CLI,
 987                                        MFIB_RPF_ID_NONE, eflags);
 988             }
 989           else
 990             {
 991               if (is_del)
 992                 mfib_table_entry_path_remove (fib_index,
 993                                               &pfx, MFIB_SOURCE_CLI, &rpath);
 994               else
 995                 mfib_table_entry_path_update (fib_index,
 996                                               &pfx, MFIB_SOURCE_CLI, &rpath,
 997                                               iflags);
 998             }
 999
1000           if (FIB_PROTOCOL_IP4 == pfx.fp_proto)
1001             {
1002               pfx.fp_grp_addr.ip4.as_u32 =
1003                 clib_host_to_net_u32 (incr +
1004                                       clib_net_to_host_u32 (pfx.
1005                                                             fp_grp_addr.ip4.
1006                                                             as_u32));
1007             }
1008           else
1009             {
1010               int bucket = (incr < 64 ? 0 : 1);
1011               pfx.fp_grp_addr.ip6.as_u64[bucket] =
1012                 clib_host_to_net_u64 (incr +
1013                                       clib_net_to_host_u64 (pfx.
1014                                                             fp_grp_addr.ip6.as_u64
1015                                                             [bucket]));
1016
1017             }
1018         }
1019       if (FIB_PROTOCOL_IP4 == pfx.fp_proto)
1020         {
1021           pfx.fp_src_addr.ip4.as_u32 =
1022             clib_host_to_net_u32 (1 +
1023                                   clib_net_to_host_u32 (pfx.fp_src_addr.
1024                                                         ip4.as_u32));
1025         }
1026       else
1027         {
1028           pfx.fp_src_addr.ip6.as_u64[1] =
1029             clib_host_to_net_u64 (1 +
1030                                   clib_net_to_host_u64 (pfx.fp_src_addr.
1031                                                         ip6.as_u64[1]));
1032         }
1033     }
1034
1035   timet[1] = vlib_time_now (vm);
1036
1037   if (scount > 1 || gcount > 1)
1038     vlib_cli_output (vm, "%.6e routes/sec",
1039                      (scount * gcount) / (timet[1] - timet[0]));
1040
1041 done:
1042   unformat_free (line_input);
1043
1044   return error;
1045 }
1046
1047 /*?
1048  * This command is used to add or delete IPv4 or IPv6  multicastroutes. All
1049  * IP Addresses ('<em><dst-ip-addr>/<width></em>',
1050  * '<em><next-hop-ip-addr></em>' and '<em><adj-hop-ip-addr></em>')
1051  * can be IPv4 or IPv6, but all must be of the same form in a single
1052  * command. To display the current set of routes, use the commands
1053  * '<em>show ip mfib</em>' and '<em>show ip6 mfib</em>'.
1054  * The full set of support flags for interfaces and route is shown via;
1055  * '<em>show mfib route flags</em>' and '<em>show mfib itf flags</em>'
1056  * respectively.
1057  * @cliexpar
1058  * Example of how to add a forwarding interface to a route (and create the
1059  * route if it does not exist)
1060  * @cliexcmd{ip mroute add 232.1.1.1 via GigabitEthernet2/0/0 Forward}
1061  * Example of how to add an accepting interface to a route (and create the
1062  * route if it does not exist)
1063  * @cliexcmd{ip mroute add 232.1.1.1 via GigabitEthernet2/0/1 Accept}
1064  * Example of changing the route's flags to send signals via the API
1065  * @cliexcmd{ip mroute add 232.1.1.1 Signal}
1066
1067  ?*/
1068 /* *INDENT-OFF* */
1069 VLIB_CLI_COMMAND (ip_mroute_command, static) =
1070 {
1071   .path = "ip mroute",
1072   .short_help = "ip mroute [add|del] <dst-ip-addr>/<width> [table <table-id>] [via <next-hop-ip-addr> [<interface>],",
1073   .function = vnet_ip_mroute_cmd,
1074   .is_mp_safe = 1,
1075 };
1076 /* *INDENT-ON* */
1077
1078 /*
1079  * The next two routines address a longstanding script hemorrhoid.
1080  * Probing a v4 or v6 neighbor needs to appear to be synchronous,
1081  * or dependent route-adds will simply fail.
1082  */
1083 static clib_error_t *
1084 ip6_probe_neighbor_wait (vlib_main_t * vm, ip6_address_t * a, u32 sw_if_index,
1085                          int retry_count)
1086 {
1087   vnet_main_t *vnm = vnet_get_main ();
1088   clib_error_t *e;
1089   int i;
1090   int resolved = 0;
1091   uword event_type;
1092   uword *event_data = 0;
1093
1094   ASSERT (vlib_in_process_context (vm));
1095
1096   if (retry_count > 0)
1097     vnet_register_ip6_neighbor_resolution_event
1098       (vnm, a, vlib_get_current_process (vm)->node_runtime.node_index,
1099        1 /* event */ , 0 /* data */ );
1100
1101   for (i = 0; i < retry_count; i++)
1102     {
1103       /* The interface may be down, etc. */
1104       e = ip6_probe_neighbor (vm, a, sw_if_index, 0);
1105
1106       if (e)
1107         return e;
1108
1109       vlib_process_wait_for_event_or_clock (vm, 1.0);
1110       event_type = vlib_process_get_events (vm, &event_data);
1111       switch (event_type)
1112         {
1113         case 1:         /* resolved... */
1114           vlib_cli_output (vm, "Resolved %U", format_ip6_address, a);
1115           resolved = 1;
1116           goto done;
1117
1118         case ~0:                /* timeout */
1119           break;
1120
1121         default:
1122           clib_warning ("unknown event_type %d", event_type);
1123         }
1124       vec_reset_length (event_data);
1125     }
1126
1127 done:
1128
1129   if (!resolved)
1130     return clib_error_return (0, "Resolution failed for %U",
1131                               format_ip6_address, a);
1132   return 0;
1133 }
1134
1135 static clib_error_t *
1136 ip4_probe_neighbor_wait (vlib_main_t * vm, ip4_address_t * a, u32 sw_if_index,
1137                          int retry_count)
1138 {
1139   vnet_main_t *vnm = vnet_get_main ();
1140   clib_error_t *e;
1141   int i;
1142   int resolved = 0;
1143   uword event_type;
1144   uword *event_data = 0;
1145
1146   ASSERT (vlib_in_process_context (vm));
1147
1148   if (retry_count > 0)
1149     vnet_register_ip4_arp_resolution_event
1150       (vnm, a, vlib_get_current_process (vm)->node_runtime.node_index,
1151        1 /* event */ , 0 /* data */ );
1152
1153   for (i = 0; i < retry_count; i++)
1154     {
1155       /* The interface may be down, etc. */
1156       e = ip4_probe_neighbor (vm, a, sw_if_index, 0);
1157
1158       if (e)
1159         return e;
1160
1161       vlib_process_wait_for_event_or_clock (vm, 1.0);
1162       event_type = vlib_process_get_events (vm, &event_data);
1163       switch (event_type)
1164         {
1165         case 1:         /* resolved... */
1166           vlib_cli_output (vm, "Resolved %U", format_ip4_address, a);
1167           resolved = 1;
1168           goto done;
1169
1170         case ~0:                /* timeout */
1171           break;
1172
1173         default:
1174           clib_warning ("unknown event_type %d", event_type);
1175         }
1176       vec_reset_length (event_data);
1177     }
1178
1179 done:
1180
1181   vec_reset_length (event_data);
1182
1183   if (!resolved)
1184     return clib_error_return (0, "Resolution failed for %U",
1185                               format_ip4_address, a);
1186   return 0;
1187 }
1188
1189 static clib_error_t *
1190 probe_neighbor_address (vlib_main_t * vm,
1191                         unformat_input_t * input, vlib_cli_command_t * cmd)
1192 {
1193   vnet_main_t *vnm = vnet_get_main ();
1194   unformat_input_t _line_input, *line_input = &_line_input;
1195   ip4_address_t a4;
1196   ip6_address_t a6;
1197   clib_error_t *error = 0;
1198   u32 sw_if_index = ~0;
1199   int retry_count = 3;
1200   int is_ip4 = 1;
1201   int address_set = 0;
1202
1203   /* Get a line of input. */
1204   if (!unformat_user (input, unformat_line_input, line_input))
1205     return 0;
1206
1207   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1208     {
1209       if (unformat_user (line_input, unformat_vnet_sw_interface, vnm,
1210                          &sw_if_index))
1211         ;
1212       else if (unformat (line_input, "retry %d", &retry_count))
1213         ;
1214
1215       else if (unformat (line_input, "%U", unformat_ip4_address, &a4))
1216         address_set++;
1217       else if (unformat (line_input, "%U", unformat_ip6_address, &a6))
1218         {
1219           address_set++;
1220           is_ip4 = 0;
1221         }
1222       else
1223         {
1224           error = clib_error_return (0, "unknown input '%U'",
1225                                      format_unformat_error, line_input);
1226           goto done;
1227         }
1228     }
1229
1230   if (sw_if_index == ~0)
1231     {
1232       error = clib_error_return (0, "Interface required, not set.");
1233       goto done;
1234     }
1235   if (address_set == 0)
1236     {
1237       error = clib_error_return (0, "ip address required, not set.");
1238       goto done;
1239     }
1240   if (address_set > 1)
1241     {
1242       error = clib_error_return (0, "Multiple ip addresses not supported.");
1243       goto done;
1244     }
1245
1246   if (is_ip4)
1247     error = ip4_probe_neighbor_wait (vm, &a4, sw_if_index, retry_count);
1248   else
1249     error = ip6_probe_neighbor_wait (vm, &a6, sw_if_index, retry_count);
1250
1251 done:
1252   unformat_free (line_input);
1253
1254   return error;
1255 }
1256
1257 /*?
1258  * The '<em>ip probe-neighbor</em>' command ARPs for IPv4 addresses or
1259  * attempts IPv6 neighbor discovery depending on the supplied IP address
1260  * format.
1261  *
1262  * @note This command will not immediately affect the indicated FIB; it
1263  * is not suitable for use in establishing a FIB entry prior to adding
1264  * recursive FIB entries. As in: don't use it in a script to probe a
1265  * gateway prior to adding a default route. It won't work. Instead,
1266  * configure a static ARP cache entry [see '<em>set ip arp</em>'], or
1267  * a static IPv6 neighbor [see '<em>set ip6 neighbor</em>'].
1268  *
1269  * @cliexpar
1270  * Example of probe for an IPv4 address:
1271  * @cliexcmd{ip probe-neighbor GigabitEthernet2/0/0 172.16.1.2}
1272 ?*/
1273 /* *INDENT-OFF* */
1274 VLIB_CLI_COMMAND (ip_probe_neighbor_command, static) = {
1275   .path = "ip probe-neighbor",
1276   .function = probe_neighbor_address,
1277   .short_help = "ip probe-neighbor <interface> <ip4-addr> | <ip6-addr> [retry nn]",
1278   .is_mp_safe = 1,
1279 };
1280 /* *INDENT-ON* */
1281
1282 clib_error_t *
1283 vnet_ip_container_proxy_add_del (vnet_ip_container_proxy_args_t * args)
1284 {
1285   u32 fib_index;
1286
1287   if (!vnet_sw_interface_is_api_valid (vnet_get_main (), args->sw_if_index))
1288     return clib_error_return_code (0, VNET_API_ERROR_INVALID_INTERFACE, 0,
1289                                    "invalid sw_if_index");
1290
1291   fib_index = fib_table_get_table_id_for_sw_if_index (args->prefix.fp_proto,
1292                                                       args->sw_if_index);
1293   if (args->is_add)
1294     {
1295       dpo_id_t proxy_dpo = DPO_INVALID;
1296       l3_proxy_dpo_add_or_lock (fib_proto_to_dpo (args->prefix.fp_proto),
1297                                 args->sw_if_index, &proxy_dpo);
1298       fib_table_entry_special_dpo_add (fib_index,
1299                                        &args->prefix,
1300                                        FIB_SOURCE_PROXY,
1301                                        FIB_ENTRY_FLAG_EXCLUSIVE, &proxy_dpo);
1302       dpo_reset (&proxy_dpo);
1303     }
1304   else
1305     {
1306       fib_table_entry_special_remove (fib_index, &args->prefix,
1307                                       FIB_SOURCE_PROXY);
1308     }
1309   return 0;
1310 }
1311
1312 u8
1313 ip_container_proxy_is_set (fib_prefix_t * pfx, u32 sw_if_index)
1314 {
1315   u32 fib_index;
1316   fib_node_index_t fei;
1317   const dpo_id_t *dpo;
1318   l3_proxy_dpo_t *l3p;
1319   load_balance_t *lb0;
1320
1321   fib_index = fib_table_get_table_id_for_sw_if_index (pfx->fp_proto,
1322                                                       sw_if_index);
1323   if (fib_index == ~0)
1324     return 0;
1325
1326   fei = fib_table_lookup_exact_match (fib_index, pfx);
1327   if (fei == FIB_NODE_INDEX_INVALID)
1328     return 0;
1329
1330   dpo = fib_entry_contribute_ip_forwarding (fei);
1331   lb0 = load_balance_get (dpo->dpoi_index);
1332   dpo = load_balance_get_bucket_i (lb0, 0);
1333   if (dpo->dpoi_type != DPO_L3_PROXY)
1334     return 0;
1335
1336   l3p = l3_proxy_dpo_get (dpo->dpoi_index);
1337   return (l3p->l3p_sw_if_index == sw_if_index);
1338 }
1339
1340 clib_error_t *
1341 ip_container_cmd (vlib_main_t * vm,
1342                   unformat_input_t * main_input, vlib_cli_command_t * cmd)
1343 {
1344   unformat_input_t _line_input, *line_input = &_line_input;
1345   fib_prefix_t pfx;
1346   u32 is_del, addr_set = 0;
1347   vnet_main_t *vnm;
1348   u32 sw_if_index;
1349
1350   vnm = vnet_get_main ();
1351   is_del = 0;
1352   sw_if_index = ~0;
1353   memset (&pfx, 0, sizeof (pfx));
1354
1355   /* Get a line of input. */
1356   if (!unformat_user (main_input, unformat_line_input, line_input))
1357     return 0;
1358
1359   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1360     {
1361       if (unformat (line_input, "%U", unformat_ip4_address, &pfx.fp_addr.ip4))
1362         {
1363           pfx.fp_proto = FIB_PROTOCOL_IP4;
1364           pfx.fp_len = 32;
1365           addr_set = 1;
1366         }
1367       else if (unformat (line_input, "%U",
1368                          unformat_ip6_address, &pfx.fp_addr.ip6))
1369         {
1370           pfx.fp_proto = FIB_PROTOCOL_IP6;
1371           pfx.fp_len = 128;
1372           addr_set = 1;
1373         }
1374       else if (unformat (line_input, "%U",
1375                          unformat_vnet_sw_interface, vnm, &sw_if_index))
1376         ;
1377       else if (unformat (line_input, "del"))
1378         is_del = 1;
1379       else
1380         {
1381           unformat_free (line_input);
1382           return (clib_error_return (0, "unknown input '%U'",
1383                                      format_unformat_error, line_input));
1384         }
1385     }
1386
1387   if (~0 == sw_if_index || !addr_set)
1388     {
1389       unformat_free (line_input);
1390       vlib_cli_output (vm, "interface and address must be set");
1391       return 0;
1392     }
1393
1394   vnet_ip_container_proxy_args_t args = {
1395     .prefix = pfx,
1396     .sw_if_index = sw_if_index,
1397     .is_add = !is_del,
1398   };
1399   vnet_ip_container_proxy_add_del (&args);
1400   unformat_free (line_input);
1401   return (NULL);
1402 }
1403
1404 /* *INDENT-OFF* */
1405 VLIB_CLI_COMMAND (ip_container_command_node, static) = {
1406   .path = "ip container",
1407   .function = ip_container_cmd,
1408   .short_help = "ip container <address> <interface>",
1409   .is_mp_safe = 1,
1410 };
1411 /* *INDENT-ON* */
1412
1413 clib_error_t *
1414 show_ip_container_cmd_fn (vlib_main_t * vm, unformat_input_t * main_input,
1415                           vlib_cli_command_t * cmd)
1416 {
1417   unformat_input_t _line_input, *line_input = &_line_input;
1418   vnet_main_t *vnm = vnet_get_main ();
1419   fib_prefix_t pfx;
1420   u32 sw_if_index = ~0;
1421   u8 has_proxy;
1422
1423   if (!unformat_user (main_input, unformat_line_input, line_input))
1424     return 0;
1425   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1426     {
1427       if (unformat (line_input, "%U", unformat_ip4_address, &pfx.fp_addr.ip4))
1428         {
1429           pfx.fp_proto = FIB_PROTOCOL_IP4;
1430           pfx.fp_len = 32;
1431         }
1432       else if (unformat (line_input, "%U",
1433                          unformat_ip6_address, &pfx.fp_addr.ip6))
1434         {
1435           pfx.fp_proto = FIB_PROTOCOL_IP6;
1436           pfx.fp_len = 128;
1437         }
1438       else if (unformat (line_input, "%U",
1439                          unformat_vnet_sw_interface, vnm, &sw_if_index))
1440         ;
1441       else
1442         {
1443           unformat_free (line_input);
1444           return (clib_error_return (0, "unknown input '%U'",
1445                                      format_unformat_error, line_input));
1446         }
1447     }
1448
1449   if (~0 == sw_if_index)
1450     {
1451       unformat_free (line_input);
1452       vlib_cli_output (vm, "no interface");
1453       return (clib_error_return (0, "no interface"));
1454     }
1455
1456   has_proxy = ip_container_proxy_is_set (&pfx, sw_if_index);
1457   vlib_cli_output (vm, "ip container proxy is: %s", has_proxy ? "on" : "off");
1458
1459   unformat_free (line_input);
1460   return 0;
1461 }
1462
1463 /* *INDENT-OFF* */
1464 VLIB_CLI_COMMAND (show_ip_container_command, static) = {
1465   .path = "show ip container",
1466   .function = show_ip_container_cmd_fn,
1467   .short_help = "show ip container <address> <interface>",
1468   .is_mp_safe = 1,
1469 };
1470 /* *INDENT-ON* */
1471
1472 /*
1473  * fd.io coding-style-patch-verification: ON
1474  *
1475  * Local Variables:
1476  * eval: (c-set-style "gnu")
1477  * End:
1478  */