src/plugins/dhcp/dhcp6_pd_client_cp.c

   1 /*
   2  * Copyright (c) 2018 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/vnet.h>
  17 #include <vlibmemory/api.h>
  18 #include <dhcp/dhcp6_packet.h>
  19 #include <dhcp/dhcp6_pd_client_dp.h>
  20 #include <vnet/ip/ip.h>
  21 #include <vnet/ip/ip6.h>
  22 #include <vnet/ip/ip6_link.h>
  23 #include <vnet/ip6-nd/ip6_ra.h>
  24 #include <float.h>
  25 #include <math.h>
  26 #include <string.h>
  27 #include <vnet/ip/ip_types_api.h>
  28
  29 typedef struct
  30 {
  31   u32 prefix_group_index;
  32   uword opaque_data;            // used by prefix publisher
  33   ip6_address_t prefix;
  34   u8 prefix_length;
  35   u32 preferred_lt;
  36   u32 valid_lt;
  37   f64 due_time;
  38 } prefix_info_t;
  39
  40 typedef struct
  41 {
  42   u8 enabled;
  43   u32 prefix_group_index;
  44   u32 server_index;
  45   u32 T1;
  46   u32 T2;
  47   f64 T1_due_time;
  48   f64 T2_due_time;
  49   u32 prefix_count;
  50   u8 rebinding;
  51 } client_state_t;
  52
  53 typedef struct
  54 {
  55   client_state_t *client_state_by_sw_if_index;
  56   clib_bitmap_t *prefix_ownership_bitmap;
  57   u32 n_clients;
  58   f64 max_valid_due_time;
  59
  60   /* convenience */
  61   vlib_main_t *vlib_main;
  62   vnet_main_t *vnet_main;
  63   api_main_t *api_main;
  64   u32 node_index;
  65 } dhcp6_pd_client_cp_main_t;
  66
  67 static dhcp6_pd_client_cp_main_t dhcp6_pd_client_cp_main;
  68
  69 typedef struct
  70 {
  71   prefix_info_t *prefix_pool;
  72   const u8 **prefix_group_name_by_index;
  73 } ip6_prefix_main_t;
  74
  75 static ip6_prefix_main_t ip6_prefix_main;
  76
  77 typedef struct
  78 {
  79   /* config */
  80   u32 sw_if_index;
  81   u32 prefix_group_index;
  82   ip6_address_t address;
  83   u8 prefix_length;
  84
  85   /* state */
  86   u8 configured_in_data_plane;
  87 } ip6_address_info_t;
  88
  89 typedef struct
  90 {
  91   ip6_address_info_t *addresses;
  92   u32 *active_prefix_index_by_prefix_group_index;
  93 } ip6_address_with_prefix_main_t;
  94
  95 static ip6_address_with_prefix_main_t ip6_address_with_prefix_main;
  96
  97 enum
  98 {
  99   DHCPV6_PD_EVENT_INTERRUPT,
 100   DHCPV6_PD_EVENT_DISABLE,
 101 };
 102
 103 static_always_inline u32
 104 active_prefix_index_by_prefix_group_index_get (u32 prefix_group_index)
 105 {
 106   ip6_address_with_prefix_main_t *apm = &ip6_address_with_prefix_main;
 107
 108   if (prefix_group_index >=
 109       vec_len (apm->active_prefix_index_by_prefix_group_index))
 110     return ~0;
 111
 112   return apm->active_prefix_index_by_prefix_group_index[prefix_group_index];
 113 }
 114
 115 static_always_inline void
 116 active_prefix_index_by_prefix_group_index_set (u32 prefix_group_index,
 117                                                u32 prefix_index)
 118 {
 119   ip6_address_with_prefix_main_t *apm = &ip6_address_with_prefix_main;
 120   static const u32 empty = ~0;
 121
 122   ASSERT (prefix_group_index != ~0);
 123
 124   if (prefix_index == ~0
 125       && prefix_group_index >=
 126       vec_len (apm->active_prefix_index_by_prefix_group_index))
 127     return;
 128
 129   vec_validate_init_empty (apm->active_prefix_index_by_prefix_group_index,
 130                            prefix_group_index, empty);
 131   apm->active_prefix_index_by_prefix_group_index[prefix_group_index] =
 132     prefix_index;
 133 }
 134
 135 static_always_inline u8
 136 is_dhcpv6_pd_prefix (prefix_info_t * prefix_info)
 137 {
 138   dhcp6_pd_client_cp_main_t *rm = &dhcp6_pd_client_cp_main;
 139   ip6_prefix_main_t *pm = &ip6_prefix_main;
 140   u32 prefix_index;
 141
 142   prefix_index = prefix_info - pm->prefix_pool;
 143   return clib_bitmap_get (rm->prefix_ownership_bitmap, prefix_index);
 144 }
 145
 146 static_always_inline void
 147 set_is_dhcpv6_pd_prefix (prefix_info_t * prefix_info, u8 value)
 148 {
 149   dhcp6_pd_client_cp_main_t *rm = &dhcp6_pd_client_cp_main;
 150   ip6_prefix_main_t *pm = &ip6_prefix_main;
 151   u32 prefix_index;
 152
 153   prefix_index = prefix_info - pm->prefix_pool;
 154   rm->prefix_ownership_bitmap =
 155     clib_bitmap_set (rm->prefix_ownership_bitmap, prefix_index, value);
 156 }
 157
 158 static void
 159 cp_ip6_address_prefix_add_del_handler (u32 prefix_index, u8 is_add);
 160
 161 static void
 162 notify_prefix_add_del (u32 prefix_index, u8 is_add)
 163 {
 164   // TODO: use registries
 165   cp_ip6_address_prefix_add_del_handler (prefix_index, is_add);
 166 }
 167
 168 static void
 169 send_client_message_start_stop (u32 sw_if_index, u32 server_index,
 170                                 u8 msg_type, prefix_info_t * prefix_list,
 171                                 u8 start)
 172 {
 173   dhcp6_pd_client_cp_main_t *rm = &dhcp6_pd_client_cp_main;
 174   dhcp6_pd_send_client_message_params_t params = { 0, };
 175   dhcp6_pd_send_client_message_params_prefix_t *prefixes = 0, *pref;
 176   u32 i;
 177
 178   ASSERT (sw_if_index < vec_len (rm->client_state_by_sw_if_index) &&
 179           rm->client_state_by_sw_if_index[sw_if_index].enabled);
 180   client_state_t *client_state =
 181     &rm->client_state_by_sw_if_index[sw_if_index];
 182
 183   params.sw_if_index = sw_if_index;
 184   params.server_index = server_index;
 185   params.msg_type = msg_type;
 186   if (start)
 187     {
 188       if (msg_type == DHCPV6_MSG_SOLICIT)
 189         {
 190           params.irt = 1;
 191           params.mrt = 120;
 192         }
 193       else if (msg_type == DHCPV6_MSG_REQUEST)
 194         {
 195           params.irt = 1;
 196           params.mrt = 30;
 197           params.mrc = 10;
 198         }
 199       else if (msg_type == DHCPV6_MSG_RENEW)
 200         {
 201           params.irt = 10;
 202           params.mrt = 600;
 203           f64 current_time = vlib_time_now (rm->vlib_main);
 204           i32 diff_time = client_state->T2 - current_time;
 205           if (diff_time < 0)
 206             diff_time = 0;
 207           params.mrd = diff_time;
 208         }
 209       else if (msg_type == DHCPV6_MSG_REBIND)
 210         {
 211           params.irt = 10;
 212           params.mrt = 600;
 213           f64 current_time = vlib_time_now (rm->vlib_main);
 214           i32 diff_time = rm->max_valid_due_time - current_time;
 215           if (diff_time < 0)
 216             diff_time = 0;
 217           params.mrd = diff_time;
 218         }
 219       else if (msg_type == DHCPV6_MSG_RELEASE)
 220         {
 221           params.mrc = 1;
 222         }
 223     }
 224
 225   params.T1 = 0;
 226   params.T2 = 0;
 227   if (vec_len (prefix_list) != 0)
 228     vec_validate (prefixes, vec_len (prefix_list) - 1);
 229   for (i = 0; i < vec_len (prefix_list); i++)
 230     {
 231       prefix_info_t *prefix = &prefix_list[i];
 232       pref = &prefixes[i];
 233       pref->valid_lt = prefix->valid_lt;
 234       pref->preferred_lt = prefix->preferred_lt;
 235       pref->prefix = prefix->prefix;
 236       pref->prefix_length = prefix->prefix_length;
 237     }
 238   params.prefixes = prefixes;
 239
 240   dhcp6_pd_send_client_message (rm->vlib_main, sw_if_index, !start, &params);
 241
 242   vec_free (params.prefixes);
 243 }
 244
 245 static void interrupt_process (void);
 246
 247 static u8
 248 ip6_prefixes_equal (ip6_address_t * prefix1, ip6_address_t * prefix2, u8 len)
 249 {
 250   if (len >= 64)
 251     {
 252       if (prefix1->as_u64[0] != prefix2->as_u64[0])
 253         return 0;
 254       if (len == 64)
 255         return 1;
 256       return clib_net_to_host_u64 (prefix1->as_u64[1]) >> (128 - len) ==
 257         clib_net_to_host_u64 (prefix2->as_u64[1]) >> (128 - len);
 258     }
 259   return clib_net_to_host_u64 (prefix1->as_u64[0]) >> (64 - len) ==
 260     clib_net_to_host_u64 (prefix2->as_u64[0]) >> (64 - len);
 261 }
 262
 263 static clib_error_t *
 264 dhcp6_pd_reply_event_handler (vl_api_dhcp6_pd_reply_event_t * mp)
 265 {
 266   dhcp6_pd_client_cp_main_t *rm = &dhcp6_pd_client_cp_main;
 267   ip6_prefix_main_t *pm = &ip6_prefix_main;
 268   vlib_main_t *vm = rm->vlib_main;
 269   client_state_t *client_state;
 270   ip6_address_t *prefix;
 271   u32 sw_if_index;
 272   u32 n_prefixes;
 273   vl_api_dhcp6_pd_prefix_info_t *api_prefix;
 274   u32 inner_status_code;
 275   u32 status_code;
 276   u32 server_index;
 277   f64 current_time;
 278   clib_error_t *error = 0;
 279   u32 i;
 280
 281   current_time = vlib_time_now (vm);
 282
 283   sw_if_index = ntohl (mp->sw_if_index);
 284
 285   if (sw_if_index >= vec_len (rm->client_state_by_sw_if_index))
 286     return 0;
 287
 288   client_state = &rm->client_state_by_sw_if_index[sw_if_index];
 289
 290   if (!client_state->enabled)
 291     return 0;
 292
 293   server_index = ntohl (mp->server_index);
 294
 295   n_prefixes = ntohl (mp->n_prefixes);
 296
 297   inner_status_code = ntohs (mp->inner_status_code);
 298   status_code = ntohs (mp->status_code);
 299
 300   if (mp->msg_type == DHCPV6_MSG_API_ADVERTISE
 301       && client_state->server_index == ~0)
 302     {
 303       prefix_info_t *prefix_list = 0, *prefix_info;
 304       u8 prefix_length;
 305
 306       if (inner_status_code == DHCPV6_STATUS_NOPREFIX_AVAIL)
 307         {
 308           clib_warning
 309             ("Advertise message arrived with NoPrefixAvail status code");
 310           return 0;
 311         }
 312
 313       if (n_prefixes > 0)
 314         vec_validate (prefix_list, n_prefixes - 1);
 315       for (i = 0; i < n_prefixes; i++)
 316         {
 317           api_prefix = &mp->prefixes[i];
 318           prefix = (ip6_address_t *) api_prefix->prefix.address;
 319           prefix_length = api_prefix->prefix.len;
 320
 321           prefix_info = &prefix_list[i];
 322           prefix_info->prefix = *prefix;
 323           prefix_info->prefix_length = prefix_length;
 324           prefix_info->preferred_lt = 0;
 325           prefix_info->valid_lt = 0;
 326         }
 327
 328       client_state->server_index = server_index;
 329
 330       send_client_message_start_stop (sw_if_index, server_index,
 331                                       DHCPV6_MSG_REQUEST, prefix_list, 1);
 332       vec_free (prefix_list);
 333     }
 334
 335   if (mp->msg_type != DHCPV6_MSG_API_REPLY)
 336     return 0;
 337
 338   if (!client_state->rebinding && client_state->server_index != server_index)
 339     {
 340       clib_warning ("Reply message arrived with Server ID different "
 341                     "from that in Request or Renew message");
 342       return 0;
 343     }
 344
 345   if (inner_status_code == DHCPV6_STATUS_NOPREFIX_AVAIL)
 346     {
 347       clib_warning ("Reply message arrived with NoPrefixAvail status code");
 348       if (n_prefixes > 0)
 349         {
 350           clib_warning
 351             ("Invalid Reply message arrived: It contains NoPrefixAvail "
 352              "status code but also contains prefixes");
 353           return 0;
 354         }
 355     }
 356
 357   if (status_code == DHCPV6_STATUS_UNSPEC_FAIL)
 358     {
 359       clib_warning ("Reply message arrived with UnspecFail status code");
 360       return 0;
 361     }
 362
 363   send_client_message_start_stop (sw_if_index, server_index,
 364                                   mp->msg_type, 0, 0);
 365
 366   for (i = 0; i < n_prefixes; i++)
 367     {
 368       prefix_info_t *prefix_info = 0;
 369       u8 prefix_length;
 370       u32 valid_time;
 371       u32 preferred_time;
 372
 373       api_prefix = &mp->prefixes[i];
 374
 375       prefix = (ip6_address_t *) api_prefix->prefix.address;
 376       prefix_length = api_prefix->prefix.len;
 377
 378       if (ip6_address_is_link_local_unicast (prefix))
 379         continue;
 380
 381       valid_time = ntohl (api_prefix->valid_time);
 382       preferred_time = ntohl (api_prefix->preferred_time);
 383       prefix_length = api_prefix->prefix.len;
 384
 385       if (preferred_time > valid_time)
 386         continue;
 387
 388       u8 address_prefix_present = 0;
 389       /* *INDENT-OFF* */
 390       pool_foreach (prefix_info, pm->prefix_pool,
 391       ({
 392         if (is_dhcpv6_pd_prefix (prefix_info) &&
 393             prefix_info->opaque_data == sw_if_index &&
 394             prefix_info->prefix_length == prefix_length &&
 395             ip6_prefixes_equal (&prefix_info->prefix, prefix, prefix_length))
 396           {
 397             address_prefix_present = 1;
 398             goto prefix_pool_foreach_out;
 399           }
 400       }));
 401       /* *INDENT-ON* */
 402     prefix_pool_foreach_out:
 403
 404       if (address_prefix_present)
 405         {
 406           /*
 407            * We found the prefix. Move along.
 408            * Don't touch the prefix timers!
 409            * If we happen to receive a renew reply just before we
 410            * would have sent a solicit to renew the prefix delegation,
 411            * we forget to renew the delegation. Worse luck, we start
 412            * sending router advertisements with a valid time of zero,
 413            * and the wheels fall off...
 414            */
 415           continue;
 416         }
 417
 418       if (valid_time == 0)
 419         continue;
 420
 421       pool_get (pm->prefix_pool, prefix_info);
 422       prefix_info->prefix_group_index = client_state->prefix_group_index;
 423       set_is_dhcpv6_pd_prefix (prefix_info, 1);
 424       prefix_info->opaque_data = sw_if_index;
 425       prefix_info->prefix_length = prefix_length;
 426       prefix_info->prefix = *prefix;
 427       prefix_info->preferred_lt = preferred_time;
 428       prefix_info->valid_lt = valid_time;
 429       prefix_info->due_time = current_time + valid_time;
 430       if (prefix_info->due_time > rm->max_valid_due_time)
 431         rm->max_valid_due_time = prefix_info->due_time;
 432       rm->client_state_by_sw_if_index[sw_if_index].prefix_count++;
 433
 434       u32 prefix_index = prefix_info - pm->prefix_pool;
 435       notify_prefix_add_del (prefix_index, 1);
 436     }
 437
 438   client_state->server_index = server_index;
 439   client_state->T1 = ntohl (mp->T1);
 440   client_state->T2 = ntohl (mp->T2);
 441   if (client_state->T1 != 0)
 442     client_state->T1_due_time = current_time + client_state->T1;
 443   if (client_state->T2 != 0)
 444     client_state->T2_due_time = current_time + client_state->T2;
 445   client_state->rebinding = 0;
 446
 447   interrupt_process ();
 448
 449   return error;
 450 }
 451
 452 static prefix_info_t *
 453 create_prefix_list (u32 sw_if_index)
 454 {
 455   ip6_prefix_main_t *pm = &ip6_prefix_main;
 456   prefix_info_t *prefix_info, *prefix_list = 0;;
 457
 458   /* *INDENT-OFF* */
 459   pool_foreach (prefix_info, pm->prefix_pool,
 460   ({
 461     if (is_dhcpv6_pd_prefix (prefix_info) &&
 462         prefix_info->opaque_data == sw_if_index)
 463       {
 464         u32 pos = vec_len (prefix_list);
 465         vec_validate (prefix_list, pos);
 466         clib_memcpy (&prefix_list[pos], prefix_info, sizeof (*prefix_info));
 467       }
 468   }));
 469   /* *INDENT-ON* */
 470
 471   return prefix_list;
 472 }
 473
 474 VNET_DHCP6_PD_REPLY_EVENT_FUNCTION (dhcp6_pd_reply_event_handler);
 475
 476 static uword
 477 dhcp6_pd_client_cp_process (vlib_main_t * vm, vlib_node_runtime_t * rt,
 478                             vlib_frame_t * f)
 479 {
 480   dhcp6_pd_client_cp_main_t *rm = &dhcp6_pd_client_cp_main;
 481   ip6_prefix_main_t *pm = &ip6_prefix_main;
 482   prefix_info_t *prefix_info;
 483   client_state_t *client_state;
 484   f64 sleep_time = 1e9;
 485   f64 current_time;
 486   f64 due_time;
 487   uword event_type;
 488   uword *event_data = 0;
 489   int i;
 490
 491   while (1)
 492     {
 493       vlib_process_wait_for_event_or_clock (vm, sleep_time);
 494       event_type = vlib_process_get_events (vm, &event_data);
 495       vec_reset_length (event_data);
 496
 497       if (event_type == DHCPV6_PD_EVENT_DISABLE)
 498         {
 499           vlib_node_set_state (vm, rm->node_index, VLIB_NODE_STATE_DISABLED);
 500           sleep_time = 1e9;
 501           continue;
 502         }
 503
 504       current_time = vlib_time_now (vm);
 505       do
 506         {
 507           due_time = current_time + 1e9;
 508           /* *INDENT-OFF* */
 509           pool_foreach (prefix_info, pm->prefix_pool,
 510           ({
 511             if (is_dhcpv6_pd_prefix (prefix_info))
 512               {
 513                 if (prefix_info->due_time > current_time)
 514                   {
 515                     if (prefix_info->due_time < due_time)
 516                       due_time = prefix_info->due_time;
 517                   }
 518                 else
 519                   {
 520                     u32 prefix_index = prefix_info - pm->prefix_pool;
 521                     notify_prefix_add_del (prefix_index, 0);
 522                     u32 sw_if_index = prefix_info->opaque_data;
 523                     set_is_dhcpv6_pd_prefix (prefix_info, 0);
 524                     pool_put (pm->prefix_pool, prefix_info);
 525                     client_state = &rm->client_state_by_sw_if_index[sw_if_index];
 526                     if (--client_state->prefix_count == 0)
 527                       {
 528                         client_state->rebinding = 0;
 529                         client_state->server_index = ~0;
 530                         send_client_message_start_stop (sw_if_index, ~0,
 531                                                         DHCPV6_MSG_SOLICIT,
 532                                                         0, 1);
 533                       }
 534                   }
 535               }
 536           }));
 537           /* *INDENT-ON* */
 538           for (i = 0; i < vec_len (rm->client_state_by_sw_if_index); i++)
 539             {
 540               client_state_t *cs = &rm->client_state_by_sw_if_index[i];
 541               if (cs->enabled && cs->server_index != ~0)
 542                 {
 543                   if (cs->T2_due_time > current_time)
 544                     {
 545                       if (cs->T2_due_time < due_time)
 546                         due_time = cs->T2_due_time;
 547                       if (cs->T1_due_time > current_time)
 548                         {
 549                           if (cs->T1_due_time < due_time)
 550                             due_time = cs->T1_due_time;
 551                         }
 552                       else
 553                         {
 554                           cs->T1_due_time = DBL_MAX;
 555                           prefix_info_t *prefix_list;
 556                           prefix_list = create_prefix_list (i);
 557                           send_client_message_start_stop (i, cs->server_index,
 558                                                           DHCPV6_MSG_RENEW,
 559                                                           prefix_list, 1);
 560                           vec_free (prefix_list);
 561                         }
 562                     }
 563                   else
 564                     {
 565                       cs->T2_due_time = DBL_MAX;
 566                       prefix_info_t *prefix_list;
 567                       prefix_list = create_prefix_list (i);
 568                       cs->rebinding = 1;
 569                       send_client_message_start_stop (i, ~0,
 570                                                       DHCPV6_MSG_REBIND,
 571                                                       prefix_list, 1);
 572                       vec_free (prefix_list);
 573                     }
 574                 }
 575             }
 576           current_time = vlib_time_now (vm);
 577         }
 578       while (due_time < current_time);
 579
 580       sleep_time = due_time - current_time;
 581     }
 582
 583   return 0;
 584 }
 585
 586 /* *INDENT-OFF* */
 587 VLIB_REGISTER_NODE (dhcp6_pd_client_cp_process_node) = {
 588     .function = dhcp6_pd_client_cp_process,
 589     .type = VLIB_NODE_TYPE_PROCESS,
 590     .name = "dhcp6-pd-client-cp-process",
 591 };
 592 /* *INDENT-ON* */
 593
 594 static void
 595 interrupt_process (void)
 596 {
 597   dhcp6_pd_client_cp_main_t *rm = &dhcp6_pd_client_cp_main;
 598   vlib_main_t *vm = rm->vlib_main;
 599
 600   vlib_process_signal_event (vm, dhcp6_pd_client_cp_process_node.index,
 601                              DHCPV6_PD_EVENT_INTERRUPT, 0);
 602 }
 603
 604 static void
 605 disable_process (void)
 606 {
 607   dhcp6_pd_client_cp_main_t *rm = &dhcp6_pd_client_cp_main;
 608   vlib_main_t *vm = rm->vlib_main;
 609
 610   vlib_process_signal_event (vm, dhcp6_pd_client_cp_process_node.index,
 611                              DHCPV6_PD_EVENT_DISABLE, 0);
 612 }
 613
 614 static void
 615 enable_process (void)
 616 {
 617   dhcp6_pd_client_cp_main_t *rm = &dhcp6_pd_client_cp_main;
 618   vlib_main_t *vm = rm->vlib_main;
 619   vlib_node_t *node;
 620
 621   node = vec_elt (vm->node_main.nodes, rm->node_index);
 622
 623   vlib_node_set_state (vm, rm->node_index, VLIB_NODE_STATE_POLLING);
 624   vlib_start_process (vm, node->runtime_index);
 625 }
 626
 627 static u32
 628 cp_ip6_construct_address (ip6_address_info_t * address_info, u32 prefix_index,
 629                           ip6_address_t * r_addr)
 630 {
 631   ip6_prefix_main_t *pm = &ip6_prefix_main;
 632   prefix_info_t *prefix;
 633   u64 mask, addr0, pref;
 634
 635   addr0 = clib_net_to_host_u64 (address_info->address.as_u64[0]);
 636   prefix = &pm->prefix_pool[prefix_index];
 637   if (prefix->prefix_length > 64)
 638     {
 639       clib_warning ("Prefix length is bigger that 64 bits");
 640       return 1;
 641     }
 642   mask = ((u64) 1 << (64 - prefix->prefix_length)) - 1;
 643   addr0 &= mask;
 644   pref = clib_host_to_net_u64 (prefix->prefix.as_u64[0]);
 645   pref &= ~mask;
 646   addr0 |= pref;
 647   r_addr->as_u64[0] = clib_host_to_net_u64 (addr0);
 648   r_addr->as_u64[1] = address_info->address.as_u64[1];
 649
 650   return 0;
 651 }
 652
 653 static void
 654 cp_ip6_address_add_del_now (ip6_address_info_t * address_info, u8 is_add)
 655 {
 656   vlib_main_t *vm = vlib_get_main ();
 657   u32 prefix_index;
 658   ip6_address_t addr;
 659   clib_error_t *error;
 660
 661   if (address_info->prefix_group_index != ~0)
 662     prefix_index =
 663       active_prefix_index_by_prefix_group_index_get
 664       (address_info->prefix_group_index);
 665   else
 666     prefix_index = ~0;
 667
 668   if (is_add && !address_info->configured_in_data_plane)
 669     {
 670       if (prefix_index != ~0)
 671         {
 672           if (cp_ip6_construct_address (address_info, prefix_index, &addr) !=
 673               0)
 674             return;
 675           error =
 676             ip6_add_del_interface_address (vm, address_info->sw_if_index,
 677                                            &addr, address_info->prefix_length,
 678                                            0 /* add */ );
 679           if (error)
 680             clib_warning ("Failed adding IPv6 address: %U",
 681                           format_clib_error, error);
 682           else
 683             {
 684               if (CLIB_DEBUG > 0)
 685                 clib_warning ("Add address %U on %U",
 686                               format_ip6_address_and_length,
 687                               &addr, address_info->prefix_length,
 688                               format_vnet_sw_if_index_name,
 689                               vnet_get_main (), address_info->sw_if_index);
 690
 691               address_info->configured_in_data_plane = 1;
 692             }
 693         }
 694       else
 695         {
 696           if (address_info->prefix_group_index == ~0)
 697             {
 698               error =
 699                 ip6_add_del_interface_address (vm, address_info->sw_if_index,
 700                                                &address_info->address,
 701                                                address_info->prefix_length,
 702                                                0 /* add */ );
 703               if (error)
 704                 clib_warning ("Failed adding IPv6 address: %U",
 705                               format_clib_error, error);
 706               else
 707                 {
 708                   if (CLIB_DEBUG > 0)
 709                     clib_warning ("Add address %U on %U",
 710                                   format_ip6_address_and_length,
 711                                   &addr, address_info->prefix_length,
 712                                   format_vnet_sw_if_index_name,
 713                                   vnet_get_main (),
 714                                   address_info->sw_if_index);
 715
 716                   address_info->configured_in_data_plane = 1;
 717                 }
 718             }
 719         }
 720     }
 721   else if (!is_add && address_info->configured_in_data_plane)
 722     {
 723       if (prefix_index == ~0)
 724         {
 725           if (address_info->prefix_group_index == ~0)
 726             {
 727               error =
 728                 ip6_add_del_interface_address (vm, address_info->sw_if_index,
 729                                                &address_info->address,
 730                                                address_info->prefix_length,
 731                                                1 /* del */ );
 732               if (error)
 733                 clib_warning ("Failed deleting IPv6 address: %U",
 734                               format_clib_error, error);
 735               address_info->configured_in_data_plane = 0;
 736             }
 737           else
 738             clib_warning ("Deleting address with prefix "
 739                           "but active prefix index is not set");
 740         }
 741       else
 742         {
 743           if (cp_ip6_construct_address (address_info, prefix_index, &addr) !=
 744               0)
 745             return;
 746           error =
 747             ip6_add_del_interface_address (vm, address_info->sw_if_index,
 748                                            &addr, address_info->prefix_length,
 749                                            1 /* del */ );
 750           if (error)
 751             clib_warning ("Failed deleting IPv6 address: %U",
 752                           format_clib_error, error);
 753           address_info->configured_in_data_plane = 0;
 754         }
 755     }
 756 }
 757
 758 static u32
 759 cp_ip6_address_find_new_active_prefix (u32 prefix_group_index,
 760                                        u32 ignore_prefix_index)
 761 {
 762   ip6_prefix_main_t *pm = &ip6_prefix_main;
 763   prefix_info_t *prefix_info;
 764
 765   /* *INDENT-OFF* */
 766   pool_foreach (prefix_info, pm->prefix_pool,
 767   ({
 768     if (prefix_info->prefix_group_index == prefix_group_index &&
 769         prefix_info - pm->prefix_pool != ignore_prefix_index)
 770         return prefix_info - pm->prefix_pool;
 771   }));
 772   /* *INDENT-ON* */
 773   return ~0;
 774 }
 775
 776 static void
 777 cp_ip6_advertise_prefix (prefix_info_t * prefix_info,
 778                          ip6_address_info_t * address_info, int enable)
 779 {
 780   vlib_main_t *vm = vlib_get_main ();
 781   ip6_main_t *im = &ip6_main;
 782   u32 prefix_index;
 783   ip6_address_t addr;
 784   int rv;
 785
 786   prefix_index =
 787     active_prefix_index_by_prefix_group_index_get
 788     (address_info->prefix_group_index);
 789
 790   if (cp_ip6_construct_address (address_info, prefix_index, &addr) != 0)
 791     {
 792       clib_warning ("address construction FAIL");
 793       return;
 794     }
 795
 796   /* The RA code assumes that host bits are zero, so clear them */
 797   addr.as_u64[0] &= im->fib_masks[address_info->prefix_length].as_u64[0];
 798   addr.as_u64[1] &= im->fib_masks[address_info->prefix_length].as_u64[1];
 799
 800   rv = ip6_ra_prefix (vm, address_info->sw_if_index,
 801                       &addr, address_info->prefix_length,
 802                       0 /* use_default */ ,
 803                       prefix_info->valid_lt,
 804                       prefix_info->preferred_lt, 0 /* no_advertise */ ,
 805                       0 /* off_link */ ,
 806                       0 /* no_autoconfig */ ,
 807                       0 /* no_onlink */ ,
 808                       enable == 0 /* is_no */ );
 809   if (rv != 0)
 810     {
 811       clib_warning ("ip6_neighbor_ra_prefix returned %d", rv);
 812       return;
 813     }
 814
 815   if (CLIB_DEBUG > 0)
 816     clib_warning ("Advertise prefix %U valid lt %u preferred lt %u",
 817                   format_ip6_address_and_length, &addr,
 818                   address_info->prefix_length, prefix_info->valid_lt,
 819                   prefix_info->preferred_lt);
 820 }
 821
 822
 823 static void
 824 cp_ip6_address_prefix_add_del_handler (u32 prefix_index, u8 is_add)
 825 {
 826   ip6_address_with_prefix_main_t *apm = &ip6_address_with_prefix_main;
 827   ip6_prefix_main_t *pm = &ip6_prefix_main;
 828   ip6_address_info_t *address_info;
 829   prefix_info_t *prefix;
 830   u32 new_prefix_index;
 831   u32 prefix_group_index;
 832   u32 i;
 833
 834   prefix = &pm->prefix_pool[prefix_index];
 835   prefix_group_index = prefix->prefix_group_index;
 836
 837   if (is_add)
 838     {
 839       if (active_prefix_index_by_prefix_group_index_get
 840           (prefix_group_index) == ~0)
 841         {
 842           active_prefix_index_by_prefix_group_index_set
 843             (prefix_group_index, prefix_index);
 844           for (i = 0; i < vec_len (apm->addresses); i++)
 845             {
 846               address_info = &apm->addresses[i];
 847               if (address_info->prefix_group_index == prefix_group_index)
 848                 {
 849                   /* Add the prefix to the interface */
 850                   cp_ip6_address_add_del_now (address_info, 1 /* add */ );
 851                   /* And advertise the prefix on the interface */
 852                   cp_ip6_advertise_prefix (prefix, address_info,
 853                                            1 /* enable */ );
 854                 }
 855             }
 856         }
 857     }
 858   else
 859     {
 860       if (active_prefix_index_by_prefix_group_index_get
 861           (prefix_group_index) == prefix_index)
 862         {
 863           for (i = 0; i < vec_len (apm->addresses); i++)
 864             {
 865               address_info = &apm->addresses[i];
 866               if (address_info->prefix_group_index == prefix_group_index)
 867                 {
 868                   cp_ip6_advertise_prefix (prefix, address_info,
 869                                            0 /* enable */ );
 870                   cp_ip6_address_add_del_now (address_info, 0 /* del */ );
 871                 }
 872             }
 873           active_prefix_index_by_prefix_group_index_set
 874             (prefix_group_index, ~0);
 875           new_prefix_index =
 876             cp_ip6_address_find_new_active_prefix (prefix_group_index,
 877                                                    prefix_index);
 878           if (new_prefix_index != ~0)
 879             {
 880               active_prefix_index_by_prefix_group_index_set
 881                 (prefix_group_index, new_prefix_index);
 882               for (i = 0; i < vec_len (apm->addresses); i++)
 883                 {
 884                   address_info = &apm->addresses[i];
 885                   if (address_info->prefix_group_index == prefix_group_index)
 886                     {
 887                       cp_ip6_address_add_del_now (address_info, 1 /* add */ );
 888                       cp_ip6_advertise_prefix (prefix, address_info,
 889                                                1 /* enable */ );
 890                     }
 891                 }
 892             }
 893         }
 894     }
 895 }
 896
 897 static u32
 898 prefix_group_find_or_create (const u8 * name, u8 create)
 899 {
 900   ip6_prefix_main_t *pm = &ip6_prefix_main;
 901   u32 free_index = ~0;
 902   u8 *name_dup;
 903   u32 i;
 904
 905   for (i = 0; i < vec_len (pm->prefix_group_name_by_index); i++)
 906     {
 907       if (pm->prefix_group_name_by_index[i] == 0)
 908         free_index = i;
 909       else if (0 ==
 910                strcmp ((const char *) pm->prefix_group_name_by_index[i],
 911                        (const char *) name))
 912         return i;
 913     }
 914   if (!create)
 915     return ~0;
 916   name_dup = (u8 *) strdup ((const char *) name);
 917   if (free_index != ~0)
 918     {
 919       pm->prefix_group_name_by_index[free_index] = name_dup;
 920       return free_index;
 921     }
 922   else
 923     {
 924       vec_add1 (pm->prefix_group_name_by_index, name_dup);
 925       return vec_len (pm->prefix_group_name_by_index) - 1;
 926     }
 927 }
 928
 929 int
 930 dhcp6_cp_ip6_address_add_del (u32 sw_if_index, const u8 * prefix_group,
 931                               ip6_address_t address, u8 prefix_length,
 932                               u8 is_add)
 933 {
 934
 935   ip6_address_with_prefix_main_t *apm = &ip6_address_with_prefix_main;
 936   vnet_main_t *vnm = vnet_get_main ();
 937   ip6_address_info_t *address_info;
 938   u32 prefix_group_index;
 939   u32 n;
 940
 941   if (!vnet_sw_interface_is_api_valid (vnm, sw_if_index))
 942     {
 943       clib_warning ("Invalid sw_if_index");
 944       return VNET_API_ERROR_INVALID_VALUE;
 945     }
 946
 947   if (prefix_group != 0 && prefix_group[0] != '\0')
 948     {
 949       if (strnlen ((const char *) prefix_group, 64) == 64)
 950         return VNET_API_ERROR_INVALID_VALUE;
 951
 952       prefix_group_index = prefix_group_find_or_create (prefix_group, 1);
 953     }
 954   else
 955     prefix_group_index = ~0;
 956
 957   n = vec_len (apm->addresses);
 958
 959   vec_foreach (address_info, apm->addresses)
 960   {
 961     if (address_info->sw_if_index == sw_if_index &&
 962         address_info->prefix_group_index == prefix_group_index &&
 963         address_info->prefix_length == prefix_length &&
 964         0 == memcmp (&address_info->address, &address, 16))
 965       {
 966         if (is_add)
 967           return VNET_API_ERROR_DUPLICATE_IF_ADDRESS;
 968         cp_ip6_address_add_del_now (address_info, 0 /* del */ );
 969         *address_info = apm->addresses[n - 1];
 970         _vec_len (apm->addresses) = n - 1;
 971         return 0;
 972       }
 973   }
 974
 975   if (!is_add)
 976     return VNET_API_ERROR_ADDRESS_NOT_FOUND_FOR_INTERFACE;
 977
 978   vec_validate (apm->addresses, n);
 979   address_info = &apm->addresses[n];
 980   address_info->sw_if_index = sw_if_index;
 981   address_info->prefix_group_index = prefix_group_index;
 982   address_info->address = address;
 983   address_info->prefix_length = prefix_length;
 984   cp_ip6_address_add_del_now (address_info, 1 /* add */ );
 985
 986   return 0;
 987 }
 988
 989 static clib_error_t *
 990 cp_ip6_address_add_del_command_function (vlib_main_t * vm,
 991                                          unformat_input_t * input,
 992                                          vlib_cli_command_t * cmd)
 993 {
 994   vnet_main_t *vnm = vnet_get_main ();
 995   clib_error_t *error = 0;
 996   u32 sw_if_index = ~0;
 997   u8 *prefix_group = 0;
 998   ip6_address_t address;
 999   u32 prefix_length;
1000   u8 address_set = 0;
1001   u8 add = 1;
1002   unformat_input_t _line_input, *line_input = &_line_input;
1003
1004   if (!unformat_user (input, unformat_line_input, line_input))
1005     return 0;
1006
1007   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1008     {
1009       if (unformat
1010           (line_input, "%U", unformat_vnet_sw_interface, vnm, &sw_if_index));
1011       else if (unformat (line_input, "prefix group %s", &prefix_group));
1012       else
1013         if (unformat (line_input, "%U/%d", unformat_ip6_address,
1014                       &address, &prefix_length))
1015         address_set = 1;
1016       else if (unformat (line_input, "del"))
1017         add = 0;
1018       else
1019         {
1020           error = clib_error_return (0, "unexpected input `%U'",
1021                                      format_unformat_error, line_input);
1022           unformat_free (line_input);
1023           goto done;
1024         }
1025     }
1026
1027   unformat_free (line_input);
1028
1029   if (sw_if_index == ~0)
1030     error = clib_error_return (0, "Missing sw_if_index");
1031   else if (address_set == 0)
1032     error = clib_error_return (0, "Missing address");
1033   else
1034     {
1035       if (dhcp6_cp_ip6_address_add_del
1036           (sw_if_index, prefix_group, address, prefix_length, add) != 0)
1037         error = clib_error_return (0, "Error adding or removing address");
1038     }
1039
1040 done:
1041   return error;
1042 }
1043
1044 /*?
1045  * This command is used to add/delete IPv6 address
1046  * potentially using available prefix from specified prefix group
1047  *
1048  * @cliexpar
1049  * @parblock
1050  * Example of how to add IPv6 address:
1051  * @cliexcmd{set ip6 address GigabitEthernet2/0/0
1052  *           prefix group my-prefix-group ::7/64}
1053  * Example of how to delete IPv6 address:
1054  * @cliexcmd{set ip6 address GigabitEthernet2/0/0
1055  *           prefix group my-prefix-group ::7/64 del}
1056  * @endparblock
1057 ?*/
1058 /* *INDENT-OFF* */
1059 VLIB_CLI_COMMAND (ip6_address_add_del_command, static) = {
1060   .path = "set ip6 address",
1061   .short_help = "set ip6 address <interface> [prefix group <string>] "
1062                 "<address> [del]",
1063   .function = cp_ip6_address_add_del_command_function,
1064 };
1065 /* *INDENT-ON* */
1066
1067 static clib_error_t *
1068 cp_ip6_addresses_show_command_function (vlib_main_t * vm,
1069                                         unformat_input_t * input,
1070                                         vlib_cli_command_t * cmd)
1071 {
1072   ip6_address_with_prefix_main_t *apm = &ip6_address_with_prefix_main;
1073   ip6_prefix_main_t *pm = &ip6_prefix_main;
1074   ip6_address_info_t *address_info;
1075   const u8 *prefix_group;
1076   clib_error_t *error = 0;
1077   int i;
1078
1079   for (i = 0; i < vec_len (apm->addresses); i++)
1080     {
1081       address_info = &apm->addresses[i];
1082       if (address_info->prefix_group_index == ~0)
1083         prefix_group = (const u8 *) "NONE";
1084       else
1085         prefix_group =
1086           pm->prefix_group_name_by_index[address_info->prefix_group_index];
1087       vlib_cli_output (vm,
1088                        "sw_if_index: %u, prefix_group: %s, address: %U/%d",
1089                        address_info->sw_if_index, prefix_group,
1090                        format_ip6_address, &address_info->address,
1091                        address_info->prefix_length);
1092     }
1093
1094   return error;
1095 }
1096
1097 /* *INDENT-OFF* */
1098 VLIB_CLI_COMMAND (ip6_addresses_show_command, static) = {
1099   .path = "show ip6 addresses",
1100   .short_help = "show ip6 addresses",
1101   .function = cp_ip6_addresses_show_command_function,
1102 };
1103 /* *INDENT-ON* */
1104
1105 static clib_error_t *
1106 cp_ip6_prefixes_show_command_function (vlib_main_t * vm,
1107                                        unformat_input_t * input,
1108                                        vlib_cli_command_t * cmd)
1109 {
1110   ip6_prefix_main_t *pm = &ip6_prefix_main;
1111   clib_error_t *error = 0;
1112   prefix_info_t *prefix_info;
1113   const u8 *prefix_group;
1114   f64 current_time = vlib_time_now (vm);
1115
1116   /* *INDENT-OFF* */
1117   pool_foreach (prefix_info, pm->prefix_pool,
1118   ({
1119     prefix_group =
1120       pm->prefix_group_name_by_index[prefix_info->prefix_group_index];
1121     vlib_cli_output (vm, "opaque_data: %lu, prefix: %U/%d, prefix group: %s, "
1122                      "preferred lifetime: %u, valid lifetime: %u "
1123                      "(%f remaining)",
1124                      prefix_info->opaque_data, format_ip6_address,
1125                      &prefix_info->prefix, prefix_info->prefix_length,
1126                      prefix_group,
1127                      prefix_info->preferred_lt, prefix_info->valid_lt,
1128                      prefix_info->due_time - current_time);
1129   }));
1130   /* *INDENT-ON* */
1131
1132   return error;
1133 }
1134
1135 /* *INDENT-OFF* */
1136 VLIB_CLI_COMMAND (ip6_prefixes_show_command, static) = {
1137   .path = "show ip6 prefixes",
1138   .short_help = "show ip6 prefixes",
1139   .function = cp_ip6_prefixes_show_command_function,
1140 };
1141 /* *INDENT-ON* */
1142
1143 static clib_error_t *
1144 ip6_pd_clients_show_command_function (vlib_main_t * vm,
1145                                       unformat_input_t * input,
1146                                       vlib_cli_command_t * cmd)
1147 {
1148   dhcp6_pd_client_cp_main_t *rm = &dhcp6_pd_client_cp_main;
1149   ip6_prefix_main_t *pm = &ip6_prefix_main;
1150   clib_error_t *error = 0;
1151   client_state_t *cs;
1152   f64 current_time = vlib_time_now (vm);
1153   const u8 *prefix_group;
1154   char buf1[256];
1155   char buf2[256];
1156   const char *rebinding;
1157   u32 i;
1158
1159   for (i = 0; i < vec_len (rm->client_state_by_sw_if_index); i++)
1160     {
1161       cs = &rm->client_state_by_sw_if_index[i];
1162       if (cs->enabled)
1163         {
1164           if (cs->T1_due_time != DBL_MAX && cs->T1_due_time > current_time)
1165             {
1166               sprintf (buf1, "%u remaining",
1167                        (u32) round (cs->T1_due_time - current_time));
1168             }
1169           else
1170             sprintf (buf1, "timeout");
1171           if (cs->T2_due_time != DBL_MAX && cs->T2_due_time > current_time)
1172             sprintf (buf2, "%u remaining",
1173                      (u32) round (cs->T2_due_time - current_time));
1174           else
1175             sprintf (buf2, "timeout");
1176           if (cs->rebinding)
1177             rebinding = ", REBINDING";
1178           else
1179             rebinding = "";
1180           prefix_group =
1181             pm->prefix_group_name_by_index[cs->prefix_group_index];
1182           if (cs->T1)
1183             vlib_cli_output (vm,
1184                              "sw_if_index: %u, prefix group: %s, T1: %u (%s), "
1185                              "T2: %u (%s), server index: %d%s", i,
1186                              prefix_group, cs->T1, buf1, cs->T2, buf2,
1187                              cs->server_index, rebinding);
1188           else
1189             vlib_cli_output (vm, "sw_if_index: %u, prefix group: %s%s", i,
1190                              prefix_group, rebinding);
1191         }
1192     }
1193
1194   return error;
1195 }
1196
1197 /* *INDENT-OFF* */
1198 VLIB_CLI_COMMAND (ip6_pd_clients_show_command, static) = {
1199   .path = "show ip6 pd clients",
1200   .short_help = "show ip6 pd clients",
1201   .function = ip6_pd_clients_show_command_function,
1202 };
1203 /* *INDENT-ON* */
1204
1205
1206
1207 int
1208 dhcp6_pd_client_enable_disable (u32 sw_if_index,
1209                                 const u8 * prefix_group, u8 enable)
1210 {
1211   dhcp6_pd_client_cp_main_t *rm = &dhcp6_pd_client_cp_main;
1212   ip6_prefix_main_t *pm = &ip6_prefix_main;
1213   vnet_main_t *vnm = rm->vnet_main;
1214   client_state_t *client_state;
1215   static client_state_t empty_config = {
1216     0
1217   };
1218   prefix_info_t *prefix_info;
1219   prefix_info_t *prefix_list = 0;
1220   u32 prefix_group_index;
1221
1222   if (!vnet_sw_interface_is_api_valid (vnm, sw_if_index))
1223     {
1224       clib_warning ("Invalid sw_if_index");
1225       return VNET_API_ERROR_INVALID_VALUE;
1226     }
1227
1228   vec_validate_init_empty (rm->client_state_by_sw_if_index, sw_if_index,
1229                            empty_config);
1230   client_state = &rm->client_state_by_sw_if_index[sw_if_index];
1231
1232   u8 old_enabled = client_state->enabled;
1233
1234   if (enable)
1235     {
1236       if (strnlen ((const char *) prefix_group, 64) == 64
1237           || prefix_group[0] == '\0')
1238         return VNET_API_ERROR_INVALID_VALUE;
1239       prefix_group_index =
1240         prefix_group_find_or_create (prefix_group, !old_enabled);
1241       if (old_enabled
1242           && prefix_group_index != client_state->prefix_group_index)
1243         return VNET_API_ERROR_INVALID_VALUE;
1244     }
1245
1246   if (!old_enabled && enable)
1247     {
1248       client_state->enabled = 1;
1249       client_state->prefix_group_index = prefix_group_index;
1250       ASSERT (client_state->prefix_group_index != ~0);
1251       client_state->server_index = ~0;
1252
1253       rm->n_clients++;
1254       if (rm->n_clients == 1)
1255         {
1256           enable_process ();
1257           dhcp6_clients_enable_disable (1);
1258         }
1259
1260       ip6_link_enable (sw_if_index);
1261       send_client_message_start_stop (sw_if_index, ~0, DHCPV6_MSG_SOLICIT,
1262                                       0, 1);
1263     }
1264   else if (old_enabled && !enable)
1265     {
1266       send_client_message_start_stop (sw_if_index, ~0, ~0, 0, 0);
1267
1268       rm->n_clients--;
1269       if (rm->n_clients == 0)
1270         {
1271           dhcp6_clients_enable_disable (0);
1272           disable_process ();
1273         }
1274
1275       vec_validate (prefix_list, 0);
1276
1277       /* *INDENT-OFF* */
1278       pool_foreach (prefix_info, pm->prefix_pool,
1279       ({
1280         if (is_dhcpv6_pd_prefix (prefix_info) &&
1281             prefix_info->opaque_data == sw_if_index)
1282           {
1283             ASSERT (sw_if_index < vec_len (rm->client_state_by_sw_if_index) &&
1284                     rm->client_state_by_sw_if_index[sw_if_index].enabled);
1285             client_state_t *client_state =
1286               &rm->client_state_by_sw_if_index[sw_if_index];
1287             prefix_list[0] = *prefix_info;
1288             send_client_message_start_stop (sw_if_index,
1289                                             client_state->server_index,
1290                                             DHCPV6_MSG_RELEASE, prefix_list,
1291                                             1);
1292             u32 prefix_index = prefix_info - pm->prefix_pool;
1293             notify_prefix_add_del (prefix_index, 0);
1294             set_is_dhcpv6_pd_prefix (prefix_info, 0);
1295             pool_put (pm->prefix_pool, prefix_info);
1296           }
1297       }));
1298       /* *INDENT-ON* */
1299
1300       vec_free (prefix_list);
1301
1302       clib_memset (client_state, 0, sizeof (*client_state));
1303     }
1304
1305   return 0;
1306 }
1307
1308 static clib_error_t *
1309 dhcp6_pd_client_enable_disable_command_fn (vlib_main_t *
1310                                            vm,
1311                                            unformat_input_t
1312                                            * input, vlib_cli_command_t * cmd)
1313 {
1314   dhcp6_pd_client_cp_main_t *rm = &dhcp6_pd_client_cp_main;
1315   vnet_main_t *vnm = rm->vnet_main;
1316   clib_error_t *error = 0;
1317   u8 *prefix_group = 0;
1318   u32 sw_if_index = ~0;
1319   u8 enable = 1;
1320   unformat_input_t _line_input, *line_input = &_line_input;
1321
1322   if (!unformat_user (input, unformat_line_input, line_input))
1323     return 0;
1324
1325   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1326     {
1327       if (unformat
1328           (line_input, "%U", unformat_vnet_sw_interface, vnm, &sw_if_index))
1329         ;
1330       else if (unformat (line_input, "prefix group %s", &prefix_group));
1331       else if (unformat (line_input, "disable"))
1332         enable = 0;
1333       else
1334         {
1335           error = clib_error_return (0, "unexpected input `%U'",
1336                                      format_unformat_error, line_input);
1337           goto done;
1338         }
1339     }
1340
1341   if (prefix_group == 0 && enable)
1342     error = clib_error_return (0, "Prefix group must be set when enabling");
1343   else if (sw_if_index != ~0)
1344     {
1345       if (dhcp6_pd_client_enable_disable (sw_if_index, prefix_group, enable)
1346           != 0)
1347         error = clib_error_return (0, "Invalid sw_if_index or prefix group");
1348     }
1349   else
1350     error = clib_error_return (0, "Missing sw_if_index");
1351
1352 done:
1353   vec_free (prefix_group);
1354   unformat_free (line_input);
1355
1356   return error;
1357 }
1358
1359 /*?
1360  * This command is used to enable/disable DHCPv6 PD client
1361  * on particular interface.
1362  *
1363  * @cliexpar
1364  * @parblock
1365  * Example of how to enable DHCPv6 PD client:
1366  * @cliexcmd{dhcp6 pd client GigabitEthernet2/0/0 prefix group my-pd-group}
1367  * Example of how to disable DHCPv6 PD client:
1368  * @cliexcmd{dhcp6 pd client GigabitEthernet2/0/0 disable}
1369  * @endparblock
1370 ?*/
1371 /* *INDENT-OFF* */
1372 VLIB_CLI_COMMAND (dhcp6_pd_client_enable_disable_command, static) = {
1373   .path = "dhcp6 pd client",
1374   .short_help = "dhcp6 pd client <interface> (prefix group <string> | disable)",
1375   .function = dhcp6_pd_client_enable_disable_command_fn,
1376 };
1377 /* *INDENT-ON* */
1378
1379 #include <vlib/unix/plugin.h>
1380
1381 static clib_error_t *
1382 dhcp_pd_client_cp_init (vlib_main_t * vm)
1383 {
1384   dhcp6_pd_client_cp_main_t *rm = &dhcp6_pd_client_cp_main;
1385
1386   rm->vlib_main = vm;
1387   rm->vnet_main = vnet_get_main ();
1388   rm->api_main = vlibapi_get_main ();
1389   rm->node_index = dhcp6_pd_client_cp_process_node.index;
1390
1391   return (NULL);
1392 }
1393
1394 VLIB_INIT_FUNCTION (dhcp_pd_client_cp_init);
1395
1396 /*
1397  * fd.io coding-style-patch-verification: ON
1398  *
1399  * Local Variables:
1400  * eval: (c-set-style "gnu")
1401  * End:
1402  */