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