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