src/vnet/ip/ip6_link.c

   1 /*
   2  * Copyright (c) 2019 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 #include <vnet/ip/ip6_link.h>
  17 #include <vnet/ip/ip6_ll_table.h>
  18
  19 #include <vnet/ethernet/ethernet.h>
  20 #include <vnet/mfib/ip6_mfib.h>
  21 #include <vnet/adj/adj_mcast.h>
  22
  23 typedef struct ip6_link_delegate_t_
  24 {
  25   u32 ild_sw_if_index;
  26   ip6_link_delegate_id_t ild_type;
  27   index_t ild_index;
  28 } ip6_link_delegate_t;
  29
  30 const static ip6_link_delegate_t ip6_link_delegate_uninit = {
  31   .ild_sw_if_index = ~0,
  32 };
  33
  34 typedef struct ip6_link_t_
  35 {
  36   /** interface ip6 is enabled on */
  37   u32 il_sw_if_index;
  38
  39   /** link-local address - if unset that IP6 is disabled*/
  40   ip6_address_t il_ll_addr;
  41
  42   /** list of delegates */
  43   ip6_link_delegate_t *il_delegates;
  44
  45   /** multicast adjacency for this link */
  46   adj_index_t il_mcast_adj;
  47
  48   /** number of references to IP6 enabled on this link */
  49   u32 il_locks;
  50 } ip6_link_t;
  51
  52 #define FOREACH_IP6_LINK_DELEGATE(_ild, _il, body)      \
  53 {                                                       \
  54  if (NULL != _il) {                                     \
  55    vec_foreach (_ild, _il->il_delegates) {              \
  56      if (ip6_link_delegate_is_init(_ild))               \
  57        body;                                            \
  58    }                                                    \
  59  }                                                      \
  60 }
  61
  62 #define FOREACH_IP6_LINK_DELEGATE_ID(_id) \
  63   for (_id = 0; _id < il_delegate_id; _id++)
  64
  65 /** last used delegate ID */
  66 static ip6_link_delegate_id_t il_delegate_id;
  67
  68 /** VFT registered per-delegate type */
  69 static ip6_link_delegate_vft_t *il_delegate_vfts;
  70
  71 /** Per interface configs */
  72 static ip6_link_t *ip6_links;
  73
  74 /** Randomizer */
  75 static u64 il_randomizer;
  76
  77 /** Logging */
  78 static vlib_log_class_t ip6_link_logger;
  79
  80 #define IP6_LINK_DBG(...)                       \
  81     vlib_log_debug (ip6_link_logger, __VA_ARGS__);
  82
  83 #define IP6_LINK_INFO(...)                              \
  84     vlib_log_notice (ip6_link_logger, __VA_ARGS__);
  85
  86 static bool
  87 ip6_link_delegate_is_init (const ip6_link_delegate_t * ild)
  88 {
  89   return (~0 != ild->ild_sw_if_index);
  90 }
  91
  92 static bool
  93 ip6_link_is_enabled_i (const ip6_link_t * il)
  94 {
  95   return (!ip6_address_is_zero (&il->il_ll_addr));
  96 }
  97
  98 static void
  99 ip6_link_local_address_from_mac (ip6_address_t * ip, const u8 * mac)
 100 {
 101   ip->as_u64[0] = clib_host_to_net_u64 (0xFE80000000000000ULL);
 102   /* Invert the "u" bit */
 103   ip->as_u8[8] = mac[0] ^ (1 << 1);
 104   ip->as_u8[9] = mac[1];
 105   ip->as_u8[10] = mac[2];
 106   ip->as_u8[11] = 0xFF;
 107   ip->as_u8[12] = 0xFE;
 108   ip->as_u8[13] = mac[3];
 109   ip->as_u8[14] = mac[4];
 110   ip->as_u8[15] = mac[5];
 111 }
 112
 113 static void
 114 ip6_mac_address_from_link_local (u8 * mac, const ip6_address_t * ip)
 115 {
 116   /* Invert the previously inverted "u" bit */
 117   mac[0] = ip->as_u8[8] ^ (1 << 1);
 118   mac[1] = ip->as_u8[9];
 119   mac[2] = ip->as_u8[10];
 120   mac[3] = ip->as_u8[13];
 121   mac[4] = ip->as_u8[14];
 122   mac[5] = ip->as_u8[15];
 123 }
 124
 125 static ip6_link_t *
 126 ip6_link_get (u32 sw_if_index)
 127 {
 128   ip6_link_t *il;
 129
 130   if (sw_if_index >= vec_len (ip6_links))
 131     return (NULL);
 132
 133   il = &ip6_links[sw_if_index];
 134
 135   if (!ip6_link_is_enabled_i (il))
 136     return (NULL);
 137
 138   return (il);
 139 }
 140
 141 bool
 142 ip6_link_is_enabled (u32 sw_if_index)
 143 {
 144   return (NULL != ip6_link_get (sw_if_index));
 145 }
 146
 147
 148 int
 149 ip6_link_enable (u32 sw_if_index, const ip6_address_t * link_local_addr)
 150 {
 151   ip6_link_t *il;
 152   int rv;
 153
 154   il = ip6_link_get (sw_if_index);
 155
 156   if (NULL == il)
 157     {
 158       const vnet_sw_interface_t *sw, *sw_sup;
 159       const ethernet_interface_t *eth;
 160       vnet_main_t *vnm;
 161
 162       vnm = vnet_get_main ();
 163
 164       IP6_LINK_INFO ("enable: %U",
 165                      format_vnet_sw_if_index_name, vnm, sw_if_index);
 166
 167       sw_sup = vnet_get_sup_sw_interface (vnm, sw_if_index);
 168       if (sw_sup->type != VNET_SW_INTERFACE_TYPE_HARDWARE)
 169         {
 170           rv = VNET_API_ERROR_UNSUPPORTED;
 171           goto out;
 172         }
 173
 174       eth = ethernet_get_interface (&ethernet_main, sw_sup->hw_if_index);
 175
 176       if (NULL == eth)
 177         {
 178           rv = VNET_API_ERROR_UNSUPPORTED;
 179           goto out;
 180         }
 181
 182       vec_validate (ip6_links, sw_if_index);
 183
 184       il = &ip6_links[sw_if_index];
 185       il->il_locks = 0;
 186       il->il_sw_if_index = sw_if_index;
 187
 188       sw = vnet_get_sup_sw_interface (vnm, sw_if_index);
 189
 190       if (NULL != link_local_addr)
 191         ip6_address_copy (&il->il_ll_addr, link_local_addr);
 192       else if (sw->type == VNET_SW_INTERFACE_TYPE_SUB ||
 193                sw->type == VNET_SW_INTERFACE_TYPE_PIPE ||
 194                sw->type == VNET_SW_INTERFACE_TYPE_P2P)
 195         {
 196           il->il_ll_addr.as_u64[0] =
 197             clib_host_to_net_u64 (0xFE80000000000000ULL);
 198
 199           /* make up an interface id */
 200           il->il_ll_addr.as_u64[1] = random_u64 (&il_randomizer);
 201
 202           /* clear u bit */
 203           il->il_ll_addr.as_u8[8] &= 0xfd;
 204         }
 205       else
 206         {
 207           ip6_link_local_address_from_mac (&il->il_ll_addr,
 208                                            eth->address.mac.bytes);
 209         }
 210
 211       {
 212         ip6_ll_prefix_t ilp = {
 213           .ilp_addr = il->il_ll_addr,
 214           .ilp_sw_if_index = sw_if_index,
 215         };
 216
 217         ip6_ll_table_entry_update (&ilp, FIB_ROUTE_PATH_LOCAL);
 218       }
 219
 220       /* essentially "enables" ipv6 on this interface */
 221       ip6_mfib_interface_enable_disable (sw_if_index, 1);
 222       ip6_sw_interface_enable_disable (sw_if_index, 1);
 223
 224       il->il_mcast_adj = adj_mcast_add_or_lock (FIB_PROTOCOL_IP6,
 225                                                 VNET_LINK_IP6, sw_if_index);
 226
 227       /* inform all register clients */
 228       ip6_link_delegate_id_t id;
 229       FOREACH_IP6_LINK_DELEGATE_ID (id)
 230       {
 231         if (NULL != il_delegate_vfts[id].ildv_enable)
 232           il_delegate_vfts[id].ildv_enable (il->il_sw_if_index);
 233       }
 234
 235       rv = 0;
 236     }
 237   else
 238     {
 239       rv = VNET_API_ERROR_VALUE_EXIST;
 240     }
 241
 242   il->il_locks++;
 243
 244 out:
 245   return (rv);
 246 }
 247
 248 static void
 249 ip6_link_delegate_flush (ip6_link_t * il)
 250 {
 251   ip6_link_delegate_t *ild;
 252
 253   /* *INDENT-OFF* */
 254   FOREACH_IP6_LINK_DELEGATE (ild, il,
 255   ({
 256     il_delegate_vfts[ild->ild_type].ildv_disable(ild->ild_index);
 257   }));
 258   /* *INDENT-ON* */
 259
 260   vec_free (il->il_delegates);
 261   il->il_delegates = NULL;
 262 }
 263
 264 static void
 265 ip6_link_last_lock_gone (ip6_link_t * il)
 266 {
 267   ip6_ll_prefix_t ilp = {
 268     .ilp_addr = il->il_ll_addr,
 269     .ilp_sw_if_index = il->il_sw_if_index,
 270   };
 271
 272   IP6_LINK_INFO ("last-lock: %U",
 273                  format_vnet_sw_if_index_name,
 274                  vnet_get_main (), il->il_sw_if_index);
 275
 276   ip6_link_delegate_flush (il);
 277   ip6_ll_table_entry_delete (&ilp);
 278
 279   ip6_mfib_interface_enable_disable (il->il_sw_if_index, 0);
 280   ip6_sw_interface_enable_disable (il->il_sw_if_index, 0);
 281
 282   ip6_address_set_zero (&il->il_ll_addr);
 283   adj_unlock (il->il_mcast_adj);
 284   il->il_mcast_adj = ADJ_INDEX_INVALID;
 285 }
 286
 287 static void
 288 ip6_link_unlock (ip6_link_t * il)
 289 {
 290   if (NULL == il)
 291     return;
 292
 293   il->il_locks--;
 294
 295   if (0 == il->il_locks)
 296     ip6_link_last_lock_gone (il);
 297 }
 298
 299 int
 300 ip6_link_disable (u32 sw_if_index)
 301 {
 302   ip6_link_t *il;
 303
 304   il = ip6_link_get (sw_if_index);
 305
 306   if (NULL == il)
 307     return (VNET_API_ERROR_IP6_NOT_ENABLED);
 308
 309   IP6_LINK_INFO ("disable: %U",
 310                  format_vnet_sw_if_index_name, vnet_get_main (), sw_if_index);
 311
 312   ip6_link_unlock (il);
 313
 314   return (0);
 315 }
 316
 317 const ip6_address_t *
 318 ip6_get_link_local_address (u32 sw_if_index)
 319 {
 320   const ip6_link_t *il;
 321
 322   il = ip6_link_get (sw_if_index);
 323
 324   if (NULL == il)
 325     return (NULL);
 326
 327   return (&il->il_ll_addr);
 328 }
 329
 330 adj_index_t
 331 ip6_link_get_mcast_adj (u32 sw_if_index)
 332 {
 333   const ip6_link_t *il;
 334
 335   il = ip6_link_get (sw_if_index);
 336
 337   if (NULL == il)
 338     return (INDEX_INVALID);
 339
 340   return (il->il_mcast_adj);
 341 }
 342
 343 int
 344 ip6_link_set_local_address (u32 sw_if_index, const ip6_address_t * address)
 345 {
 346   ip6_link_delegate_t *ild;
 347   ip6_link_t *il;
 348
 349   il = ip6_link_get (sw_if_index);
 350
 351   if (NULL == il)
 352     return ip6_link_enable (sw_if_index, address);
 353
 354   ip6_ll_prefix_t ilp = {
 355     .ilp_addr = il->il_ll_addr,
 356     .ilp_sw_if_index = sw_if_index,
 357   };
 358
 359   IP6_LINK_INFO ("set-ll: %U -> %U",
 360                  format_vnet_sw_if_index_name, vnet_get_main (), sw_if_index,
 361                  format_ip6_address, address);
 362
 363   ip6_ll_table_entry_delete (&ilp);
 364   ip6_address_copy (&il->il_ll_addr, address);
 365   ip6_address_copy (&ilp.ilp_addr, address);
 366   ip6_ll_table_entry_update (&ilp, FIB_ROUTE_PATH_LOCAL);
 367
 368   /* *INDENT-OFF* */
 369   FOREACH_IP6_LINK_DELEGATE (ild, il,
 370   ({
 371     if (NULL != il_delegate_vfts[ild->ild_type].ildv_ll_change)
 372       il_delegate_vfts[ild->ild_type].ildv_ll_change(ild->ild_index,
 373                                                      &il->il_ll_addr);
 374   }));
 375   /* *INDENT-ON* */
 376
 377   return (0);
 378 }
 379
 380 ip6_link_delegate_id_t
 381 ip6_link_delegate_register (const ip6_link_delegate_vft_t * vft)
 382 {
 383   ip6_link_delegate_id_t rc = il_delegate_id++;
 384
 385   ASSERT (vft->ildv_disable);
 386
 387   vec_validate (il_delegate_vfts, rc);
 388
 389   il_delegate_vfts[rc] = *vft;
 390
 391   return (rc);
 392 }
 393
 394 index_t
 395 ip6_link_delegate_get (u32 sw_if_index, ip6_link_delegate_id_t id)
 396 {
 397   ip6_link_t *il;
 398
 399   il = ip6_link_get (sw_if_index);
 400
 401   if (NULL == il)
 402     return (INDEX_INVALID);
 403
 404   vec_validate_init_empty (il->il_delegates, id, ip6_link_delegate_uninit);
 405
 406   if (!ip6_link_delegate_is_init (&il->il_delegates[id]))
 407     return (INDEX_INVALID);
 408
 409   return (il->il_delegates[id].ild_index);
 410 }
 411
 412 bool
 413 ip6_link_delegate_update (u32 sw_if_index,
 414                           ip6_link_delegate_id_t id, index_t ii)
 415 {
 416   ip6_link_t *il;
 417
 418   il = ip6_link_get (sw_if_index);
 419
 420   if (NULL == il)
 421     return (false);
 422
 423   vec_validate_init_empty (il->il_delegates, id, ip6_link_delegate_uninit);
 424
 425   il->il_delegates[id].ild_sw_if_index = sw_if_index;
 426   il->il_delegates[id].ild_type = id;
 427   il->il_delegates[id].ild_index = ii;
 428
 429   return (true);
 430 }
 431
 432 void
 433 ip6_link_delegate_remove (u32 sw_if_index,
 434                           ip6_link_delegate_id_t id, index_t ii)
 435 {
 436   ip6_link_t *il;
 437
 438   il = ip6_link_get (sw_if_index);
 439
 440   if (NULL != il)
 441     {
 442       if (vec_len (il->il_delegates) > id)
 443         {
 444           clib_memcpy (&il->il_delegates[id],
 445                        &ip6_link_delegate_uninit,
 446                        sizeof (il->il_delegates[0]));
 447         }
 448     }
 449 }
 450
 451 static void
 452 ip6_link_add_del_address (ip6_main_t * im,
 453                           uword opaque,
 454                           u32 sw_if_index,
 455                           ip6_address_t * address,
 456                           u32 address_length,
 457                           u32 if_address_index, u32 is_delete)
 458 {
 459   const ip6_link_delegate_t *ild;
 460   ip6_link_t *il;
 461
 462   if (ip6_address_is_link_local_unicast (address))
 463     // only interested in global addresses here
 464     return;
 465
 466   IP6_LINK_INFO ("addr-%s: %U -> %U",
 467                  (is_delete ? "del" : "add"),
 468                  format_vnet_sw_if_index_name, vnet_get_main (), sw_if_index,
 469                  format_ip6_address, address);
 470
 471   il = ip6_link_get (sw_if_index);
 472
 473   if (NULL == il)
 474     return;
 475
 476   /* *INDENT-OFF* */
 477   FOREACH_IP6_LINK_DELEGATE (ild, il,
 478   ({
 479       if (is_delete)
 480         {
 481           if (NULL != il_delegate_vfts[ild->ild_type].ildv_addr_del)
 482             il_delegate_vfts[ild->ild_type].ildv_addr_del(ild->ild_index,
 483                                                           address, address_length);
 484         }
 485       else
 486         {
 487           if (NULL != il_delegate_vfts[ild->ild_type].ildv_addr_add)
 488             il_delegate_vfts[ild->ild_type].ildv_addr_add(ild->ild_index,
 489                                                           address, address_length);
 490         }
 491   }));
 492   /* *INDENT-ON* */
 493 }
 494
 495 static clib_error_t *
 496 ip6_link_interface_add_del (vnet_main_t * vnm, u32 sw_if_index, u32 is_add)
 497 {
 498   if (!is_add)
 499     {
 500       ip6_link_t *il;
 501
 502       il = ip6_link_get (sw_if_index);
 503
 504       IP6_LINK_DBG ("link-del: %U",
 505                     format_vnet_sw_if_index_name, vnet_get_main (),
 506                     sw_if_index);
 507
 508       if (NULL != il)
 509         /* force cleanup */
 510         ip6_link_last_lock_gone (il);
 511     }
 512
 513   return (NULL);
 514 }
 515
 516 VNET_SW_INTERFACE_ADD_DEL_FUNCTION (ip6_link_interface_add_del);
 517
 518 static clib_error_t *
 519 ip6_link_init (vlib_main_t * vm)
 520 {
 521   il_randomizer = clib_cpu_time_now ();
 522   ip6_link_logger = vlib_log_register_class ("ip6", "link");
 523
 524   {
 525     ip6_add_del_interface_address_callback_t cb = {
 526       .function = ip6_link_add_del_address,
 527     };
 528     vec_add1 (ip6_main.add_del_interface_address_callbacks, cb);
 529   }
 530   return (NULL);
 531 }
 532
 533 VLIB_INIT_FUNCTION (ip6_link_init);
 534
 535
 536 static clib_error_t *
 537 test_ip6_link_command_fn (vlib_main_t * vm,
 538                           unformat_input_t * input, vlib_cli_command_t * cmd)
 539 {
 540   u8 mac[6];
 541   ip6_address_t _a, *a = &_a;
 542
 543   if (unformat (input, "%U", unformat_ethernet_address, mac))
 544     {
 545       ip6_link_local_address_from_mac (a, mac);
 546       vlib_cli_output (vm, "Link local address: %U", format_ip6_address, a);
 547       ip6_mac_address_from_link_local (mac, a);
 548       vlib_cli_output (vm, "Original MAC address: %U",
 549                        format_ethernet_address, mac);
 550     }
 551
 552   return 0;
 553 }
 554
 555 /*?
 556  * This command converts the given MAC Address into an IPv6 link-local
 557  * address.
 558  *
 559  * @cliexpar
 560  * Example of how to create an IPv6 link-local address:
 561  * @cliexstart{test ip6 link 16:d9:e0:91:79:86}
 562  * Link local address: fe80::14d9:e0ff:fe91:7986
 563  * Original MAC address: 16:d9:e0:91:79:86
 564  * @cliexend
 565 ?*/
 566 /* *INDENT-OFF* */
 567 VLIB_CLI_COMMAND (test_link_command, static) =
 568 {
 569   .path = "test ip6 link",
 570   .function = test_ip6_link_command_fn,
 571   .short_help = "test ip6 link <mac-address>",
 572 };
 573 /* *INDENT-ON* */
 574
 575 static u8 *
 576 ip6_print_addrs (u8 * s, u32 * addrs)
 577 {
 578   ip_lookup_main_t *lm = &ip6_main.lookup_main;
 579   u32 i;
 580
 581   for (i = 0; i < vec_len (addrs); i++)
 582     {
 583       ip_interface_address_t *a =
 584         pool_elt_at_index (lm->if_address_pool, addrs[i]);
 585       ip6_address_t *address = ip_interface_address_get_address (lm, a);
 586
 587       s = format (s, "%U%U/%d\n",
 588                   format_white_space, 4,
 589                   format_ip6_address, address, a->address_length);
 590     }
 591
 592   return (s);
 593 }
 594
 595 static u8 *
 596 format_ip6_link (u8 * s, va_list * arg)
 597 {
 598   const ip6_link_t *il = va_arg (*arg, ip6_link_t *);
 599   ip_lookup_main_t *lm = &ip6_main.lookup_main;
 600   vnet_main_t *vnm = vnet_get_main ();
 601
 602   if (!ip6_link_is_enabled_i (il))
 603     return (s);
 604
 605   s = format (s, "%U is admin %s\n",
 606               format_vnet_sw_interface_name, vnm,
 607               vnet_get_sw_interface (vnm, il->il_sw_if_index),
 608               (vnet_sw_interface_is_admin_up (vnm, il->il_sw_if_index) ?
 609                "up" : "down"));
 610
 611   u32 ai;
 612   u32 *link_scope = 0, *global_scope = 0;
 613   u32 *local_scope = 0, *unknown_scope = 0;
 614   ip_interface_address_t *a;
 615   const ip6_link_delegate_t *ild;
 616
 617   vec_validate_init_empty (lm->if_address_pool_index_by_sw_if_index,
 618                            il->il_sw_if_index, ~0);
 619   ai = lm->if_address_pool_index_by_sw_if_index[il->il_sw_if_index];
 620
 621   while (ai != (u32) ~ 0)
 622     {
 623       a = pool_elt_at_index (lm->if_address_pool, ai);
 624       ip6_address_t *address = ip_interface_address_get_address (lm, a);
 625
 626       if (ip6_address_is_link_local_unicast (address))
 627         vec_add1 (link_scope, ai);
 628       else if (ip6_address_is_global_unicast (address))
 629         vec_add1 (global_scope, ai);
 630       else if (ip6_address_is_local_unicast (address))
 631         vec_add1 (local_scope, ai);
 632       else
 633         vec_add1 (unknown_scope, ai);
 634
 635       ai = a->next_this_sw_interface;
 636     }
 637
 638   if (vec_len (link_scope))
 639     {
 640       s = format (s, "%ULink-local address(es):\n", format_white_space, 2);
 641       s = ip6_print_addrs (s, link_scope);
 642       vec_free (link_scope);
 643     }
 644
 645   if (vec_len (local_scope))
 646     {
 647       s = format (s, "%ULocal unicast address(es):\n", format_white_space, 2);
 648       s = ip6_print_addrs (s, local_scope);
 649       vec_free (local_scope);
 650     }
 651
 652   if (vec_len (global_scope))
 653     {
 654       s = format (s, "%UGlobal unicast address(es):\n",
 655                   format_white_space, 2);
 656       s = ip6_print_addrs (s, global_scope);
 657       vec_free (global_scope);
 658     }
 659
 660   if (vec_len (unknown_scope))
 661     {
 662       s = format (s, "%UOther-scope address(es):\n", format_white_space, 2);
 663       s = ip6_print_addrs (s, unknown_scope);
 664       vec_free (unknown_scope);
 665     }
 666
 667   s = format (s, "%ULink-local address(es):\n", format_white_space, 2);
 668   s = format (s, "%U%U\n",
 669               format_white_space, 4, format_ip6_address, &il->il_ll_addr);
 670
 671   /* *INDENT-OFF* */
 672   FOREACH_IP6_LINK_DELEGATE(ild, il,
 673   ({
 674     s = format (s, "%U", il_delegate_vfts[ild->ild_type].ildv_format,
 675                      ild->ild_index, 2);
 676   }));
 677   /* *INDENT-ON* */
 678
 679   return (s);
 680 }
 681
 682 static clib_error_t *
 683 ip6_link_show (vlib_main_t * vm,
 684                unformat_input_t * input, vlib_cli_command_t * cmd)
 685 {
 686   const ip6_link_t *il;
 687   vnet_main_t *vnm;
 688   u32 sw_if_index;
 689
 690   vnm = vnet_get_main ();
 691   sw_if_index = ~0;
 692
 693   if (unformat_user (input, unformat_vnet_sw_interface, vnm, &sw_if_index))
 694     {
 695       il = ip6_link_get (sw_if_index);
 696
 697       if (NULL == il)
 698         {
 699           vlib_cli_output (vm, "IP6 disabled");
 700           return (NULL);
 701         }
 702       else
 703         vlib_cli_output (vm, "%U", format_ip6_link, il);
 704     }
 705   else
 706     {
 707       vec_foreach (il, ip6_links)
 708         vlib_cli_output (vm, "%U", format_ip6_link, il);
 709     }
 710
 711   return (NULL);
 712 }
 713
 714 /*?
 715  * This command is used to display various IPv6 attributes on a given
 716  * interface.
 717  *
 718  * @cliexpar
 719  * Example of how to display IPv6 settings:
 720  * @cliexstart{show ip6 interface GigabitEthernet2/0/0}
 721  * GigabitEthernet2/0/0 is admin up
 722  *         Link-local address(es):
 723  *                 fe80::ab8/64
 724  *         Joined group address(es):
 725  *                 ff02::1
 726  *                 ff02::2
 727  *                 ff02::16
 728  *                 ff02::1:ff00:ab8
 729  *         Advertised Prefixes:
 730  *                 prefix fe80::fe:28ff:fe9c:75b3,  length 64
 731  *         MTU is 1500
 732  *         ICMP error messages are unlimited
 733  *         ICMP redirects are disabled
 734  *         ICMP unreachables are not sent
 735  *         ND DAD is disabled
 736  *         ND advertised reachable time is 0
 737  *         ND advertised retransmit interval is 0 (msec)
 738  *         ND router advertisements are sent every 200 seconds (min interval is 150)
 739  *         ND router advertisements live for 600 seconds
 740  *         Hosts use stateless autoconfig for addresses
 741  *         ND router advertisements sent 19336
 742  *         ND router solicitations received 0
 743  *         ND router solicitations dropped 0
 744  * @cliexend
 745  * Example of output if IPv6 is not enabled on the interface:
 746  * @cliexstart{show ip6 interface GigabitEthernet2/0/0}
 747  * show ip6 interface: IPv6 not enabled on interface
 748  * @cliexend
 749 ?*/
 750 /* *INDENT-OFF* */
 751 VLIB_CLI_COMMAND (ip6_link_show_command, static) =
 752 {
 753   .path = "show ip6 interface",
 754   .function = ip6_link_show,
 755   .short_help = "show ip6 interface <interface>",
 756 };
 757 /* *INDENT-ON* */
 758
 759 static clib_error_t *
 760 enable_ip6_interface_cmd (vlib_main_t * vm,
 761                           unformat_input_t * input, vlib_cli_command_t * cmd)
 762 {
 763   vnet_main_t *vnm = vnet_get_main ();
 764   clib_error_t *error = NULL;
 765   u32 sw_if_index;
 766
 767   sw_if_index = ~0;
 768
 769   if (unformat_user (input, unformat_vnet_sw_interface, vnm, &sw_if_index))
 770     {
 771       if (ip6_link_enable (sw_if_index, NULL))
 772         error = clib_error_return (0, "Failed\n");
 773     }
 774   else
 775     {
 776       error = clib_error_return (0, "unknown interface\n'",
 777                                  format_unformat_error, input);
 778
 779     }
 780   return error;
 781 }
 782
 783 /*?
 784  * This command is used to enable IPv6 on a given interface.
 785  *
 786  * @cliexpar
 787  * Example of how enable IPv6 on a given interface:
 788  * @cliexcmd{enable ip6 interface GigabitEthernet2/0/0}
 789 ?*/
 790 /* *INDENT-OFF* */
 791 VLIB_CLI_COMMAND (enable_ip6_interface_command, static) =
 792 {
 793   .path = "enable ip6 interface",
 794   .function = enable_ip6_interface_cmd,
 795   .short_help = "enable ip6 interface <interface>",
 796 };
 797 /* *INDENT-ON* */
 798
 799 static clib_error_t *
 800 disable_ip6_interface_cmd (vlib_main_t * vm,
 801                            unformat_input_t * input, vlib_cli_command_t * cmd)
 802 {
 803   vnet_main_t *vnm = vnet_get_main ();
 804   clib_error_t *error = NULL;
 805   u32 sw_if_index;
 806
 807   sw_if_index = ~0;
 808
 809   if (unformat_user (input, unformat_vnet_sw_interface, vnm, &sw_if_index))
 810     {
 811       if (ip6_link_disable (sw_if_index))
 812         error = clib_error_return (0, "Failed\n");
 813     }
 814   else
 815     {
 816       error = clib_error_return (0, "unknown interface\n'",
 817                                  format_unformat_error, input);
 818
 819     }
 820   return error;
 821 }
 822
 823 /*?
 824  * This command is used to disable IPv6 on a given interface.
 825  *
 826  * @cliexpar
 827  * Example of how disable IPv6 on a given interface:
 828  * @cliexcmd{disable ip6 interface GigabitEthernet2/0/0}
 829 ?*/
 830 /* *INDENT-OFF* */
 831 VLIB_CLI_COMMAND (disable_ip6_interface_command, static) =
 832 {
 833   .path = "disable ip6 interface",
 834   .function = disable_ip6_interface_cmd,
 835   .short_help = "disable ip6 interface <interface>",
 836 };
 837 /* *INDENT-ON* */
 838
 839 /*
 840  * fd.io coding-style-patch-verification: ON
 841  *
 842  * Local Variables:
 843  * eval: (c-set-style "gnu")
 844  * End:
 845  */