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