src/plugins/dhcp/dhcp6_ia_na_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 <vnet/vnet_msg_enum.h>
  19 #include <dhcp/dhcp6_packet.h>
  20 #include <dhcp/dhcp6_ia_na_client_dp.h>
  21 #include <vnet/ip/ip.h>
  22 #include <vnet/ip/ip6.h>
  23 #include <float.h>
  24 #include <math.h>
  25
  26 typedef struct
  27 {
  28   u32 sw_if_index;
  29   ip6_address_t address;
  30   u32 preferred_lt;
  31   u32 valid_lt;
  32   f64 due_time;
  33 } address_info_t;
  34
  35 typedef struct
  36 {
  37   u8 enabled;
  38   u32 server_index;
  39   u32 T1;
  40   u32 T2;
  41   f64 T1_due_time;
  42   f64 T2_due_time;
  43   u32 address_count;
  44   u8 rebinding;
  45 } client_state_t;
  46
  47 typedef struct
  48 {
  49   address_info_t *address_pool;
  50   client_state_t *client_state_by_sw_if_index;
  51   u32 n_clients;
  52   f64 max_valid_due_time;
  53
  54   /* convenience */
  55   vlib_main_t *vlib_main;
  56   vnet_main_t *vnet_main;
  57   api_main_t *api_main;
  58   u32 node_index;
  59 } dhcp6_client_cp_main_t;
  60
  61 static dhcp6_client_cp_main_t dhcp6_client_cp_main;
  62
  63 enum
  64 {
  65   RD_CP_EVENT_INTERRUPT,
  66   RD_CP_EVENT_DISABLE,
  67 };
  68
  69 static void
  70 send_client_message_start_stop (u32 sw_if_index, u32 server_index,
  71                                 u8 msg_type, address_info_t * address_list,
  72                                 u8 start)
  73 {
  74   dhcp6_client_cp_main_t *rm = &dhcp6_client_cp_main;
  75   dhcp6_send_client_message_params_t params = { 0, };
  76   dhcp6_send_client_message_params_address_t *addresses = 0, *addr;
  77   u32 i;
  78
  79   ASSERT (sw_if_index < vec_len (rm->client_state_by_sw_if_index) &&
  80           rm->client_state_by_sw_if_index[sw_if_index].enabled);
  81   client_state_t *client_state =
  82     &rm->client_state_by_sw_if_index[sw_if_index];
  83
  84   params.sw_if_index = sw_if_index;
  85   params.server_index = server_index;
  86   params.msg_type = msg_type;
  87   if (start)
  88     {
  89       if (msg_type == DHCPV6_MSG_SOLICIT)
  90         {
  91           params.irt = 1;
  92           params.mrt = 120;
  93         }
  94       else if (msg_type == DHCPV6_MSG_REQUEST)
  95         {
  96           params.irt = 1;
  97           params.mrt = 30;
  98           params.mrc = 10;
  99         }
 100       else if (msg_type == DHCPV6_MSG_RENEW)
 101         {
 102           params.irt = 10;
 103           params.mrt = 600;
 104           f64 current_time = vlib_time_now (rm->vlib_main);
 105           i32 diff_time = client_state->T2 - current_time;
 106           if (diff_time < 0)
 107             diff_time = 0;
 108           params.mrd = diff_time;
 109         }
 110       else if (msg_type == DHCPV6_MSG_REBIND)
 111         {
 112           params.irt = 10;
 113           params.mrt = 600;
 114           f64 current_time = vlib_time_now (rm->vlib_main);
 115           i32 diff_time = rm->max_valid_due_time - current_time;
 116           if (diff_time < 0)
 117             diff_time = 0;
 118           params.mrd = diff_time;
 119         }
 120       else if (msg_type == DHCPV6_MSG_RELEASE)
 121         {
 122           params.mrc = 1;
 123         }
 124     }
 125
 126   params.T1 = 0;
 127   params.T2 = 0;
 128   if (vec_len (address_list) != 0)
 129     vec_validate (addresses, vec_len (address_list) - 1);
 130   for (i = 0; i < vec_len (address_list); i++)
 131     {
 132       address_info_t *address = &address_list[i];
 133       addr = &addresses[i];
 134       addr->valid_lt = address->valid_lt;
 135       addr->preferred_lt = address->preferred_lt;
 136       addr->address = address->address;
 137     }
 138   params.addresses = addresses;
 139
 140   dhcp6_send_client_message (rm->vlib_main, sw_if_index, !start, &params);
 141
 142   vec_free (params.addresses);
 143 }
 144
 145 static void interrupt_process (void);
 146
 147 static u32
 148 ip6_enable (u32 sw_if_index)
 149 {
 150   dhcp6_client_cp_main_t *rm = &dhcp6_client_cp_main;
 151   clib_error_t *rv;
 152
 153   rv = enable_ip6_interface (rm->vlib_main, sw_if_index);
 154
 155   return rv != 0;
 156 }
 157
 158 static u8
 159 ip6_addresses_equal (ip6_address_t * address1, ip6_address_t * address2)
 160 {
 161   if (address1->as_u64[0] != address2->as_u64[0])
 162     return 0;
 163   return address1->as_u64[1] == address2->as_u64[1];
 164 }
 165
 166 static clib_error_t *
 167 dhcp6_reply_event_handler (vl_api_dhcp6_reply_event_t * mp)
 168 {
 169   dhcp6_client_cp_main_t *rm = &dhcp6_client_cp_main;
 170   vlib_main_t *vm = rm->vlib_main;
 171   client_state_t *client_state;
 172   ip6_address_t *address;
 173   u32 sw_if_index;
 174   u32 n_addresses;
 175   vl_api_dhcp6_address_info_t *api_address;
 176   u32 inner_status_code;
 177   u32 status_code;
 178   u32 server_index;
 179   f64 current_time;
 180   clib_error_t *error = 0;
 181   u32 i;
 182
 183   current_time = vlib_time_now (vm);
 184
 185   sw_if_index = ntohl (mp->sw_if_index);
 186
 187   if (sw_if_index >= vec_len (rm->client_state_by_sw_if_index))
 188     return 0;
 189
 190   client_state = &rm->client_state_by_sw_if_index[sw_if_index];
 191
 192   if (!client_state->enabled)
 193     return 0;
 194
 195   server_index = ntohl (mp->server_index);
 196
 197   n_addresses = ntohl (mp->n_addresses);
 198
 199   inner_status_code = ntohs (mp->inner_status_code);
 200   status_code = ntohs (mp->status_code);
 201
 202   if (mp->msg_type == DHCPV6_MSG_API_ADVERTISE
 203       && client_state->server_index == ~0)
 204     {
 205       address_info_t *address_list = 0, *address_info;
 206
 207       if (inner_status_code == DHCPV6_STATUS_NOADDRS_AVAIL)
 208         {
 209           clib_warning
 210             ("Advertise message arrived with NoAddrsAvail status code");
 211           return 0;
 212         }
 213
 214       if (n_addresses > 0)
 215         vec_validate (address_list, n_addresses - 1);
 216       for (i = 0; i < n_addresses; i++)
 217         {
 218           api_address = &mp->addresses[i];
 219           address = (ip6_address_t *) api_address->address;
 220
 221           address_info = &address_list[i];
 222           address_info->address = *address;
 223           address_info->preferred_lt = 0;
 224           address_info->valid_lt = 0;
 225         }
 226
 227       client_state->server_index = server_index;
 228
 229       send_client_message_start_stop (sw_if_index, server_index,
 230                                       DHCPV6_MSG_REQUEST, address_list, 1);
 231       vec_free (address_list);
 232     }
 233
 234   if (mp->msg_type != DHCPV6_MSG_API_REPLY)
 235     return 0;
 236
 237   if (!client_state->rebinding && client_state->server_index != server_index)
 238     {
 239       clib_warning ("Reply message arrived with Server ID different "
 240                     "from that in Request or Renew message");
 241       return 0;
 242     }
 243
 244   if (inner_status_code == DHCPV6_STATUS_NOADDRS_AVAIL)
 245     {
 246       clib_warning ("Reply message arrived with NoAddrsAvail status code");
 247       if (n_addresses > 0)
 248         {
 249           clib_warning
 250             ("Invalid Reply message arrived: It contains NoAddrsAvail "
 251              "status code but also contains addresses");
 252           return 0;
 253         }
 254     }
 255
 256   if (status_code == DHCPV6_STATUS_UNSPEC_FAIL)
 257     {
 258       clib_warning ("Reply message arrived with UnspecFail status code");
 259       return 0;
 260     }
 261
 262   send_client_message_start_stop (sw_if_index, server_index,
 263                                   mp->msg_type, 0, 0);
 264
 265   for (i = 0; i < n_addresses; i++)
 266     {
 267       address_info_t *address_info = 0;
 268       u32 valid_time;
 269       u32 preferred_time;
 270
 271       api_address = &mp->addresses[i];
 272
 273       address = (ip6_address_t *) api_address->address;
 274
 275       if (ip6_address_is_link_local_unicast (address))
 276         continue;
 277
 278       valid_time = ntohl (api_address->valid_time);
 279       preferred_time = ntohl (api_address->preferred_time);
 280
 281       if (preferred_time > valid_time)
 282         continue;
 283
 284       u8 address_already_present = 0;
 285       /* *INDENT-OFF* */
 286       pool_foreach (address_info, rm->address_pool,
 287       ({
 288         if (address_info->sw_if_index != sw_if_index)
 289           ;
 290         else if (!ip6_addresses_equal (&address_info->address, address))
 291           ;
 292         else
 293           {
 294             address_already_present = 1;
 295             goto address_pool_foreach_out;
 296           }
 297       }));
 298       /* *INDENT-ON* */
 299     address_pool_foreach_out:
 300
 301       if (address_already_present)
 302         {
 303           address_info->preferred_lt = preferred_time;
 304           address_info->valid_lt = valid_time;
 305           address_info->due_time = current_time + valid_time;
 306           if (address_info->due_time > rm->max_valid_due_time)
 307             rm->max_valid_due_time = address_info->due_time;
 308           continue;
 309         }
 310
 311       if (valid_time == 0)
 312         continue;
 313
 314       pool_get (rm->address_pool, address_info);
 315       address_info->sw_if_index = sw_if_index;
 316       address_info->address = *address;
 317       address_info->preferred_lt = preferred_time;
 318       address_info->valid_lt = valid_time;
 319       address_info->due_time = current_time + valid_time;
 320       if (address_info->due_time > rm->max_valid_due_time)
 321         rm->max_valid_due_time = address_info->due_time;
 322       rm->client_state_by_sw_if_index[sw_if_index].address_count++;
 323
 324       error = ip6_add_del_interface_address (vm, sw_if_index,
 325                                              &address_info->address, 64, 0);
 326       if (error)
 327         clib_warning ("Failed to add interface address");
 328     }
 329
 330   client_state->server_index = server_index;
 331   client_state->T1 = ntohl (mp->T1);
 332   client_state->T2 = ntohl (mp->T2);
 333   if (client_state->T1 != 0)
 334     client_state->T1_due_time = current_time + client_state->T1;
 335   if (client_state->T2 != 0)
 336     client_state->T2_due_time = current_time + client_state->T2;
 337   client_state->rebinding = 0;
 338
 339   interrupt_process ();
 340
 341   return error;
 342 }
 343
 344 static address_info_t *
 345 create_address_list (u32 sw_if_index)
 346 {
 347   dhcp6_client_cp_main_t *rm = &dhcp6_client_cp_main;
 348   address_info_t *address_info, *address_list = 0;;
 349
 350   /* *INDENT-OFF* */
 351   pool_foreach (address_info, rm->address_pool,
 352   ({
 353     if (address_info->sw_if_index == sw_if_index)
 354       {
 355         u32 pos = vec_len (address_list);
 356         vec_validate (address_list, pos);
 357         clib_memcpy (&address_list[pos], address_info, sizeof (*address_info));
 358       }
 359   }));
 360   /* *INDENT-ON* */
 361
 362   return address_list;
 363 }
 364
 365 VNET_DHCP6_REPLY_EVENT_FUNCTION (dhcp6_reply_event_handler);
 366
 367 static uword
 368 dhcp6_client_cp_process (vlib_main_t * vm, vlib_node_runtime_t * rt,
 369                          vlib_frame_t * f)
 370 {
 371   dhcp6_client_cp_main_t *rm = &dhcp6_client_cp_main;
 372   address_info_t *address_info;
 373   client_state_t *client_state;
 374   f64 sleep_time = 1e9;
 375   clib_error_t *error;
 376   f64 current_time;
 377   f64 due_time;
 378   uword event_type;
 379   uword *event_data = 0;
 380   int i;
 381
 382   while (1)
 383     {
 384       vlib_process_wait_for_event_or_clock (vm, sleep_time);
 385       event_type = vlib_process_get_events (vm, &event_data);
 386       vec_reset_length (event_data);
 387
 388       if (event_type == RD_CP_EVENT_DISABLE)
 389         {
 390           vlib_node_set_state (vm, rm->node_index, VLIB_NODE_STATE_DISABLED);
 391           sleep_time = 1e9;
 392           continue;
 393         }
 394
 395       current_time = vlib_time_now (vm);
 396       do
 397         {
 398           due_time = current_time + 1e9;
 399           /* *INDENT-OFF* */
 400           pool_foreach (address_info, rm->address_pool,
 401           ({
 402             if (address_info->due_time > current_time)
 403               {
 404                 if (address_info->due_time < due_time)
 405                   due_time = address_info->due_time;
 406               }
 407             else
 408               {
 409                 u32 sw_if_index = address_info->sw_if_index;
 410                 error = ip6_add_del_interface_address (vm, sw_if_index,
 411                                                        &address_info->address,
 412                                                        64, 1);
 413                 if (error)
 414                     clib_warning ("Failed to delete interface address");
 415                 pool_put (rm->address_pool, address_info);
 416                 /* make sure ip6 stays enabled */
 417                 ip6_enable (sw_if_index);
 418                 client_state = &rm->client_state_by_sw_if_index[sw_if_index];
 419                 if (--client_state->address_count == 0)
 420                   {
 421                     client_state->rebinding = 0;
 422                     client_state->server_index = ~0;
 423                     send_client_message_start_stop (sw_if_index, ~0,
 424                                                     DHCPV6_MSG_SOLICIT,
 425                                                     0, 1);
 426                   }
 427               }
 428           }));
 429           /* *INDENT-ON* */
 430           for (i = 0; i < vec_len (rm->client_state_by_sw_if_index); i++)
 431             {
 432               client_state_t *cs = &rm->client_state_by_sw_if_index[i];
 433               if (cs->enabled && cs->server_index != ~0)
 434                 {
 435                   if (cs->T2_due_time > current_time)
 436                     {
 437                       if (cs->T2_due_time < due_time)
 438                         due_time = cs->T2_due_time;
 439                       if (cs->T1_due_time > current_time)
 440                         {
 441                           if (cs->T1_due_time < due_time)
 442                             due_time = cs->T1_due_time;
 443                         }
 444                       else
 445                         {
 446                           cs->T1_due_time = DBL_MAX;
 447                           address_info_t *address_list;
 448                           address_list = create_address_list (i);
 449                           cs->rebinding = 1;
 450                           send_client_message_start_stop (i, cs->server_index,
 451                                                           DHCPV6_MSG_RENEW,
 452                                                           address_list, 1);
 453                           vec_free (address_list);
 454                         }
 455                     }
 456                   else
 457                     {
 458                       cs->T2_due_time = DBL_MAX;
 459                       address_info_t *address_list;
 460                       address_list = create_address_list (i);
 461                       cs->rebinding = 1;
 462                       send_client_message_start_stop (i, ~0,
 463                                                       DHCPV6_MSG_REBIND,
 464                                                       address_list, 1);
 465                       vec_free (address_list);
 466                     }
 467                 }
 468             }
 469           current_time = vlib_time_now (vm);
 470         }
 471       while (due_time < current_time);
 472
 473       sleep_time = due_time - current_time;
 474     }
 475
 476   return 0;
 477 }
 478
 479 /* *INDENT-OFF* */
 480 VLIB_REGISTER_NODE (dhcp6_client_cp_process_node) = {
 481     .function = dhcp6_client_cp_process,
 482     .type = VLIB_NODE_TYPE_PROCESS,
 483     .name = "dhcp6-client-cp-process",
 484 };
 485 /* *INDENT-ON* */
 486
 487 static void
 488 interrupt_process (void)
 489 {
 490   dhcp6_client_cp_main_t *rm = &dhcp6_client_cp_main;
 491   vlib_main_t *vm = rm->vlib_main;
 492
 493   vlib_process_signal_event (vm, dhcp6_client_cp_process_node.index,
 494                              RD_CP_EVENT_INTERRUPT, 0);
 495 }
 496
 497 static void
 498 disable_process (void)
 499 {
 500   dhcp6_client_cp_main_t *rm = &dhcp6_client_cp_main;
 501   vlib_main_t *vm = rm->vlib_main;
 502
 503   vlib_process_signal_event (vm, dhcp6_client_cp_process_node.index,
 504                              RD_CP_EVENT_DISABLE, 0);
 505 }
 506
 507 static void
 508 enable_process (void)
 509 {
 510   dhcp6_client_cp_main_t *rm = &dhcp6_client_cp_main;
 511   vlib_main_t *vm = rm->vlib_main;
 512   vlib_node_t *node;
 513
 514   node = vec_elt (vm->node_main.nodes, rm->node_index);
 515
 516   vlib_node_set_state (vm, rm->node_index, VLIB_NODE_STATE_POLLING);
 517   vlib_start_process (vm, node->runtime_index);
 518 }
 519
 520 static clib_error_t *
 521 dhcp6_addresses_show_command_function (vlib_main_t * vm,
 522                                        unformat_input_t * input,
 523                                        vlib_cli_command_t * cmd)
 524 {
 525   dhcp6_client_cp_main_t *dm = &dhcp6_client_cp_main;
 526   clib_error_t *error = 0;
 527   address_info_t *address_info;
 528   f64 current_time = vlib_time_now (vm);
 529
 530   /* *INDENT-OFF* */
 531   pool_foreach (address_info, dm->address_pool,
 532   ({
 533     vlib_cli_output (vm, "address: %U, "
 534                      "preferred lifetime: %u, valid lifetime: %u "
 535                      "(%f remaining)",
 536                      format_ip6_address, &address_info->address,
 537                      address_info->preferred_lt, address_info->valid_lt,
 538                      address_info->due_time - current_time);
 539   }));
 540   /* *INDENT-ON* */
 541
 542   return error;
 543 }
 544
 545 /* *INDENT-OFF* */
 546 VLIB_CLI_COMMAND (dhcp6_addresses_show_command, static) = {
 547   .path = "show dhcp6 addresses",
 548   .short_help = "show dhcp6 addresses",
 549   .function = dhcp6_addresses_show_command_function,
 550 };
 551 /* *INDENT-ON* */
 552
 553 static clib_error_t *
 554 dhcp6_clients_show_command_function (vlib_main_t * vm,
 555                                      unformat_input_t * input,
 556                                      vlib_cli_command_t * cmd)
 557 {
 558   dhcp6_client_cp_main_t *rm = &dhcp6_client_cp_main;
 559   clib_error_t *error = 0;
 560   client_state_t *cs;
 561   f64 current_time = vlib_time_now (vm);
 562   char buf1[256];
 563   char buf2[256];
 564   const char *rebinding;
 565   u32 i;
 566
 567   for (i = 0; i < vec_len (rm->client_state_by_sw_if_index); i++)
 568     {
 569       cs = &rm->client_state_by_sw_if_index[i];
 570       if (cs->enabled)
 571         {
 572           if (cs->T1_due_time != DBL_MAX && cs->T1_due_time > current_time)
 573             {
 574               sprintf (buf1, "%u remaining",
 575                        (u32) round (cs->T1_due_time - current_time));
 576             }
 577           else
 578             sprintf (buf1, "timeout");
 579           if (cs->T2_due_time != DBL_MAX && cs->T2_due_time > current_time)
 580             sprintf (buf2, "%u remaining",
 581                      (u32) round (cs->T2_due_time - current_time));
 582           else
 583             sprintf (buf2, "timeout");
 584           if (cs->rebinding)
 585             rebinding = ", REBINDING";
 586           else
 587             rebinding = "";
 588           if (cs->T1)
 589             vlib_cli_output (vm,
 590                              "sw_if_index: %u, T1: %u (%s), "
 591                              "T2: %u (%s), server index: %d%s", i,
 592                              cs->T1, buf1, cs->T2, buf2,
 593                              cs->server_index, rebinding);
 594           else
 595             vlib_cli_output (vm, "sw_if_index: %u%s", i, rebinding);
 596         }
 597     }
 598
 599   return error;
 600 }
 601
 602 /* *INDENT-OFF* */
 603 VLIB_CLI_COMMAND (dhcp6_clients_show_command, static) = {
 604   .path = "show dhcp6 clients",
 605   .short_help = "show dhcp6 clients",
 606   .function = dhcp6_clients_show_command_function,
 607 };
 608 /* *INDENT-ON* */
 609
 610 int
 611 dhcp6_client_enable_disable (u32 sw_if_index, u8 enable)
 612 {
 613   dhcp6_client_cp_main_t *rm = &dhcp6_client_cp_main;
 614   vnet_main_t *vnm = rm->vnet_main;
 615   vlib_main_t *vm = rm->vlib_main;
 616   client_state_t *client_state;
 617   client_state_t empty_config = { 0 };
 618   address_info_t *address_info;
 619   clib_error_t *error;
 620
 621   if (!vnet_sw_interface_is_api_valid (vnm, sw_if_index))
 622     {
 623       clib_warning ("Invalid sw_if_index");
 624       return 1;
 625     }
 626
 627   vec_validate_init_empty (rm->client_state_by_sw_if_index, sw_if_index,
 628                            empty_config);
 629   client_state = &rm->client_state_by_sw_if_index[sw_if_index];
 630
 631   u8 old_enabled = client_state->enabled;
 632   if (enable)
 633     client_state->enabled = 1;
 634   client_state->server_index = ~0;
 635
 636   if (!old_enabled && enable)
 637     {
 638       rm->n_clients++;
 639       if (rm->n_clients == 1)
 640         {
 641           enable_process ();
 642           dhcp6_clients_enable_disable (1);
 643         }
 644
 645       ip6_enable (sw_if_index);
 646       send_client_message_start_stop (sw_if_index, ~0, DHCPV6_MSG_SOLICIT,
 647                                       0, 1);
 648     }
 649   else if (old_enabled && !enable)
 650     {
 651       send_client_message_start_stop (sw_if_index, ~0, ~0, 0, 0);
 652
 653       rm->n_clients--;
 654       if (rm->n_clients == 0)
 655         {
 656           dhcp6_clients_enable_disable (0);
 657           disable_process ();
 658         }
 659
 660       /* *INDENT-OFF* */
 661       pool_foreach (address_info, rm->address_pool,
 662       ({
 663         if (address_info->sw_if_index == sw_if_index)
 664           {
 665             ASSERT (sw_if_index < vec_len (rm->client_state_by_sw_if_index) &&
 666                     rm->client_state_by_sw_if_index[sw_if_index].enabled);
 667             client_state_t *client_state =
 668               &rm->client_state_by_sw_if_index[sw_if_index];
 669             send_client_message_start_stop (sw_if_index,
 670                                             client_state->server_index,
 671                                             DHCPV6_MSG_RELEASE, address_info,
 672                                             1);
 673             error = ip6_add_del_interface_address (vm, sw_if_index,
 674                                                    &address_info->address,
 675                                                    64, 1);
 676             if (error)
 677                 clib_warning ("Failed to delete interface address");
 678             pool_put (rm->address_pool, address_info);
 679           }
 680       }));
 681       /* *INDENT-ON* */
 682     }
 683
 684   if (!enable)
 685     client_state->enabled = 0;
 686
 687   return 0;
 688 }
 689
 690 static clib_error_t *
 691 dhcp6_client_enable_disable_command_fn (vlib_main_t * vm,
 692                                         unformat_input_t * input,
 693                                         vlib_cli_command_t * cmd)
 694 {
 695   dhcp6_client_cp_main_t *rm = &dhcp6_client_cp_main;
 696   vnet_main_t *vnm = rm->vnet_main;
 697   clib_error_t *error = 0;
 698   u32 sw_if_index = ~0;
 699   u8 enable = 1;
 700   unformat_input_t _line_input, *line_input = &_line_input;
 701
 702   if (!unformat_user (input, unformat_line_input, line_input))
 703     return 0;
 704
 705   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 706     {
 707       if (unformat
 708           (line_input, "%U", unformat_vnet_sw_interface, vnm, &sw_if_index))
 709         ;
 710       else if (unformat (line_input, "disable"))
 711         enable = 0;
 712       else
 713         {
 714           error = clib_error_return (0, "unexpected input `%U'",
 715                                      format_unformat_error, line_input);
 716           goto done;
 717         }
 718     }
 719
 720   unformat_free (line_input);
 721
 722   if (sw_if_index != ~0)
 723     {
 724       if (dhcp6_client_enable_disable (sw_if_index, enable) != 0)
 725         error = clib_error_return (0, "Invalid sw_if_index");
 726     }
 727   else
 728     error = clib_error_return (0, "Missing sw_if_index");
 729
 730 done:
 731   return error;
 732 }
 733
 734 /*?
 735  * This command is used to enable/disable DHCPv6 client
 736  * on particular interface.
 737  *
 738  * @cliexpar
 739  * @parblock
 740  * Example of how to enable DHCPv6 client:
 741  * @cliexcmd{dhcp6 client GigabitEthernet2/0/0}
 742  * Example of how to disable DHCPv6 client:
 743  * @cliexcmd{dhcp6 client GigabitEthernet2/0/0 disable}
 744  * @endparblock
 745 ?*/
 746 /* *INDENT-OFF* */
 747 VLIB_CLI_COMMAND (dhcp6_client_enable_disable_command, static) = {
 748   .path = "dhcp6 client",
 749   .short_help = "dhcp6 client <interface> [disable]",
 750   .function = dhcp6_client_enable_disable_command_fn,
 751 };
 752 /* *INDENT-ON* */
 753
 754 static clib_error_t *
 755 dhcp_ia_na_client_cp_init (vlib_main_t * vm)
 756 {
 757   dhcp6_client_cp_main_t *rm = &dhcp6_client_cp_main;
 758
 759   rm->vlib_main = vm;
 760   rm->vnet_main = vnet_get_main ();
 761   rm->api_main = &api_main;
 762   rm->node_index = dhcp6_client_cp_process_node.index;
 763
 764   return NULL;
 765 }
 766
 767 VLIB_INIT_FUNCTION (dhcp_ia_na_client_cp_init);
 768
 769 /*
 770  * fd.io coding-style-patch-verification: ON
 771  *
 772  * Local Variables:
 773  * eval: (c-set-style "gnu")
 774  * End:
 775  */